Interfaz Grafica de Usuario en C ligado a SDL !Excelente!

[Fire544]

Hola internautas, programadores, lectores y todo usuario  

Solucion a dolores de caveza:

la justificacion de este post, es por la urgencia con la cual algunos programadores iniciados/avanzados buscan alguna API o Lib que les ayude a crear sus GUI para evitar usar la API Win32. Pues existen varias Libs que nos permiten la comunicacion con los sistemas de video, sonidos, perifericos, etc; que son los componentes basicos a manejar a la hora de crear nuestras propias GUI.

Para esos propositos de desarrollo de GUI, mencionare algunas existentes que se utilizan, esta la famosa (Allegro.h, Glut, Direct3d/2d, WxWidgets, SDL, etc) pero a lo mejor dirian "No utilizo ningunas de estas por su complejidad" no es claro todo tiene su nivel de complejidad pero a la hora de pensar tomar alguna API entonces piencen "Sera mas compleja que la anterior", "Sera multiplataforma", "Que puedo hacer con esta Lib o API". Entonces tendrian buena eleccion, eso nos hace pensar que dependiendo de nuestros objetivos podremos elegir la Lib correcta.

Bueno una de las Libs mas pontetes y usuales para graficos seria SDL, que a lo mejor has leido detalles o info.. de esta pero nunca te atreviste a tocarla, y si lo hiciste te tropezaste con que "Esta Lib no tiene funciones para crear Botones, Texbox, ListBox, Label, etc", pero entonces aqui entra la imaginacion y los eventos que ya trae SDL que es para lo que esta echa esta Lib.

He intentado desarrollar Aplicaciones Graficas con esta Lib y me ha ido bien, desarrolle algunas funciones para la creacion de botones, texbox, label, showbox, etc. Para poder ir desarrollando mas rapido mis aplicaciones (Presupuesto Economico) y haciendo uso de lo que se conoce como "Interfaz de Usuario" para poder comunicar la GUI con el Sistema/ejecutable y a si simular o imitar lo que son las señales con las API actuales como GTK, QT, Glut, etc.

Voy a dejar el codigo del .h y un ejemplo de como utilizarlo junto con un Source y Ejecutable.

Nota: Si no estas familiarizado con SDL y C no intentes forzar tu comprension.

Código (cpp) [Seleccionar] Expandir



//cabecera.h para incluir en main.c le llamo "components.h"

#define ROJO 1
#define VERDE 2
#define AZUL 3
#define BLANCO 4
#define NEGRO 5

#define BOTON "boton.jpg"
#define FONT "lsansd.ttf"

