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.

 
//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.

#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/

 

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. !!

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 !!