elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Rompecabezas de Bitcoin, Medio millón USD en premios


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Interfaz Grafica de Usuario en C ligado a SDL !Excelente!
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Interfaz Grafica de Usuario en C ligado a SDL !Excelente!  (Leído 3,891 veces)
Fire544

Desconectado Desconectado

Mensajes: 85


"Escucha el sonido del 0, 1"


Ver Perfil WWW
Interfaz Grafica de Usuario en C ligado a SDL !Excelente!
« en: 1 Julio 2012, 05:52 am »

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
  1.  
  2. //cabecera.h para incluir en main.c le llamo "components.h"
  3.  
  4. #define ROJO 1
  5. #define VERDE 2
  6. #define AZUL 3
  7. #define BLANCO 4
  8. #define NEGRO 5
  9.  
  10. #define BOTON "boton.jpg"
  11. #define FONT "lsansd.ttf"
  12.  
  13. SDL_Surface *pantalla;
  14. //button
  15. void create_button(int x, int y, const char *file, int tam_label, int color)
  16. {
  17.     SDL_Surface *boton, *img_label;
  18.     SDL_Rect pos_boton, pos_label;
  19.     TTF_Font *label;
  20.     SDL_Color paleta_color;
  21.  
  22.     boton = IMG_Load(BOTON);
  23.     //posicion boton
  24.     pos_boton = (SDL_Rect) {x, y, 0, 0};
  25.     //posicion etiqueta
  26.     pos_label = (SDL_Rect) {x+5, y+15, 0, 0};
  27.     //cargar fuente y tamano
  28.     label = TTF_OpenFont(FONT, tam_label);
  29.     //rojo
  30.     if(color==1)
  31.     {
  32.                    paleta_color.r=255;
  33.                    paleta_color.b=0;
  34.                    paleta_color.g=0;
  35.  
  36.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  37.     }
  38.     //verde
  39.     if(color==2)
  40.     {
  41.                    paleta_color.r=0;
  42.                    paleta_color.b=0;
  43.                    paleta_color.g=255;
  44.  
  45.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  46.     }
  47.     //azul
  48.     if(color==3)
  49.     {
  50.                    paleta_color.r=0;
  51.                    paleta_color.b=255;
  52.                    paleta_color.g=0;
  53.  
  54.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  55.     }
  56.     //blanco
  57.     if(color==4)
  58.     {
  59.                    paleta_color.r=255;
  60.                    paleta_color.b=255;
  61.                    paleta_color.g=255;
  62.  
  63.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  64.     }
  65.     //negro
  66.     if(color==4)
  67.     {
  68.                    paleta_color.r=0;
  69.                    paleta_color.b=0;
  70.                    paleta_color.g=0;
  71.  
  72.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  73.     }
  74.     //volcamos superficies en buffer
  75.     SDL_BlitSurface(boton, NULL, pantalla, &pos_boton);
  76.     SDL_BlitSurface(img_label, NULL, pantalla, &pos_label);
  77.     //pintamos imagen
  78.     SDL_Flip(pantalla);
  79.     //liberamos superficies
  80.     SDL_FreeSurface(boton);
  81.     SDL_FreeSurface(img_label);
  82.     }
  83. //label
  84. void create_label(int x, int y, const char *file, int tam_label, int color)
  85. {
  86.     SDL_Surface *img_label;
  87.     SDL_Rect pos_label;
  88.     TTF_Font *label;
  89.     SDL_Color paleta_color;
  90.  
  91.     //posicion etiqueta
  92.     pos_label = (SDL_Rect) {x, y, 0, 0};
  93.     //cargar fuente y tamano
  94.     label = TTF_OpenFont(FONT, tam_label);
  95.     //rojo
  96.     if(color==1)
  97.     {
  98.                    paleta_color.r=255;
  99.                    paleta_color.b=0;
  100.                    paleta_color.g=0;
  101.  
  102.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  103.     }
  104.     //verde
  105.     if(color==2)
  106.     {
  107.                    paleta_color.r=0;
  108.                    paleta_color.b=0;
  109.                    paleta_color.g=255;
  110.  
  111.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  112.     }
  113.     //azul
  114.     if(color==3)
  115.     {
  116.                    paleta_color.r=0;
  117.                    paleta_color.b=255;
  118.                    paleta_color.g=0;
  119.  
  120.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  121.     }
  122.     //blanco
  123.     if(color==4)
  124.     {
  125.                    paleta_color.r=255;
  126.                    paleta_color.b=255;
  127.                    paleta_color.g=255;
  128.  
  129.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  130.     }
  131.     //negro
  132.     if(color==5)
  133.     {
  134.                    paleta_color.r=0;
  135.                    paleta_color.b=0;
  136.                    paleta_color.g=0;
  137.  
  138.     img_label = TTF_RenderText_Blended(label, file, paleta_color);
  139.     }
  140.     //volcamos superficies en buffer
  141.     SDL_BlitSurface(img_label, NULL, pantalla, &pos_label);
  142.     //pintamos imagen
  143.     SDL_Flip(pantalla);
  144.     //liberamos superficies
  145.     SDL_FreeSurface(img_label);
  146.     }
  147.     //texbox
  148. void create_texbox(int x, int y)
  149. {
  150.     SDL_Surface *texbox;
  151.     SDL_Rect pos_texbox;
  152.  
  153.     pos_texbox = (SDL_Rect) {x, y, 0, 0};
  154.  
  155.     texbox = IMG_Load("texbox.jpg");
  156.  
  157.     SDL_BlitSurface(texbox, NULL, pantalla, &pos_texbox);
  158.  
  159.     SDL_Flip(pantalla);
  160.  
  161.     SDL_FreeSurface(texbox);
  162.     }
  163.  
  164. //escribir
  165. void SDL_printf(int x, int y, const char *file, int tam_letra, int color)
  166. {
  167.     SDL_Surface *letra;
  168.     SDL_Rect pos_letra;
  169.     TTF_Font *letra_;
  170.     SDL_Color paleta_color;
  171.  
  172.     //posicion letra
  173.     pos_letra = (SDL_Rect) {x, y, 0, 0};
  174.     //cargar fuente y tamano
  175.     letra_= TTF_OpenFont(FONT, tam_letra);
  176.     //rojo
  177.     if(color==1)
  178.     {
  179.                    paleta_color.r=255;
  180.                    paleta_color.b=0;
  181.                    paleta_color.g=0;
  182.  
  183.     letra = TTF_RenderText_Blended(letra_, file, paleta_color);
  184.     }
  185.     //verde
  186.     if(color==2)
  187.     {
  188.                    paleta_color.r=0;
  189.                    paleta_color.b=0;
  190.                    paleta_color.g=255;
  191.  
  192.     letra = TTF_RenderText_Blended(letra_, file, paleta_color);
  193.     }
  194.     //azul
  195.     if(color==3)
  196.     {
  197.                    paleta_color.r=0;
  198.                    paleta_color.b=255;
  199.                    paleta_color.g=0;
  200.  
  201.     letra = TTF_RenderText_Blended(letra_, file, paleta_color);
  202.     }
  203.     //blanco
  204.     if(color==4)
  205.     {
  206.                    paleta_color.r=255;
  207.                    paleta_color.b=255;
  208.                    paleta_color.g=255;
  209.  
  210.     letra = TTF_RenderText_Blended(letra_, file, paleta_color);
  211.     }
  212.     //negro
  213.     if(color==5)
  214.     {
  215.                    paleta_color.r=0;
  216.                    paleta_color.b=0;
  217.                    paleta_color.g=0;
  218.  
  219.     letra = TTF_RenderText_Blended(letra_, file, paleta_color);
  220.     }
  221.     //volcamos superficie en buffer
  222.     SDL_BlitSurface(letra, NULL, pantalla, &pos_letra);
  223.     //pintamos imagen
  224.     SDL_Flip(pantalla);
  225.     //liberamos superficie
  226.     SDL_FreeSurface(letra);
  227.     }
  228.  
  229. void scroll_back(int x, int y)
  230. {
  231.     SDL_Surface *cursor=IMG_Load("cursor.jpg");
  232.  
  233.     SDL_Rect pos_coord=(SDL_Rect){x, y-4, 0, 0};
  234.  
  235.     SDL_BlitSurface(cursor, NULL, pantalla, &pos_coord);
  236.     SDL_Flip(pantalla);
  237.     }
  238.  
  239. void scroll_clear(int x, int y)
  240. {
  241.     SDL_Surface *cur_blanco=IMG_Load("cur_bb.jpg");
  242.  
  243.     SDL_Rect pos_coord_cb=(SDL_Rect){x, y-4, 0, 0};
  244.  
  245.     SDL_BlitSurface(cur_blanco, NULL, pantalla, &pos_coord_cb);
  246.     SDL_Flip(pantalla);
  247.     }
  248.  
  249. void cursor_white(int x, int y)
  250. {
  251.     SDL_Surface *cursor=IMG_Load("cur_bb.jpg");
  252.  
  253.     SDL_Rect pos_coord=(SDL_Rect){x, y-4, 0, 0};
  254.  
  255.     SDL_BlitSurface(cursor, NULL, pantalla, &pos_coord);
  256.     SDL_Flip(pantalla);
  257.     }
  258.  
  259.  

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

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <SDL.h>
  4. #include <SDL_image.h>
  5. #include <SDL_ttf.h>
  6. #include "components.cpp"
  7.  
  8. #define SIGNAL_CEDULA 4
  9. #define SIGNAL_APELLIDO 5
  10. #define SIGNAL_DIRECCION 6
  11. #define SIGNAL_NOMBRE 1
  12. #define bytes 64
  13.  
  14. void int_value(int signal, const char ctr);
  15. void scroll_back(int x, int y);
  16. void scroll_clear(int x, int y);
  17. void clear_bytes(int sig);
  18.  
  19. struct text{
  20.       char nombre[bytes];
  21.       char apellido[bytes];
  22.       char cedula[bytes];
  23.       char direc[bytes];
  24.       }texbox;
  25.  
  26. int sig=103, sig_y=91, i=0, signal, active_event=0;
  27.  
  28. int main(int argc, char *argv[])
  29. {
  30. SDL_Surface *image;
  31. SDL_Rect pos=(SDL_Rect){0,0,0,0};
  32. SDL_Event event;
  33.  
  34. int done = 0;
  35.  
  36. atexit(SDL_Quit);
  37. //inicializamos el subsistema de letras
  38. TTF_Init();
  39. //inicializamos el subsistema de video
  40. SDL_Init(SDL_INIT_VIDEO);
  41. //cargamos imagen
  42. image=IMG_Load("nave.jpg");
  43. //llamamos buffer de video con propiedades espesificas
  44. pantalla = SDL_SetVideoMode(640,300,24,SDL_HWSURFACE);
  45. //titulo de ventana
  46. SDL_WM_SetCaption("Formulario de Usuario",NULL);
  47. //bliteamos superficie en ventana
  48. SDL_BlitSurface(image, NULL, pantalla, &pos);
  49. //volcamos superficie en pantalla
  50. SDL_Flip(pantalla);
  51. //elementos de ventana
  52. create_label(100, 50, "Nombre", 20, AZUL);
  53. create_texbox(100, 80);
  54. create_label(100, 150, "Apellido", 20, AZUL);
  55. create_texbox(100, 180);
  56. create_label(350, 50, "Direccion", 20, AZUL);
  57. create_texbox(350, 80);
  58. create_label(350, 150, "Cedula", 20, AZUL);
  59. create_texbox(350, 180);
  60. create_button(100,250,"Guardar",15,VERDE);
  61. create_button(350,250,"Salir",15,VERDE);
  62. //bucle o loop de aplicacion
  63. while(done == 0)
  64. {
  65. //esperamos eventos en cola
  66. SDL_WaitEvent(&event);
  67. //consultamos eventos en cola
  68. if (event.type == SDL_QUIT)
  69. {
  70. done = 1;
  71. }
  72. /*else if(event.type==SDL_MOUSEBUTTONDOWN)
  73. {
  74.      fprintf(stdout, "x=%i|y=%i\n", event.button.x, event.button.y);
  75.      }*/
  76. else if((event.button.x>=100&event.button.x<=320)&&(event.button.y>=79&event.button.y<=100))
  77. {
  78.     if(event.button.button==1)
  79.     {
  80.     active_event=1;
  81.     scroll_clear(sig, sig_y);
  82.     i=0;
  83.     sig=103, sig_y=91;
  84.      scroll_back(sig, sig_y);
  85.     signal=SIGNAL_NOMBRE;
  86.     }
  87.     }
  88. else if((event.button.x>=100&event.button.x<=321)&&(event.button.y>=180&event.button.y<=201))
  89. {
  90.     if(event.button.button==1)
  91.     {
  92.     active_event=1;
  93.     scroll_clear(sig, sig_y);
  94.     i=0;
  95.     sig=103, sig_y=191;
  96.     scroll_back(sig, sig_y);
  97.     signal=SIGNAL_APELLIDO;
  98.     }
  99.     }
  100. else if((event.button.x>=350&event.button.x<=571)&&(event.button.y>=79&event.button.y<=101))
  101. {
  102.     if(event.button.button==1)
  103.     {
  104.     active_event=1;
  105.     scroll_clear(sig, sig_y);
  106.     i=0;
  107.     sig=353, sig_y=91;
  108.     scroll_back(sig, sig_y);
  109.     signal=SIGNAL_DIRECCION;
  110.     }
  111.     }
  112. else if((event.button.x>=350&event.button.x<=571)&&(event.button.y>=178&event.button.y<=202))
  113. {
  114.     if(event.button.button==1)
  115.     {
  116.     active_event=1;
  117.     scroll_clear(sig, sig_y);
  118.     i=0;
  119.     sig=353, sig_y=191;
  120.     scroll_back(sig, sig_y);
  121.     signal=SIGNAL_CEDULA;
  122.     }
  123.     }
  124. else if((event.button.x>=100&event.button.x<=200)&&(event.button.y>=250&event.button.y<=285))
  125. {
  126.     create_button(100,250,"Guardar",15,AZUL);
  127.     SDL_Delay(50);
  128.     create_button(100,250,"Guardar",15,VERDE);
  129.     if(event.button.button==1&&event.type==SDL_MOUSEBUTTONDOWN)
  130.     {
  131.     active_event=0;
  132.     fprintf(stdout, "%s\n%s\n%s\n%s\n", texbox.nombre, texbox.apellido, texbox.direc, texbox.cedula);
  133.     }
  134.     }
  135. else if((event.button.x>=354&event.button.x<=449)&&(event.button.y>=250&event.button.y<=285))
  136. {
  137.     create_button(350,250,"Salir",15,AZUL);
  138.     SDL_Delay(50);
  139.     create_button(350,250,"Salir",15,VERDE);
  140.     if(event.button.button==1&&event.type==SDL_MOUSEBUTTONDOWN)
  141.     {
  142.     //codigo accion salir
  143.     done=1;
  144.     }
  145.     }
  146. //eventos de teclado
  147. else if(active_event==1)
  148. {
  149. if(event.key.keysym.sym==SDLK_a&&event.type==SDL_KEYDOWN)
  150. {    
  151.     cursor_white(sig, sig_y);                                              
  152.     SDL_printf(sig, sig_y, "a", 10, ROJO);
  153.     sig=sig+8;
  154.     scroll_back(sig, sig_y);
  155.     int_value(signal, 'a');
  156.     }
  157. else if(event.key.keysym.sym==SDLK_b&&event.type==SDL_KEYDOWN)
  158. {
  159.     cursor_white(sig, sig_y);
  160.     SDL_printf(sig, sig_y, "b", 10, ROJO);
  161.     sig=sig+8;
  162.     scroll_back(sig, sig_y);
  163.     int_value(signal, 'b');
  164.     }
  165. else if(event.key.keysym.sym==SDLK_c&&event.type==SDL_KEYDOWN)
  166. {
  167.     cursor_white(sig, sig_y);
  168.     SDL_printf(sig, sig_y, "c", 10, ROJO);
  169.     sig=sig+8;
  170.     scroll_back(sig, sig_y);
  171.     int_value(signal, 'c');
  172.     }
  173. else if(event.key.keysym.sym==SDLK_d&&event.type==SDL_KEYDOWN)
  174. {
  175.     cursor_white(sig, sig_y);
  176.     SDL_printf(sig, sig_y, "d", 10, ROJO);
  177.     sig=sig+8;
  178.     scroll_back(sig, sig_y);
  179.     int_value(signal, 'd');
  180.     }
  181. else if(event.key.keysym.sym==SDLK_e&&event.type==SDL_KEYDOWN)
  182. {
  183.     cursor_white(sig, sig_y);
  184.     SDL_printf(sig, sig_y, "e", 10, ROJO);
  185.     sig=sig+8;
  186.     scroll_back(sig, sig_y);
  187.     int_value(signal, 'e');
  188.     }
  189. else if(event.key.keysym.sym==SDLK_f&&event.type==SDL_KEYDOWN)
  190. {
  191.     cursor_white(sig, sig_y);
  192.     SDL_printf(sig, sig_y, "f", 10, ROJO);
  193.     sig=sig+8;
  194.     scroll_back(sig, sig_y);
  195.     int_value(signal, 'f');
  196.     }
  197. else if(event.key.keysym.sym==SDLK_g&&event.type==SDL_KEYDOWN)
  198. {
  199.     cursor_white(sig, sig_y);
  200.     SDL_printf(sig, sig_y, "g", 10, ROJO);
  201.     sig=sig+8;
  202.     scroll_back(sig, sig_y);
  203.     int_value(signal, 'g');
  204.     }
  205. else if(event.key.keysym.sym==SDLK_h&&event.type==SDL_KEYDOWN)
  206. {
  207.     cursor_white(sig, sig_y);
  208.     SDL_printf(sig, sig_y, "h", 10, ROJO);
  209.     sig=sig+8;
  210.     scroll_back(sig, sig_y);
  211.     int_value(signal, 'h');
  212.     }
  213. else if(event.key.keysym.sym==SDLK_i&&event.type==SDL_KEYDOWN)
  214. {
  215.     cursor_white(sig, sig_y);
  216.     SDL_printf(sig, sig_y, " i", 10, ROJO);
  217.     sig=sig+8;
  218.     scroll_back(sig, sig_y);
  219.     int_value(signal, 'i');
  220.     }
  221. else if(event.key.keysym.sym==SDLK_j&&event.type==SDL_KEYDOWN)
  222. {
  223.     cursor_white(sig, sig_y);
  224.     SDL_printf(sig, sig_y, "j", 10, ROJO);
  225.     sig=sig+8;
  226.     scroll_back(sig, sig_y);
  227.     int_value(signal, 'j');
  228.     }
  229. else if(event.key.keysym.sym==SDLK_e&&event.type==SDL_KEYDOWN)
  230. {
  231.     cursor_white(sig, sig_y);
  232.     SDL_printf(sig, sig_y, "k", 10, ROJO);
  233.     sig=sig+8;
  234.     scroll_back(sig, sig_y);
  235.     int_value(signal, 'k');
  236.     }
  237. else if(event.key.keysym.sym==SDLK_l&&event.type==SDL_KEYDOWN)
  238. {
  239.     cursor_white(sig, sig_y);
  240.     SDL_printf(sig, sig_y, "l", 10, ROJO);
  241.     sig=sig+8;
  242.     scroll_back(sig, sig_y);
  243.     int_value(signal, 'l');
  244.     }
  245. else if(event.key.keysym.sym==SDLK_m&&event.type==SDL_KEYDOWN)
  246. {
  247.     cursor_white(sig, sig_y);
  248.     SDL_printf(sig, sig_y, "m", 10, ROJO);
  249.     sig=sig+8;
  250.     scroll_back(sig, sig_y);
  251.     int_value(signal, 'm');
  252.     }
  253. else if(event.key.keysym.sym==SDLK_n&&event.type==SDL_KEYDOWN)
  254. {
  255.     cursor_white(sig, sig_y);
  256.     SDL_printf(sig, sig_y, "n", 10, ROJO);
  257.     sig=sig+8;
  258.     scroll_back(sig, sig_y);
  259.     int_value(signal, 'n');
  260.     }
  261. else if(event.key.keysym.sym==SDLK_o&&event.type==SDL_KEYDOWN)
  262. {
  263.     cursor_white(sig, sig_y);
  264.     SDL_printf(sig, sig_y, "o", 10, ROJO);
  265.     sig=sig+8;
  266.     scroll_back(sig, sig_y);
  267.     int_value(signal, 'o');
  268.     }
  269. else if(event.key.keysym.sym==SDLK_p&&event.type==SDL_KEYDOWN)
  270. {
  271.     cursor_white(sig, sig_y);
  272.     SDL_printf(sig, sig_y, "p", 10, ROJO);
  273.     sig=sig+8;
  274.     scroll_back(sig, sig_y);
  275.     int_value(signal, 'p');
  276.     }
  277. else if(event.key.keysym.sym==SDLK_q&&event.type==SDL_KEYDOWN)
  278. {
  279.     cursor_white(sig, sig_y);
  280.     SDL_printf(sig, sig_y, "q", 10, ROJO);
  281.     sig=sig+8;
  282.     scroll_back(sig, sig_y);
  283.     int_value(signal, 'q');
  284.     }
  285. else if(event.key.keysym.sym==SDLK_r&&event.type==SDL_KEYDOWN)
  286. {
  287.     cursor_white(sig, sig_y);
  288.     SDL_printf(sig, sig_y, "r", 10, ROJO);
  289.     sig=sig+8;
  290.     scroll_back(sig, sig_y);
  291.     int_value(signal, 'r');
  292.     }
  293. else if(event.key.keysym.sym==SDLK_s&&event.type==SDL_KEYDOWN)
  294. {
  295.     cursor_white(sig, sig_y);
  296.     SDL_printf(sig, sig_y, "s", 10, ROJO);
  297.     sig=sig+8;
  298.     scroll_back(sig, sig_y);
  299.     int_value(signal, 's');
  300.     }
  301. else if(event.key.keysym.sym==SDLK_KP0&&event.type==SDL_KEYDOWN)
  302. {
  303.     cursor_white(sig, sig_y);
  304.     SDL_printf(sig, sig_y, "0", 10, ROJO);
  305.     sig=sig+8;
  306.     scroll_back(sig, sig_y);
  307.     int_value(signal, '0');
  308.     }
  309. else if(event.key.keysym.sym==SDLK_KP1&&event.type==SDL_KEYDOWN)
  310. {
  311.     cursor_white(sig, sig_y);
  312.     SDL_printf(sig, sig_y, "1", 10, ROJO);
  313.     sig=sig+8;
  314.     scroll_back(sig, sig_y);
  315.     int_value(signal, '1');
  316.     }
  317. else if(event.key.keysym.sym==SDLK_KP2&&event.type==SDL_KEYDOWN)
  318. {
  319.     cursor_white(sig, sig_y);
  320.     SDL_printf(sig, sig_y, "2", 10, ROJO);
  321.     sig=sig+8;
  322.     scroll_back(sig, sig_y);
  323.     int_value(signal, '2');
  324.     }
  325. else if(event.key.keysym.sym==SDLK_KP3&&event.type==SDL_KEYDOWN)
  326. {
  327.     cursor_white(sig, sig_y);
  328.     SDL_printf(sig, sig_y, "3", 10, ROJO);
  329.     sig=sig+8;
  330.     scroll_back(sig, sig_y);
  331.     int_value(signal, '3');
  332.     }
  333. else if(event.key.keysym.sym==SDLK_KP4&&event.type==SDL_KEYDOWN)
  334. {
  335.     cursor_white(sig, sig_y);
  336.     SDL_printf(sig, sig_y, "4", 10, ROJO);
  337.     sig=sig+8;
  338.     scroll_back(sig, sig_y);
  339.     int_value(signal, '4');
  340.     }
  341. else if(event.key.keysym.sym==SDLK_KP5&&event.type==SDL_KEYDOWN)
  342. {
  343.     cursor_white(sig, sig_y);
  344.     SDL_printf(sig, sig_y, "5", 10, ROJO);
  345.     sig=sig+8;
  346.     scroll_back(sig, sig_y);
  347.     int_value(signal, '5');
  348.     }
  349. else if(event.key.keysym.sym==SDLK_KP6&&event.type==SDL_KEYDOWN)
  350. {
  351.     cursor_white(sig, sig_y);
  352.     SDL_printf(sig, sig_y, "6", 10, ROJO);
  353.     sig=sig+8;
  354.     scroll_back(sig, sig_y);
  355.     int_value(signal, '6');
  356.     }
  357. else if(event.key.keysym.sym==SDLK_KP7&&event.type==SDL_KEYDOWN)
  358. {
  359.     cursor_white(sig, sig_y);
  360.     SDL_printf(sig, sig_y, "7", 10, ROJO);
  361.     sig=sig+8;
  362.     scroll_back(sig, sig_y);
  363.     int_value(signal, '7');
  364.     }
  365. else if(event.key.keysym.sym==SDLK_KP8&&event.type==SDL_KEYDOWN)
  366. {
  367.     cursor_white(sig, sig_y);
  368.     SDL_printf(sig, sig_y, "8", 10, ROJO);
  369.     sig=sig+8;
  370.     scroll_back(sig, sig_y);
  371.     int_value(signal, '8');
  372.     }
  373. else if(event.key.keysym.sym==SDLK_KP9&&event.type==SDL_KEYDOWN)
  374. {
  375.     cursor_white(sig, sig_y);
  376.     SDL_printf(sig, sig_y, "9", 10, ROJO);
  377.     sig=sig+8;
  378.     scroll_back(sig, sig_y);
  379.     int_value(signal, '9');
  380.     }
  381. else if(event.key.keysym.sym==SDLK_t&&event.type==SDL_KEYDOWN)
  382. {
  383.     cursor_white(sig, sig_y);
  384.     SDL_printf(sig, sig_y, "t", 10, ROJO);
  385.     sig=sig+8;
  386.     scroll_back(sig, sig_y);
  387.     int_value(signal, 't');
  388.     }
  389. else if(event.key.keysym.sym==SDLK_u&&event.type==SDL_KEYDOWN)
  390. {
  391.     cursor_white(sig, sig_y);
  392.     SDL_printf(sig, sig_y, "u", 10, ROJO);
  393.     sig=sig+8;
  394.     scroll_back(sig, sig_y);
  395.     int_value(signal, 'u');
  396.     }
  397. else if(event.key.keysym.sym==SDLK_v&&event.type==SDL_KEYDOWN)
  398. {
  399.     cursor_white(sig, sig_y);
  400.     SDL_printf(sig, sig_y, "v", 10, ROJO);
  401.     sig=sig+8;
  402.     scroll_back(sig, sig_y);
  403.     int_value(signal, 'v');
  404.     }
  405. else if(event.key.keysym.sym==SDLK_w&&event.type==SDL_KEYDOWN)
  406. {
  407.     cursor_white(sig, sig_y);
  408.     SDL_printf(sig, sig_y, "w", 10, ROJO);
  409.     sig=sig+8;
  410.     scroll_back(sig, sig_y);
  411.     int_value(signal, 'w');
  412.     }
  413. else if(event.key.keysym.sym==SDLK_x&&event.type==SDL_KEYDOWN)
  414. {
  415.     cursor_white(sig, sig_y);
  416.     SDL_printf(sig, sig_y, "x", 10, ROJO);
  417.     sig=sig+8;
  418.     scroll_back(sig, sig_y);
  419.     int_value(signal, 'x');
  420.     }
  421. else if(event.key.keysym.sym==SDLK_y&&event.type==SDL_KEYDOWN)
  422. {
  423.     cursor_white(sig, sig_y);
  424.     SDL_printf(sig, sig_y, "y", 10, ROJO);
  425.     sig=sig+8;
  426.     scroll_back(sig, sig_y);
  427.     int_value(signal, 'y');
  428.     }
  429. else if(event.key.keysym.sym==SDLK_k&&event.type==SDL_KEYDOWN)
  430. {
  431.     cursor_white(sig, sig_y);
  432.     SDL_printf(sig, sig_y, "k", 10, ROJO);
  433.     sig=sig+8;
  434.     scroll_back(sig, sig_y);
  435.     int_value(signal, 'k');
  436.     }
  437. else if(event.key.keysym.sym==SDLK_z&&event.type==SDL_KEYDOWN)
  438. {
  439.     cursor_white(sig, sig_y);
  440.     SDL_printf(sig, sig_y, "z", 10, ROJO);
  441.     sig=sig+8;
  442.     scroll_back(sig, sig_y);
  443.     int_value(signal, 'z');
  444.     }
  445. else if(event.key.keysym.sym==SDLK_SPACE&&event.type==SDL_KEYDOWN)
  446. {
  447.     cursor_white(sig, sig_y);
  448.     SDL_printf(sig, sig_y, "  ", 10, ROJO);
  449.     sig=sig+8;
  450.     scroll_back(sig, sig_y);
  451.     int_value(signal, ' ');
  452.     }
  453. else if(event.key.keysym.sym==SDLK_KP_DIVIDE&&event.type==SDL_KEYDOWN)
  454. {
  455.     cursor_white(sig, sig_y);
  456.     SDL_printf(sig, sig_y, "/", 10, ROJO);
  457.     sig=sig+8;
  458.     scroll_back(sig, sig_y);
  459.     int_value(signal, '/');
  460.     }
  461. else if(event.key.keysym.sym==SDLK_BACKSPACE&&event.type==SDL_KEYDOWN)
  462. {
  463.     clear_bytes(signal);
  464.     scroll_clear(sig, sig_y);
  465.     sig=sig-8;
  466.     scroll_back(sig, sig_y);
  467.     i--;
  468.     }
  469. else if(event.key.keysym.sym==SDLK_KP_MINUS&&event.type==SDL_KEYDOWN)
  470. {
  471.     cursor_white(sig, sig_y);
  472.     SDL_printf(sig, sig_y, "-", 10, ROJO);
  473.     sig=sig+8;
  474.     scroll_back(sig, sig_y);
  475.     int_value(signal, '-');
  476.     }
  477. else if(sig<=104)
  478. {
  479.     sig = 103;
  480.     }
  481.     }
  482. }
  483. //liberamos superficie principal
  484. SDL_FreeSurface(pantalla);
  485. }
  486. /*funcion rrecoje chars y los mete en array de acuerdo
  487. a CONSTANTES*/
  488. void int_value(int sig, const char ctr)
  489. {
  490.  
  491.     if(sig==SIGNAL_NOMBRE)
  492.     {
  493.                              texbox.nombre[i]=ctr;
  494.                              i++;
  495.                              }
  496.     if(sig==SIGNAL_APELLIDO)
  497.     {
  498.                              texbox.apellido[i]=ctr;
  499.                              i++;
  500.                              }
  501.     if(sig==SIGNAL_CEDULA)
  502.     {
  503.                              texbox.cedula[i]=ctr;
  504.                              i++;
  505.                              }
  506.     if(sig==SIGNAL_DIRECCION)
  507.     {
  508.                              texbox.direc[i]=ctr;
  509.                              i++;
  510.                              }
  511.     }
  512.  
  513. void clear_bytes(int sig)
  514. {
  515.  
  516.     if(sig==SIGNAL_NOMBRE)
  517.     {
  518.                              texbox.nombre[strlen(texbox.nombre)-1]=' ';
  519.                              }
  520.     if(sig==SIGNAL_APELLIDO)
  521.     {
  522.                              texbox.apellido[strlen(texbox.apellido)-1]=' ';
  523.                              }
  524.     if(sig==SIGNAL_CEDULA)
  525.     {
  526.                              texbox.cedula[strlen(texbox.cedula)-1]=' ';
  527.                              }
  528.     if(sig==SIGNAL_DIRECCION)
  529.     {
  530.                              texbox.direc[strlen(texbox.direc)-1]=' ';
  531.                              }
  532.     }
  533.  

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

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/

 ;)