SDL_Surface *pantalla;
//button
void create_button(int x, int y, const char *file, int tam_label, int color)
{
    SDL_Surface *boton, *img_label;
    SDL_Rect pos_boton, pos_label;
    TTF_Font *label;
    SDL_Color paleta_color;
   
    boton = IMG_Load(BOTON);
    //posicion boton
    pos_boton = (SDL_Rect) {x, y, 0, 0};
    //posicion etiqueta
    pos_label = (SDL_Rect) {x+5, y+15, 0, 0};
    //cargar fuente y tamano
    label = TTF_OpenFont(FONT, tam_label);
    //rojo
    if(color==1)
    {
                   paleta_color.r=255;
                   paleta_color.b=0;
                   paleta_color.g=0;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //verde
    if(color==2)
    {
                   paleta_color.r=0;
                   paleta_color.b=0;
                   paleta_color.g=255;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //azul
    if(color==3)
    {
                   paleta_color.r=0;
                   paleta_color.b=255;
                   paleta_color.g=0;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //blanco
    if(color==4)
    {
                   paleta_color.r=255;
                   paleta_color.b=255;
                   paleta_color.g=255;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //negro
    if(color==4)
    {
                   paleta_color.r=0;
                   paleta_color.b=0;
                   paleta_color.g=0;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //volcamos superficies en buffer
    SDL_BlitSurface(boton, NULL, pantalla, &pos_boton);
    SDL_BlitSurface(img_label, NULL, pantalla, &pos_label);
    //pintamos imagen
    SDL_Flip(pantalla);
    //liberamos superficies
    SDL_FreeSurface(boton);
    SDL_FreeSurface(img_label);
    }
//label
void create_label(int x, int y, const char *file, int tam_label, int color)
{
    SDL_Surface *img_label;
    SDL_Rect pos_label;
    TTF_Font *label;
    SDL_Color paleta_color;
   
    //posicion etiqueta
    pos_label = (SDL_Rect) {x, y, 0, 0};
    //cargar fuente y tamano
    label = TTF_OpenFont(FONT, tam_label);
    //rojo
    if(color==1)
    {
                   paleta_color.r=255;
                   paleta_color.b=0;
                   paleta_color.g=0;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //verde
    if(color==2)
    {
                   paleta_color.r=0;
                   paleta_color.b=0;
                   paleta_color.g=255;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //azul
    if(color==3)
    {
                   paleta_color.r=0;
                   paleta_color.b=255;
                   paleta_color.g=0;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //blanco
    if(color==4)
    {
                   paleta_color.r=255;
                   paleta_color.b=255;
                   paleta_color.g=255;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //negro
    if(color==5)
    {
                   paleta_color.r=0;
                   paleta_color.b=0;
                   paleta_color.g=0;
                   
    img_label = TTF_RenderText_Blended(label, file, paleta_color);
    }
    //volcamos superficies en buffer
    SDL_BlitSurface(img_label, NULL, pantalla, &pos_label);
    //pintamos imagen
    SDL_Flip(pantalla);
    //liberamos superficies
    SDL_FreeSurface(img_label);
    }
    //texbox
void create_texbox(int x, int y)
{
    SDL_Surface *texbox;
    SDL_Rect pos_texbox;
   
    pos_texbox = (SDL_Rect) {x, y, 0, 0};
   
    texbox = IMG_Load("texbox.jpg");
   
    SDL_BlitSurface(texbox, NULL, pantalla, &pos_texbox);
   
    SDL_Flip(pantalla);
   
    SDL_FreeSurface(texbox);
    }

//escribir
void SDL_printf(int x, int y, const char *file, int tam_letra, int color)
{
    SDL_Surface *letra;
    SDL_Rect pos_letra;
    TTF_Font *letra_;
    SDL_Color paleta_color;
   
    //posicion letra
    pos_letra = (SDL_Rect) {x, y, 0, 0};
    //cargar fuente y tamano
    letra_= TTF_OpenFont(FONT, tam_letra);
    //rojo
    if(color==1)
    {
                   paleta_color.r=255;
                   paleta_color.b=0;
                   paleta_color.g=0;
                   
    letra = TTF_RenderText_Blended(letra_, file, paleta_color);
    }
    //verde
    if(color==2)
    {
                   paleta_color.r=0;
                   paleta_color.b=0;
                   paleta_color.g=255;
                   
    letra = TTF_RenderText_Blended(letra_, file, paleta_color);
    }
    //azul
    if(color==3)
    {
                   paleta_color.r=0;
                   paleta_color.b=255;
                   paleta_color.g=0;
                   
    letra = TTF_RenderText_Blended(letra_, file, paleta_color);
    }
    //blanco
    if(color==4)
    {
                   paleta_color.r=255;
                   paleta_color.b=255;
                   paleta_color.g=255;
                   
    letra = TTF_RenderText_Blended(letra_, file, paleta_color);
    }
    //negro
    if(color==5)
    {
                   paleta_color.r=0;
                   paleta_color.b=0;
                   paleta_color.g=0;
                   
    letra = TTF_RenderText_Blended(letra_, file, paleta_color);
    }
    //volcamos superficie en buffer
    SDL_BlitSurface(letra, NULL, pantalla, &pos_letra);
    //pintamos imagen
    SDL_Flip(pantalla);
    //liberamos superficie
    SDL_FreeSurface(letra);
    }

void scroll_back(int x, int y)
{
    SDL_Surface *cursor=IMG_Load("cursor.jpg");
   
    SDL_Rect pos_coord=(SDL_Rect){x, y-4, 0, 0};
   
    SDL_BlitSurface(cursor, NULL, pantalla, &pos_coord);
    SDL_Flip(pantalla);
    }

void scroll_clear(int x, int y)
{
    SDL_Surface *cur_blanco=IMG_Load("cur_bb.jpg");
   
    SDL_Rect pos_coord_cb=(SDL_Rect){x, y-4, 0, 0};
   
    SDL_BlitSurface(cur_blanco, NULL, pantalla, &pos_coord_cb);
    SDL_Flip(pantalla);
    }
   
void cursor_white(int x, int y)
{
    SDL_Surface *cursor=IMG_Load("cur_bb.jpg");
   
    SDL_Rect pos_coord=(SDL_Rect){x, y-4, 0, 0};
 
    SDL_BlitSurface(cursor, NULL, pantalla, &pos_coord);
    SDL_Flip(pantalla);
    }



Luego que entiendo todo este royo de los create_button, create_label y esas cosas, entonces me voy a codear la aplicacion.

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include <SDL_image.h>
#include <SDL_ttf.h>
#include "components.cpp"

#define SIGNAL_CEDULA 4
#define SIGNAL_APELLIDO 5
#define SIGNAL_DIRECCION 6
#define SIGNAL_NOMBRE 1
#define bytes 64

void int_value(int signal, const char ctr);
void scroll_back(int x, int y);
void scroll_clear(int x, int y);
void clear_bytes(int sig);

struct text{
      char nombre[bytes];
      char apellido[bytes];
      char cedula[bytes];
      char direc[bytes];
      }texbox;

int sig=103, sig_y=91, i=0, signal, active_event=0;

int main(int argc, char *argv[])
{
SDL_Surface *image;
SDL_Rect pos=(SDL_Rect){0,0,0,0};
SDL_Event event;

int done = 0;

atexit(SDL_Quit);
//inicializamos el subsistema de letras
TTF_Init();
//inicializamos el subsistema de video
SDL_Init(SDL_INIT_VIDEO);
//cargamos imagen
image=IMG_Load("nave.jpg");
//llamamos buffer de video con propiedades espesificas
pantalla = SDL_SetVideoMode(640,300,24,SDL_HWSURFACE);
//titulo de ventana
SDL_WM_SetCaption("Formulario de Usuario",NULL);
//bliteamos superficie en ventana
SDL_BlitSurface(image, NULL, pantalla, &pos);
//volcamos superficie en pantalla
SDL_Flip(pantalla);
//elementos de ventana
create_label(100, 50, "Nombre", 20, AZUL);
create_texbox(100, 80);
create_label(100, 150, "Apellido", 20, AZUL);
create_texbox(100, 180);
create_label(350, 50, "Direccion", 20, AZUL);
create_texbox(350, 80);
create_label(350, 150, "Cedula", 20, AZUL);
create_texbox(350, 180);
create_button(100,250,"Guardar",15,VERDE);
create_button(350,250,"Salir",15,VERDE);
//bucle o loop de aplicacion
while(done == 0)
{
//esperamos eventos en cola
SDL_WaitEvent(&event);
//consultamos eventos en cola
if (event.type == SDL_QUIT)
{
done = 1;
}
/*else if(event.type==SDL_MOUSEBUTTONDOWN)
{
    fprintf(stdout, "x=%i|y=%i\n", event.button.x, event.button.y);
    }*/
else if((event.button.x>=100&event.button.x<=320)&&(event.button.y>=79&event.button.y<=100))
{
    if(event.button.button==1)
    {
    active_event=1;
    scroll_clear(sig, sig_y);
    i=0;
    sig=103, sig_y=91;
     scroll_back(sig, sig_y);
    signal=SIGNAL_NOMBRE;
    }
    }
else if((event.button.x>=100&event.button.x<=321)&&(event.button.y>=180&event.button.y<=201))
{
    if(event.button.button==1)
    {
    active_event=1;
    scroll_clear(sig, sig_y);
    i=0;
    sig=103, sig_y=191;
    scroll_back(sig, sig_y);
    signal=SIGNAL_APELLIDO;
    }
    }
else if((event.button.x>=350&event.button.x<=571)&&(event.button.y>=79&event.button.y<=101))
{
    if(event.button.button==1)
    {
    active_event=1;
    scroll_clear(sig, sig_y);
    i=0;
    sig=353, sig_y=91;
    scroll_back(sig, sig_y);
    signal=SIGNAL_DIRECCION;
    }
    }
else if((event.button.x>=350&event.button.x<=571)&&(event.button.y>=178&event.button.y<=202))
{
    if(event.button.button==1)
    {
    active_event=1;
    scroll_clear(sig, sig_y);
    i=0;
    sig=353, sig_y=191;
    scroll_back(sig, sig_y);
    signal=SIGNAL_CEDULA;
    }
    }
else if((event.button.x>=100&event.button.x<=200)&&(event.button.y>=250&event.button.y<=285))
{
    create_button(100,250,"Guardar",15,AZUL);
    SDL_Delay(50);
    create_button(100,250,"Guardar",15,VERDE);
    if(event.button.button==1&&event.type==SDL_MOUSEBUTTONDOWN)
    {
    active_event=0;
    fprintf(stdout, "%s\n%s\n%s\n%s\n", texbox.nombre, texbox.apellido, texbox.direc, texbox.cedula);
    }
    }
else if((event.button.x>=354&event.button.x<=449)&&(event.button.y>=250&event.button.y<=285))
{
    create_button(350,250,"Salir",15,AZUL);
    SDL_Delay(50);
    create_button(350,250,"Salir",15,VERDE);
    if(event.button.button==1&&event.type==SDL_MOUSEBUTTONDOWN)
    {
    //codigo accion salir
    done=1;
    }
    }
//eventos de teclado
else if(active_event==1)
{
if(event.key.keysym.sym==SDLK_a&&event.type==SDL_KEYDOWN)
{    
    cursor_white(sig, sig_y);                                              
    SDL_printf(sig, sig_y, "a", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'a');
    }
else if(event.key.keysym.sym==SDLK_b&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "b", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'b');
    }
else if(event.key.keysym.sym==SDLK_c&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "c", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'c');
    }
else if(event.key.keysym.sym==SDLK_d&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "d", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'd');
    }
else if(event.key.keysym.sym==SDLK_e&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "e", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'e');
    }
else if(event.key.keysym.sym==SDLK_f&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "f", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'f');
    }
else if(event.key.keysym.sym==SDLK_g&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "g", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'g');
    }
else if(event.key.keysym.sym==SDLK_h&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "h", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'h');
    }
else if(event.key.keysym.sym==SDLK_i&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, " i", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'i');
    }
else if(event.key.keysym.sym==SDLK_j&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "j", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'j');
    }
else if(event.key.keysym.sym==SDLK_e&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "k", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'k');
    }
else if(event.key.keysym.sym==SDLK_l&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "l", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'l');
    }
else if(event.key.keysym.sym==SDLK_m&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "m", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'm');
    }
else if(event.key.keysym.sym==SDLK_n&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "n", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'n');
    }
else if(event.key.keysym.sym==SDLK_o&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "o", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'o');
    }
else if(event.key.keysym.sym==SDLK_p&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "p", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'p');
    }
else if(event.key.keysym.sym==SDLK_q&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "q", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'q');
    }
else if(event.key.keysym.sym==SDLK_r&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "r", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'r');
    }
else if(event.key.keysym.sym==SDLK_s&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "s", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 's');
    }
else if(event.key.keysym.sym==SDLK_KP0&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "0", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '0');
    }
else if(event.key.keysym.sym==SDLK_KP1&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "1", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '1');
    }
else if(event.key.keysym.sym==SDLK_KP2&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "2", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '2');
    }
else if(event.key.keysym.sym==SDLK_KP3&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "3", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '3');
    }
else if(event.key.keysym.sym==SDLK_KP4&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "4", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '4');
    }
else if(event.key.keysym.sym==SDLK_KP5&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "5", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '5');
    }
else if(event.key.keysym.sym==SDLK_KP6&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "6", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '6');
    }
else if(event.key.keysym.sym==SDLK_KP7&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "7", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '7');
    }
else if(event.key.keysym.sym==SDLK_KP8&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "8", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '8');
    }
else if(event.key.keysym.sym==SDLK_KP9&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "9", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '9');
    }
else if(event.key.keysym.sym==SDLK_t&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "t", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 't');
    }
else if(event.key.keysym.sym==SDLK_u&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "u", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'u');
    }
else if(event.key.keysym.sym==SDLK_v&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "v", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'v');
    }
else if(event.key.keysym.sym==SDLK_w&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "w", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'w');
    }
else if(event.key.keysym.sym==SDLK_x&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "x", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'x');
    }
else if(event.key.keysym.sym==SDLK_y&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "y", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'y');
    }
else if(event.key.keysym.sym==SDLK_k&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "k", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'k');
    }
else if(event.key.keysym.sym==SDLK_z&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "z", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, 'z');
    }
else if(event.key.keysym.sym==SDLK_SPACE&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "  ", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, ' ');
    }
else if(event.key.keysym.sym==SDLK_KP_DIVIDE&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "/", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '/');
    }
else if(event.key.keysym.sym==SDLK_BACKSPACE&&event.type==SDL_KEYDOWN)
{
    clear_bytes(signal);
    scroll_clear(sig, sig_y);
    sig=sig-8;
    scroll_back(sig, sig_y);
    i--;
    }
else if(event.key.keysym.sym==SDLK_KP_MINUS&&event.type==SDL_KEYDOWN)
{
    cursor_white(sig, sig_y);
    SDL_printf(sig, sig_y, "-", 10, ROJO);
    sig=sig+8;
    scroll_back(sig, sig_y);
    int_value(signal, '-');
    }
