Pixeles En Movimiento (Version 2)

Hola a todos amigos!! Espero que hayan practicado mucho ya con las aplicaciones pasadas y ahora continuaremos con la aplicación que realizamos anteriormente, la de los pixeles que se movian hacia el centro de la forma. Las modificaciones que realizaremos será que haga lo mismo pero ahora en cada uno de los 4 cuadrantes de la forma, es decir cada cuadrante tendrá sus propios pixeles creandose y desplazandose hacia el centro del cuadrante, ademá de que podremos controlar cual cuadrante esté activo y cual esté desactivado.

Para esta aplicación utilizaremos como base la que realizamos la vez anterior, pero ahora pintamos la forma de color negro y agregamos 3 timers más, es decir tendremos un total de 4 timers, ademas de un StatusBar en el fondo para señalar cuales cuadrantes están activos y cuales no lo están.

Bueno pues ahora colocamos el siguiente código en el archivo H de la aplicación, en la parte de las declaraciones del usuario privadas:


class TForm1 : public TForm
{
__published: // IDE-managed Components
        TTimer *Timer1;
        TTimer *Timer2;
        TTimer *Timer3;
        TTimer *Timer4;
        TStatusBar *StatusBar1;
        void __fastcall FormPaint(TObject *Sender);
        void __fastcall Timer1Timer(TObject *Sender);
        void __fastcall Timer2Timer(TObject *Sender);
        void __fastcall Timer3Timer(TObject *Sender);
        void __fastcall Timer4Timer(TObject *Sender);
        void __fastcall FormMouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y);
        void __fastcall FormResize(TObject *Sender);
private: // User declarations
        POINT Puntos[1000];
        int Contador;
        int MediaX, MediaY;
        POINT Puntos2[1000];
        int Contador2;
        int MediaX2, MediaY2;
        POINT Puntos3[1000];
        int Contador3;
        int MediaX3, MediaY3;
        POINT Puntos4[1000];
        int Contador4;
        int MediaX4, MediaY4;
public: // User declarations
        __fastcall TForm1(TComponent* Owner);
        COLORREF CambiarColor(COLORREF color,int &state);
};
//---------------------------------------------------------------------------


Ahora declaramos los siguientes atributos en donde esta declarado el Form1:


TForm1 *Form1;
int state1, state2, state3, state4;
COLORREF color1 = clRed, color2 = clGreen, color3 = clBlue, color4 = clWhite;


Después colocamos el código correspondiente a cada componente de la forma:


void __fastcall TForm1::FormPaint(TObject *Sender)
{
        for(int N = 0; N < 1000; N++)
        {
        Puntos[N].x = random(ClientWidth/2)-1;
        Puntos[N].y = random(ClientHeight/2)-1;
        Canvas->Pixels[Puntos[N].x][Puntos[N].y] = Form1->Color;
        }
        Contador = 0; // Inicializar el contador
        MediaX = ClientWidth / 4;
        MediaY = ClientHeight / 4;

        for(int N = 0; N < 1000; N++)
        {
        Puntos2[N].x = random(ClientWidth/2)-1;
        Puntos2[N].y = random(ClientHeight/2)-1;
        if(Puntos2[N].x < ClientWidth/2)
                Puntos2[N].x += ClientWidth/2;
        Canvas->Pixels[Puntos2[N].x][Puntos2[N].y] = Form1->Color;
        }
        Contador2 = 0; // Inicializar el contador
        MediaX2 = (ClientWidth/2) + (ClientWidth/4);
        MediaY2 = ClientHeight/4;

        for(int N = 0; N < 1000; N++)
        {
         // Calcular los 1000 puntos
        Puntos3[N].x = random(ClientWidth/2)-1;
        Puntos3[N].y = random(ClientHeight/2)-1;
        if(Puntos3[N].x > ClientWidth/2)
                Puntos3[N].x -= ClientWidth/2;
        if(Puntos3[N].y < ClientHeight/2)
                Puntos3[N].y += (ClientHeight/2)-1;
        Canvas->Pixels[Puntos3[N].x][Puntos3[N].y] = Form1->Color;
        }
        Contador3 = 0; // Inicializar el contador
        MediaX3 = (ClientWidth/2) - (ClientWidth/4);
        MediaY3 = (ClientHeight/2) + (ClientHeight/4);

        for(int N = 0; N < 1000; N++)
        {
        Puntos4[N].x = random(ClientWidth/2)-1;
        Puntos4[N].y = random(ClientHeight/2)-1;
        if(Puntos4[N].x < ClientWidth/2)
                Puntos4[N].x += ClientWidth/2;
        if(Puntos4[N].y < ClientHeight/2)
                Puntos4[N].y += ClientHeight/2;
        Canvas->Pixels[Puntos4[N].x][Puntos4[N].y] = Form1->Color;
        }
        Contador4 = 0; // Inicializar el contador
        MediaX4 = (ClientWidth/2) + (ClientWidth/4);
        MediaY4 = (ClientHeight/2) + (ClientHeight/4);

        StatusBar1->Panels->Items[0]->Width = ClientWidth/4;
        StatusBar1->Panels->Items[1]->Width = ClientWidth/4;
        StatusBar1->Panels->Items[2]->Width = ClientWidth/4;
        StatusBar1->Panels->Items[3]->Width = ClientWidth/4;
        }
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
        color1 = CambiarColor(color1, state1);
        for (int N = 0; N < 1000; N++)
        {
        Canvas->Pixels[Puntos[Contador].x][Puntos[Contador].y] = Form1->Color;
        Puntos[Contador].x += (Puntos[Contador].x < MediaX)*1 +
        (Puntos[Contador].x > MediaX)*-1;
        Puntos[Contador].y += (Puntos[Contador].y < MediaY)*1 +
        (Puntos[Contador].y > MediaY)*-1;
        if (Puntos[Contador].x == MediaX && Puntos[Contador].y == MediaY)
        {
        Puntos[Contador].x = random(ClientWidth/2)-1;
        Puntos[Contador].y = random(ClientHeight/2)-1;
        }
        Canvas->Pixels[Puntos[Contador].x][Puntos[Contador].y] = color1;
        Contador++; // Pasar al punto siguiente
        if (Contador == 1000)
        Contador = 0;
        }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Timer2Timer(TObject *Sender)
{
        color2 = CambiarColor(color2, state2);
        for (int N = 0; N < 1000; N++)
        {
        Canvas->Pixels[Puntos2[Contador2].x][Puntos2[Contador2].y] = Form1->Color;
        Puntos2[Contador2].x += (Puntos2[Contador2].x < MediaX2)*1 +
        (Puntos2[Contador2].x > MediaX2)*-1;
        Puntos2[Contador2].y += (Puntos2[Contador2].y < MediaY2)*1 +
        (Puntos2[Contador2].y > MediaY2)*-1;
        if (Puntos2[Contador2].x == MediaX2 && Puntos2[Contador2].y == MediaY2)
        {
        Puntos2[Contador2].x = random(ClientWidth/2)-1;
        Puntos2[Contador2].y = random(ClientHeight/2)-1;
        }
        if( Puntos2[Contador2].x < ClientWidth/2)
                Puntos2[Contador2].x += ClientWidth/2;
        Canvas->Pixels[Puntos2[Contador2].x][Puntos2[Contador2].y] = color2;
        Contador2++; // Pasar al punto siguiente
        if (Contador2 == 1000)
        Contador2 = 0;
        }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer3Timer(TObject *Sender)
{
        color3 = CambiarColor(color3, state1);
        for (int N = 0; N < 1000; N++)
        {
        Canvas->Pixels[Puntos3[Contador3].x][Puntos3[Contador3].y] = Form1->Color;
        Puntos3[Contador3].x += (Puntos3[Contador3].x < MediaX3)*1 +
        (Puntos3[Contador3].x > MediaX3)*-1;
        Puntos3[Contador3].y += (Puntos3[Contador3].y < MediaY3)*1 +
        (Puntos3[Contador3].y > MediaY3)*-1;
        if (Puntos3[Contador3].x == MediaX3 && Puntos3[Contador3].y == MediaY3)
        {
        Puntos3[Contador3].x = random(ClientWidth/2)-1; // de forma aleatoria
        Puntos3[Contador3].y = random(ClientHeight/2)-1;
        }
         if(Puntos3[Contador3].x > ClientWidth/2)
                Puntos3[Contador3].x -= ClientWidth/2;
        if(Puntos3[Contador3].y < ClientHeight/2)
                Puntos3[Contador3].y += ClientHeight/2;
        Canvas->Pixels[Puntos3[Contador3].x][Puntos3[Contador3].y] = color3;
        Contador3++; // Pasar al punto siguiente
        if (Contador3 == 1000)
        Contador3 = 0;
        }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer4Timer(TObject *Sender)
{
        color4 = CambiarColor(color4, state1);
        for (int N = 0; N < 1000; N++)
        {
        Canvas->Pixels[Puntos4[Contador4].x][Puntos4[Contador4].y] = Form1->Color;
        Puntos4[Contador4].x += (Puntos4[Contador4].x < MediaX4)*1 +
        (Puntos4[Contador4].x > MediaX4)*-1;
        Puntos4[Contador4].y += (Puntos4[Contador4].y < MediaY4)*1 +
        (Puntos4[Contador4].y > MediaY4)*-1;
        if (Puntos4[Contador4].x == MediaX4 && Puntos4[Contador4].y == MediaY4)
        {
        Puntos4[Contador4].x = random(ClientWidth/2)-1;
        Puntos4[Contador4].y = random(ClientHeight/2)-1;
        }
         if(Puntos4[Contador4].x < ClientWidth/2)
                Puntos4[Contador4].x += ClientWidth/2;
        if(Puntos4[Contador4].y < ClientHeight/2)
                Puntos4[Contador4].y += ClientHeight/2;
        Canvas->Pixels[Puntos4[Contador4].x][Puntos4[Contador4].y] = color4;
        Contador4++; // Pasar al punto siguiente
        if (Contador4 == 1000)
        Contador4 = 0;
        }
}
//---------------------------------------------------------------------------


Ahora para que nos salgan los mensajes de si está activo o desactivado el cuadrante correspondiente, abrimos el evento de la forma OnMouseDown y escribimos el código siguiente:


void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
        if(X < ClientWidth/2 && Y < ClientHeight/2)
        {
                if (Timer1->Enabled == false)
                {
                        Timer1->Enabled = true;
                        StatusBar1->Panels->Items[1]->Text = "Cuadrante 2: Activo";
                }
                else
                {
                        Timer1->Enabled = false;
                        StatusBar1->Panels->Items[1]->Text= "Cuadrante 2: Inactivo";
                }
        }
        if(X > ClientWidth/2 && Y < ClientHeight/2)
        {
                if (Timer2->Enabled == false)
                {
                        Timer2->Enabled = true;
                        StatusBar1->Panels->Items[0]->Text= "Cuadrante 1: Activo";
                }
                else
                {
                        Timer2->Enabled = false;
                        StatusBar1->Panels->Items[0]->Text= "Cuadrante 1: Inactivo";
                }
        }
        if(X < ClientWidth/2 && Y > ClientHeight/2)
        {
                if (Timer3->Enabled == false)
                {
                        Timer3->Enabled = true;
                        StatusBar1->Panels->Items[2]->Text= "Cuadrante 3: Activo";
                }
                else
                {
                        Timer3->Enabled = false;
                        StatusBar1->Panels->Items[2]->Text= "Cuadrante 3: Inactivo";
                }
        }
        if(X > ClientWidth/2 && Y > ClientHeight/2)
        {
                if (Timer4->Enabled == false)
                {
                        Timer4->Enabled = true;
                        StatusBar1->Panels->Items[3]->Text= "Cuadrante 4: Activo";
                }
                else
                {
                        Timer4->Enabled = false;
                        StatusBar1->Panels->Items[3]->Text= "Cuadrante 4: Inactivo";
                }
        }
}
//---------------------------------------------------------------------------
COLORREF TForm1::CambiarColor(COLORREF color,int &state)
{
        int red = GetRValue(color);
        int blue = GetBValue(color);
        int green = GetGValue(color);
        if (state == 0)
        {
                 green += 1;
                 if (green > 255)
                 {
                        green = 255;
                        state = 1;
                 }
        }
        else if (state == 1)
        {
                 blue += 1;
                 if (blue > 255)
                 {
                        blue = 255;
                        state = 2;
                 }
        }
        else if (state == 2)
        {
                 red += 1;
                 if (red > 255)
                 {
                        red = 255;
                        state = 3;
                 }
        }
        else if (state == 3)
        {
                green -=1;
                if (green < 100)
                {
                        green = 100;
                        state = 4;
                }
        }
        else if (state == 4)
        {
                blue -= 1;
                if (blue < 100)
                {
                        blue = 100;
                        state = 5;
                }
        }
        else if (state == 5)
        {
                red += 1;
                if (red < 100)
                {
                        red = 100;
                        state = 0;
                }
        }
        return RGB(red, green, blue);
}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormResize(TObject *Sender)
{
        Invalidate();
}
//---------------------------------------------------------------------------


El método que utilizamos arriba nos sirve para ir cambiando el color de los pixeles que se van dibujando sobre la forma. Además tambien abrimos el método OnResize de la forma y la linea que escribimos nos sirve para cuando expandamos la ventana con el programa en ejecución, con este código evitamos que se desfasen y se vea mal la aplicación.

Finalmente nuestra aplicación debería quedar de la siguiente manera:

Bueno chavos por esta ocasión fue todo, creo que estuvo bastante sencillo lo que realizamos pero así nos iremos acostumbrando a aplicaciones más completas después. Cuidense y estudien mucho pero sobre todo practiquen mucho las programación, sobre todo en C++ Builder para nuestro caso. Nos vemos en la próxima!.

Pixeles En Movimiento

Hola chavos que tal! Espero que estén todos muy bien y pues en esta ocasión continuaremos realizando aplicaciones en C++ Builder. Ahora crearemos un programa muy sencillo lo único que hará será mover pixeles hacia el centro de la pantalla. En esta ocasión utilizaremos la estructura POINT, la cual cuenta con campos para las posiciones X y Y en donde dibujaremos los pixeles, lo cual lo haremos de manera aleatoria en la forma.

Para esta aplicación lo único que utilizaremos será un Timer, el cual se encuentra en la pestaña System de la barra de componentes. Y también cambiamos el color de la forma a blanco, para evitar el rastro que dejan los pixeles en el efecto de movimiento.

Bueno pues para comenzar necesitamos ir al archivo H, donde está la definición de la clase TForm1 y agregar las siguientes declaraciones en la parte "private", debe quedar de la siguiente manera:


class TForm1 : public TForm
{
__published: // IDE-managed Components
        TTimer *Timer1;
        void __fastcall FormPaint(TObject *Sender);
        void __fastcall Timer1Timer(TObject *Sender);
private: // User declarations
        POINT Puntos[1000]; // Matriz para mantener la posición de 1000 puntos
        int Contador; // Contador general para la matriz anterior
        int MediaX, MediaY; // Punto medio del área de dibujo
public: // User declarations
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------


Ahora buscamos en evento de la forma llamado OnPaint y damos doble clic para abrirlo, entonces escribimos el siguiente código:


void __fastcall TForm1::FormPaint(TObject *Sender)
{
        for(int N = 0; N < 1000; N++)
        {
                // Calcular los 1000 puntos
                Puntos[N].x = random(ClientWidth); // de forma aleatoria
                Puntos[N].y = random(ClientHeight);
                Canvas->Pixels[Puntos[N].x][Puntos[N].y] = clBlack;
        }
        Contador = 0; // Inicializar el contador
        MediaX = ClientWidth / 2; // Y calcular el punto medio
        MediaY = ClientHeight / 2;
}
//---------------------------------------------------------------------------

Finalmente damos doble clic en el Timer agregado en la forma y escribimos el siguiente código:



void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
        for (int N = 0; N < 1000; N++)
        {
                // Desplazar 100 puntos en cada ciclo, probar en vez de 100 - 1000
                // Desactivar el punto de su posición actual
                Canvas->Pixels[Puntos[Contador].x][Puntos[Contador].y] = clWhite;
                // Calcular su nueva posición
                Puntos[Contador].x+=(Puntos[Contador].x<MediaX)*1+(Puntos[Contador].x>MediaX)*-1;
                Puntos[Contador].y+=(Puntos[Contador].y<MediaY)*1+(Puntos[Contador].y>MediaY)*-1;
                // Si el punto está en el centro del área debe desaparecer
                if (Puntos[Contador].x == MediaX && Puntos[Contador].y == MediaY)
                {
                        // Reapareciendo en un punto aleatorio
                        Puntos[Contador].x = random(ClientWidth);
                        Puntos[Contador].y = random(ClientHeight);
                }
                // Mostrarlo en la nueva posición
                Canvas->Pixels[Puntos[Contador].x][Puntos[Contador].y] = clRed;//Black;
                Contador++; // Pasar al punto siguiente
                // O al primero si ya se han recorrido todos
                if (Contador == 1000)
                Contador = 0;
        }
}
//---------------------------------------------------------------------------


Bueno finalmente compilamos y corremos nuestra aplicación y deberíamos tener algo por el estilo:

Bueno amigos terminamos por esta ocasión, la siguiente vez modificaremos nuestra aplicación para que se vea mejor y seguir prácticando nuetras habilidades con el C++ Builder, nos vemos hasta la próxima amigos!!

Dibujo De Un Rectángulo Utilizando La API De Windows (Versión 2)

Bueno chavos que onda!, pues en esta ocasión continuaremos con la aplicación para dibujar rectángulos que hicimos la vez anterior ¿recuerdan? Bueno pues trabajaremos con ese programa como base modificando varias cosas para realizar algo más avanzado.

Bueno primero tendremos que modificar la forma que teníamos y al final tenemos que tener una forma con los siguientes componentes:

-5 botones

-3 Edit (conocidos en C# como textBox)

-2 UpDown los cuales tendremos que asociar con 2 de los edit a través de su propiedad "Associate"

-7 TrackBar

-1 ComboBox

-6 Labels

Acomodamos los componentes de la siguiente manera:

Los botones realizan las mismas acciones que explicamos en la aplicación pasada, ahora la novedad de esta aplicación es que podemos manejar a nuestro gusto el tamaño de el rectángulo que deseamos dibujar, así como el color y estilo de la brocha (relleno) y el color y estilo del contorno (pluma).

El ancho y alto los manejamos con los Edit asociados con los UpDown, el color de relleno los cambiamos con los TrackBar de la parte superior combinando los 3 colores primarios (el famoso RGB), el ComboBox lo utilizamos para cambiar el estilo de pluma del contorno y los 3 TrackBar restantes los dejamos para manejar el color del contorno. Finalmente agregamos otro botón solo para cerrar la aplicación. El código es el siguiente:

int red=0, green=0, blue=0, largo=0, ancho=0, pred=255, pgreen=0, pblue=0, top=50, left=70;

void __fastcall TForm1::Button1Click(TObject *Sender)

{

        int ps = ComboBox1->ItemIndex;

        HPEN hpen, hpenOld;

        HBRUSH hbrush, hbrushOld;

        HDC hdc = this->Canvas->Handle;

        hpen = CreatePen(ps, TrackBar4->Position, RGB(pred, pgreen, pblue));

        hbrush = CreateSolidBrush(RGB(red, green, blue));

        hpenOld = SelectObject(hdc, hpen);

        hbrushOld = SelectObject(hdc, hbrush);

        Rectangle(hdc, top,left, Edit1->Text.ToInt()+top,Edit2->Text.ToInt()+left);

        SelectObject(hdc, hpenOld);

        DeleteObject(hpen);

        SelectObject(hdc, hbrushOld);

        DeleteObject(hbrush);

        largo = Edit1->Text.ToInt();

        ancho = Edit2->Text.ToInt();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::TrackBar1Change(TObject *Sender)

{

    red = this->TrackBar1->Position;

    Button1Click(Sender);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::TrackBar2Change(TObject *Sender)

{

     green = this -> TrackBar2 -> Position;

     Button1Click(Sender);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::TrackBar3Change(TObject *Sender)

{

     blue = this -> TrackBar3 -> Position;

     Button1Click(Sender);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

        Close();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::UpDown2Click(TObject *Sender, TUDBtnType Button)

{

        UpDown1Click(Sender, Button);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::TrackBar4Change(TObject *Sender)

{

        UpDown1Click(Sender, 0);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)

{

        TRect Recto2(125, 140, 300, 200);

        HDC hDC = Canvas->Handle;

        DrawEdge(hDC, &Recto2, BDR_RAISEDOUTER | BDR_SUNKENINNER, BF_RECT);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button4Click(TObject *Sender)

{

        RECT Recto;

        Recto.left = 70;

        Recto.top = 80;

        Recto.right = 370;

        Recto.bottom = 330;

        //Aqui utilizamos directamente el Canvas

        Canvas->Rectangle(Recto);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button5Click(TObject *Sender)

{

        TRect Recto(top,left, Edit1->Text.ToInt()+top,Edit2->Text.ToInt()+left);

        HDC hDC = Canvas->Handle;

        DrawEdge(hDC, &Recto, BDR_RAISEDOUTER | BDR_SUNKENINNER, BF_RECT);

        SetTextColor(hDC,RGB(red,green,blue));

        //char *cad="hola";

        char *cad=new char[Edit3->Text.Length()];

        strcpy(cad, Edit3->Text.c_str());

        DrawText(hDC,cad,strlen(cad),&Recto,DT_CENTER); //DT_RIGHT);//DT_LEFT;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::ComboBox1Change(TObject *Sender)

{

        Button1Click(Sender);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::UpDown1Click(TObject *Sender, TUDBtnType Button)

{

        int ps = ComboBox1->ItemIndex;

        HPEN hpen, hpenOld;

        HBRUSH hbrush, hbrushOld;

        HDC hdc = Canvas->Handle;

        hpen = CreatePen(ps, TrackBar4->Max, Form1->Color);

        hbrush = CreateSolidBrush(Form1->Color);

        hpenOld = SelectObject(hdc, hpen);

        hbrushOld = SelectObject(hdc, hbrush);

        Rectangle(hdc, top, left, largo + top, ancho + left);

        SelectObject(hdc, hpenOld);

        DeleteObject(hpen);

        SelectObject(hdc, hbrushOld);

        DeleteObject(hbrush);

        Button1Click(Sender);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::TrackBar5Change(TObject *Sender)

{

        pred = TrackBar5->Position;

        Button1Click(Sender);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::TrackBar6Change(TObject *Sender)

{

        pgreen = TrackBar6->Position;

        Button1Click(Sender);        

}

//---------------------------------------------------------------------------

void __fastcall TForm1::TrackBar7Change(TObject *Sender)

{

        pblue = TrackBar7->Position;

        Button1Click(Sender);

}

//---------------------------------------------------------------------------

Podemos correr ahora nuestra aplicación para probar lo hecho hasta ahora:

Podemos añadirle una función más al programa para que se vea más genial y de paso aprendemos nuevas cosas. Lo último que haremos sera que la función de dibujar se realice con el clic del ratón, y que su tamaño cambie al ser arrastrado con el cursor. Aquí tenemos el código para realiza estas acciones:

void TForm1::Borrar()

{

        int ps = ComboBox1->ItemIndex;

        HPEN hpen, hpenOld;

        HBRUSH hbrush, hbrushOld;

        HDC hdc = Canvas->Handle;

        hpen = CreatePen(ps, TrackBar4->Max, Form1->Color);

        hbrush = CreateSolidBrush(Form1->Color);

        hpenOld = SelectObject(hdc, hpen);

        hbrushOld = SelectObject(hdc, hbrush);

        Rectangle(hdc, top, left, largo + top, ancho + left);

        SelectObject(hdc, hpenOld);

        DeleteObject(hpen);

        SelectObject(hdc, hbrushOld);

        DeleteObject(hbrush);

}

 //------------------------------------------------------------------------

void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button,

      TShiftState Shift, int X, int Y)

{

        Borrar();

        top = X;

        left = Y;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormMouseUp(TObject *Sender, TMouseButton Button,

      TShiftState Shift, int X, int Y)

{

        if(Button==mbLeft)

        {

                Borrar();

                Edit1->Text = X - top;

                Edit2->Text = Y - left;

                Button1Click(Sender);

        }

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift,

      int X, int Y)

{

        if(Shift.Contains(ssLeft))

        {

                FormMouseUp(Sender, mbLeft, Shift, X, Y);

        }

}

//---------------------------------------------------------------------------

Ahora compilamos de nuevo y corremos la aplicación,  probamos la nueva función añadida.

Bueno amigos eso fue todo por esta ocasión, nos vemos en la siguiente para seguir realizando aplicaciones gráficas en C++ Builder y seguir aprendiendo. Hasta la próxima!

Dibujo De Un Rectángulo Utilizando La API De Windows

Que onda chavos!! Bueno pues aquí comenzamos con las aplicaciones de C++ y pues comenzaremos con algo simple y después modificaremos la aplicación para personalizarla y mejorarla, nuestra primera aplicación sera algo muy sencillo, la forma debe ser como se muestra enseguida:

La forma es muy básica y sencilla, solo tenemos 4 botones comunes y corrientes, con el texto Dibujar y a partir del 2° botón los numeramos hasta el 4. Cada uno de los botones lo único que hace es dibujar un rectángulo en la forma, aunque cada botón lo hace de una manera diferente.

El primer botón dibuja un rectángulo con color de relleno (brocha) y con color en el contorno (pluma), en este ejemplo dejamos el color de la brocha por defecto como azul y el color de la pluma como rojo. Los botones 2 y 3 dibujan un rectángulo son color de relleno, esto es solo para demostrar que existen diferentes maneras de dibujar el rectángulo. Y finalmente el botón 4 dibuja un rectángulo con la variación de que a este le podemos insertar un texto, el cual en este caso lo dejamos por defecto como: "TECNOLOGICO DE LA LAGUNA", con el texto en color rojo.

Enseguida se muestra el código de los 4 botones de la aplicación:

void __fastcall TForm1::Button1Click(TObject *Sender)

{

        HPEN hpen, hpenOld;

        HBRUSH hbrush, hbrushOld;

        // this de la forma

        HDC hdc = this->Canvas->Handle;

        // Pluma con color rojo para el borde

        hpen = CreatePen(PS_SOLID, 1, RGB(255, 0, 0));

        // Brocha con color azul para el interior

        hbrush = CreateSolidBrush(RGB(0, 0, 255));

        // Seleccione la nueva pluma y la brocha para dibujar un rectangulo

        hpenOld = SelectObject(hdc, hpen);

        hbrushOld = SelectObject(hdc, hbrush);

        Rectangle(hdc, 100,100, 400,250);

        // Despues de utilizar sus objetos, borrelos y restaure los originales

        SelectObject(hdc, hpenOld);

        DeleteObject(hpen);

        SelectObject(hdc, hbrushOld);

        DeleteObject(hbrush);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

        TRect Recto2(150, 140, 275, 200);

        HDC hDC = Canvas->Handle;

        DrawEdge(hDC, &Recto2, BDR_RAISEDOUTER | BDR_SUNKENINNER, BF_RECT);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)

{

        RECT Recto;

        Recto.left = 100;

        Recto.top = 50;

        Recto.right = 400;

        Recto.bottom = 300;

        //Aqui utilizamos directamente el Canvas

        Canvas->Rectangle(Recto);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button4Click(TObject *Sender)

{

        TRect Recto(50, 70, 455, 165);

        HDC hDC = Canvas->Handle;

        DrawEdge(hDC, &Recto, BDR_RAISEDOUTER | BDR_SUNKENINNER, BF_RECT);

        SetTextColor(hDC,RGB(255,0,0));

        char *cad="TECNOLOGICO DE LA LAGUNA";

        DrawText(hDC,cad,strlen(cad),&Recto,DT_CENTER); //DT_RIGHT);//DT_LEFT;

}

//---------------------------------------------------------------------------

Finalmente podemos visualizar como se dibuja cada uno de los rectángulos:

Bueno amigos eso es todo por esta ocasión, en la siguiente mostraremos como modificar la misma aplicación que creamos hoy para realizar cosas mucho más avanzadas. Hasta la próxima!

Breve Introducción A La Historia Del Lenguaje C++

Buenas chavos! Esta vez conoceremos un poco de la historia de C++ para comenzar a familiarizarnos con el. Que tengan un buen día todos.

Historia del lenguaje C++

El comité para el estándar ANSI C fue formado en 1983 con el objetivo de crear un lenguaje uniforme a partir del C original, desarrollado por Kernighan y Ritchie en 1972, en la ATT. hasta entonces el estándar lo marcaba el libro escrito en 1978 por estos dos autores.

El lenguaje C++ se comenzó a desarrollar en 1980. Su autor fue B. Stroustrup, también de la ATT. Al comienzo era una extensión del lenguaje C que fue denominada C with classes (C con clases). Este nuevo lenguaje comenzó a ser utilizado fuera de la ATT en 1983. El nombre C++ es también de ese año, y hace referencia al caracter del operador incremento de C (++). Ante la gran difusión y éxito que iba obteniendo en el mundo de los programadores, la ATT comenzó a estandarizarlo internamente en 1987. En 1989 se formó un comité ANSI (seguido algún tiempo después por un comité ISO) para estandarizarlo a nivel americano e internacional.

En la actualidad, el C++ es un lenguaje versátil, potente y general. Su éxito entre los programadores profesionales le ha llevado a ocupar el primer puesto como herramienta de desarrollo de aplicaciones. El C++ mantiene las ventajas del C en cuanto a riqueza de operadores y expresiones, flexibilidad, concisión y eficiencia. Además, ha eliminado algunas de las dificultades y limitaciones del C original. La evolución de C++ ha continuado con la aparición de Java, un lenguaje creado simplificando algunas cosas de C++ y añadiendo otras, que se utiliza para realizar aplicaciones en Internet. Hay que señalar que el C++ ha influido en algunos puntos muy importantes del ANSI C, como por ejemplo en la forma de declarar las funciones, en los punteros a void, etc. En efecto, aunque el C++ es posterior al C, sus primeras versiones son anteriores al ANSI C, y algunas de las mejoras de éste fueron tomadas del C++.

El C++ es a la vez un lenguaje procedural (orientado a algoritmos) y orientado a objetos. Como lenguaje procedural se asemeja al C y es compatible con él, aunque ya se ha dicho que presenta ciertas ventajas. Como lenguaje orientado a objetos se basa en una filosofía completamente diferente, que exige del programador un completo cambio de mentalidad. Las características propias de la Programación Orientada a Objetos (Object Oriented Programming, u OOP) de C++ son modificaciones mayores que sí que cambian radicalmente su naturaleza.

Hola a todos!!

Pues aquí mandando un saludo a todos :) y pues a mover los deditos chavos que empezamos con la materia de graficación del ITL.
Bienvenidos todos!.