« Última modificación: 7 Julio 2012, 06:02 am por Fire544 » En línea

"Si enseñas a pezcar a un niño lo ayudas para toda la vida, si pezcas para alimentarlo lo ayudas por un momento".
0xDani


Desconectado Desconectado

Mensajes: 1.077



Ver Perfil
Re: Interfaz Grafica de Usuario en C ligado a SDL !Excelente!
« Respuesta #1 en: 1 Julio 2012, 12:24 pm »

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 ;D


En línea

I keep searching for something that I never seem to find, but maybe I won't, because I left it all behind!

I code for $$$
Hago trabajos en C/C++
Contactar por PM
Fire544

Desconectado Desconectado

Mensajes: 85


"Escucha el sonido del 0, 1"


Ver Perfil WWW
Re: Interfaz Grafica de Usuario en C ligado a SDL !Excelente!
« Respuesta #2 en: 1 Julio 2012, 17:02 pm »

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. !!
En línea

"Si enseñas a pezcar a un niño lo ayudas para toda la vida, si pezcas para alimentarlo lo ayudas por un momento".
Foxy Rider


Desconectado Desconectado

Mensajes: 2.407


Deprecated


Ver Perfil WWW
Re: Interfaz Grafica de Usuario en C ligado a SDL !Excelente!
« Respuesta #3 en: 2 Julio 2012, 20:20 pm »

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.
En línea