else if(sig<=104)
{
    sig = 103;
    }
    }
}
//liberamos superficie principal
SDL_FreeSurface(pantalla);
}
/*funcion rrecoje chars y los mete en array de acuerdo
a CONSTANTES*/
void int_value(int sig, const char ctr)
{
   
    if(sig==SIGNAL_NOMBRE)
    {
                             texbox.nombre[i]=ctr;
                             i++;
                             }
    if(sig==SIGNAL_APELLIDO)
    {
                             texbox.apellido[i]=ctr;
                             i++;
                             }
    if(sig==SIGNAL_CEDULA)
    {
                             texbox.cedula[i]=ctr;
                             i++;
                             }
    if(sig==SIGNAL_DIRECCION)
    {
                             texbox.direc[i]=ctr;
                             i++;
                             }
    }

void clear_bytes(int sig)
{
   
    if(sig==SIGNAL_NOMBRE)
    {
                             texbox.nombre[strlen(texbox.nombre)-1]=' ';
                             }
    if(sig==SIGNAL_APELLIDO)
    {
                             texbox.apellido[strlen(texbox.apellido)-1]=' ';
                             }
    if(sig==SIGNAL_CEDULA)
    {
                             texbox.cedula[strlen(texbox.cedula)-1]=' ';
                             }
    if(sig==SIGNAL_DIRECCION)
    {
                             texbox.direc[strlen(texbox.direc)-1]=' ';
                             }
    }


Aqui es donde entra la complejidad y aplicacion de las funciones anteriormente mencionadas, es la aplicacion en si.

Salvedad: Posteo esto, para que critiquen de como mejorar/implementar el codigo de mi Lib.h no del Main.c el objetivo es que se animen y logremos intercambiar conocimientos y aprender mas todos. Pueden criticar y Postear el codigo en otros foros respetando la fuente y el autor. Me reservare los detalles y explicacion de cada syntaxis, para que ustedes mismos opinen y pregunten. !!

Salvedad 2: No olviden que aqui trabajamos con las Libs SDL_image.h, SDL_ttf.h. O sea tienen que tener su Dev-c++ en la opcion Linker con la siguiente Confg: (-lmingw32  -lSDLmain -lSDL -lSDL_image -lSDL_ttf ) e instalar todas las Libs en el directorio Include de nuestra instalacion Dev-c++ si andas en alguna Distro Linux enlaza con -lMyLib.o.

Post Finalizado Suerte   !!!!

He cumplido lo prometido aqui les dejo el .rar con el ejecutable y las .jpg y Fonts para que puedan entender mejor el codigo ya una vez ejecutado !!

http://uploading.com/files/eb8c9562/Proyecto.rar/
Tambien la imagen para mas motivacion !!
http://imageshack.us/photo/my-images/708/dibujo2xz.png/

[0xDani]

Este trabajo esta genial, porque con SDL convencional no puedes crear botones, textbox y esas cosas, pero sigue siendo demasiado compleja, mirate un codigo similar en Qt, GTK o alguna de esas y veras que sigue siendo mucho mas corto.

Saludos

[Fire544]

Si tienes te entiendo correctamente, pero lo que se quiere aprovechar es la carencia de codigo c++, o sea QT, GTK, etc, hacen uso de POO y hay quienes no trabajan con el concepto, y no optan por migrar a QT o GTK, SDL a diferencia de todas esta escrita en C puro y no necesita de POO solo creatividad y ganas, por eso posteo el articulo. Para quienes quieran colaborar entonces ayuden, y su complejidad en verdad esta en el manejo de señales para poder hacer la aplicacion mas eficiente, si te fijas en el codigo del main.c utilizo C basico y llamadas normales, pero luego se complica con algunas llamadas y al no estar comentadas entonces se vuelve inaccesible la lectura del programador.\

Pero explicare lo que no se entiende. Porque es mi estilo de programacion y no un paradigma es facil ya veras. !!

[Foxy Rider]

GTK está en C .... igual, SDL te dá herramientas base para trabajar con gráficos. Léase → Podés armar tu propia librería para interfaces gráficas y hacer cosas BASTANTE vistosas que con GTK ni de casualidad, pero al coste de reinventar la rueda y armar tu propio toolkit, claro está.

Saludos.

[Fire544]

Claro ! se pueden hacer muchas cosas con SDL, el poder de esta lib esta en el frame-buffer para los subsistemas de videos, audio, teclado, mause, etc.

El objetivo es ver opiniones y cuestiones de los usuarios que llevan tiempo buscando la lib adecuada para trabajar con graficos y poder elaborar sus GUIs ...

Gracias por tu opinion vertexSymphony !!