Fire544

Desconectado Desconectado

Mensajes: 85


"Escucha el sonido del 0, 1"


Ver Perfil WWW
Re: Interfaz Grafica de Usuario en C ligado a SDL !Excelente!
« Respuesta #4 en: 2 Julio 2012, 22:17 pm »

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 !!
En línea

"Si enseñas a pezcar a un niño lo ayudas para toda la vida, si pezcas para alimentarlo lo ayudas por un momento".
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Interfaz grafica en Java
Java
cyberx4 3 3,861 Último mensaje 14 Septiembre 2005, 20:31 pm
por GaLaN GaLaNaSo 3000
Clase para interactuar con el usuario mediante interfaz gráfica simple
Java
JmpNull 0 3,599 Último mensaje 17 Agosto 2009, 22:38 pm
por JmpNull
Interfaz grafica « 1 2 »
Programación C/C++
danyof 11 7,404 Último mensaje 24 Mayo 2010, 15:08 pm
por danyof
Interfaz Grafica
Programación C/C++
mapers 3 6,036 Último mensaje 8 Marzo 2011, 16:02 pm
por Oblivi0n
[Python/Gtk] Tutorial Interfaz gráfica de usuario PyGobject
Scripting
Softrix18 1 2,092 Último mensaje 6 Octubre 2013, 14:33 pm
por 0xDani
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines