Estoy desarrollando una aplicacion tipo Cuentas por Cobrar, intento reabrir un descriptor de fichero como lectura y modificacion binaria, para poder modificar contenido con fseek(), puedo modificar el contenido x veces en tiempo de ejecucion, cuando estoy intentando la 3ra modificacion, entonces explota, pero he verificado las salidas de los descriptores y solo el descriptor que utiliza la funcion getPos() devuelve error, al parecer no pudo abrir el descriptor, pero a que se debe, he cerrado todos los ficheros correctamente, he colocado reposicionamiento al SET 0 de mi descriptor utilizando fseek(), pero nada todo igual.

 //codigo boton  
     posFich=getPos(cedulaPg);
     getPosFich(posFich-1, modifFichero);
     pagoActual=mntPagoClt(cedulaPg);
     sumaPagada=sumar(mntPago, mntCount);
     //suma de pago
     pagoSumado=pagoActual-sumaPagada;
 
     sprintf(usuario.deuda, "%i", pagoSumado);
     //guardamos estructura de datos en fichero
     fwrite(&usuario, sizeof(struct user), 1, modifFichero);
     //cerramos fichero
     fclose(modifFichero);
 

La funcion getPos(), con esta funcion devuelvo la posicion fisica actual del fichero.

int getPos(char *cedulaPago)
{
     FILE *dato = fopen("fixcom.fix", "rb");
     int pos=0;
     //fseek(dato, 0L, SEEK_SET);
     verificarFichero(dato,"dato");
 
     while(fread(&usuario, sizeof(struct user), 1, dato)!=0)
     {
                           pos++;
                           if(strcmp(cedulaPago, usuario.cedula)==0)
                           {
                                                 fclose(dato);
                                                 return pos;
                                                 }
                           }
     }
 

La funcion mntPagoClt(), la utilizo para sacar el ultimo pago que realizo el cliente.

int mntPagoClt(char *cedula)
{
     int prestamoD=0;
 
     FILE *fichLeer=fopen("fixcom.fix", "rb");
 
     while(fread(&usuario, sizeof(struct user), 1, fichLeer)!=0)
     {
     if(strcmp(cedula, usuario.cedula)==0)
     {
 
     fclose(fichLeer);
 
     return prestamoD=atoll(usuario.deuda);
             }
             }
     }
 

De esta manera estoy abriendo los descriptores de fichero:

modifFichero=fopen("fixcom.fix","rb+");//lectura binaria y para actualizar descriptor
fdiskR=fopen("fixcom.fix","rb");//leer el fichero completo hasta encontrar lo buscado con strcmp()
fdiskW=fopen("fixcom.fix","a"); //para guardar siempre en la ultima linea del fichero

La funcion getPosFich(). Con esta funcion me posiciono en donde quiero en el descriptor

void getPosFich(int pos, FILE *filePtr)
{
     fseek(filePtr, pos*sizeof(struct user), SEEK_SET);
     }

Nota: Todos los datos se alojan en un fichero, llamado fixcon.fix.

Hola a todos !!. estuve un poco calladito con lo de los GUIs con SDL, pero ya estoy aqui nuevamente, ahora vengo con algo muy sencillo solo quiero que opinen al respecto, y claro critiquen. Es un menu algo clasico y poco modelado solo para probar nomas.

Nota: Esta desarrollado en un entorno Dev-c++, Windows XP, solo tienen que ejecutar, no he dejado los sources, porque es algo de prueba sin terminaciones ni nada, solo quiero sus opiniones y criticas ....

Aqui les dejo el link:
-------------------------------------------------------------------------------------
http://uploading.com/files/get/852beemc/Menu_GUI_C_SDL.rar
-------------------------------------------------------------------------------------
Suerte !!!  

Hola a todos!! Desarrolle una calculadora, el objetivo del software es animar a los programadores iniciados/avanzados en C , ya que veo muchas dudas sobre con cual API para GUI necesitan, si QT, o GTK soporta perifericos, si es facil, etc. Muchas dudas, que me hicieron codear este ejemplo, esta hecho en puro C del estandar ANSI, claro la GUI la implemente con SDL, es multiplataforma, solo tienen que compilar en GNU/Linux o cualquier otro S.O y no necesita modificacion de codigo.

Tiene algunos errores, luego se daran cuenta, y tambien le falta los efectos cuando accionamos encima de los botones, pero si tienen los de acciones pulsados, y luego para la version 1.1 de este mismo ejemplo, les traere todo completo. Al que se animen a criticar y ayudar con el desarrollo de la libreria no hay problemas, esta todo el codigo, ejecutable, fonts, jpg, libs y makefile, generado por SDL.

Critiquen, posteen, desahogo total !!!  

Aqui les dejo el link de descarga:

Codigo: 2m1bdemf

http://uploading.com/files/get/2m1bdemf/Proyecto_Calc_C_SDL.rar

Hola !! Anteriormente habia posteado una duda con la suma de vectores, no podia manejar la recepcion de valores absolutos en una variable tipo entero vector a una tipo entero, ps resolvi todo gracias a la ayuda de algunos users del foro y posteo en otro hilo para no revivir el tema por su tiempo de caducidad !!

#include <stdio.h>
 
int elevar(int valor, int num)
{
    int vector[num];
    const int potencia=10;
 
    for(int i=0; i<num; i++)
    {
            //llenamos vector de 10
            vector[i]=potencia;
            //asignamo 1 a la posicion iniciar de vector
            vector[0]=1;
            }
 
            for(int i=0; i<num; i++)
            {
                    //elevamos valor a las cantidades de 10 pasadas a vector
                    valor=valor*vector[i];
                    }
                    //retornamos valor elevado
                    return valor;
    }
 
int sumar(int vector[], int n)
{
    int i, r=0, vector_a[n];
 
             for(i=0; i<n; i++)
             {
                      //obtenemos valor en v de vector
                      int v=vector[i];
                      //llamamos a funcion elevar y sacamos retorno de ella
                      int x=elevar(v,n-i);
                      //asignamos valo retornado a vector
                      vector_a[i]=x;
                      //sumamos cada valor con la posicion siguente del vector
                      r=r+vector_a[i];
                      }
                      //retornamos valor absoluto de suma
                      return r;
    }
 
int main()
{   
    int i, valor_a=0, valor_b=0, vector_a[4], vector_b[4];
 
    printf("Introduzca valores 1: ");
 
    for(i=0; i<4; i++)
    {
             scanf("%i", &vector_a[i]);
             }
 
             printf("Introduzca valores 2: ");
             fflush(stdin);
 
    for(i=0; i<4; i++)
    {
             scanf("%i", &vector_b[i]);
             }
 
    valor_a=sumar(vector_a, 4);
    valor_b=sumar(vector_b, 4);
 
    int r = valor_a+valor_b;
 
    printf("\n\nResultado: %i", r);
 
    fflush(stdin);
    getchar();
    }
 
 

Suerte en tu lectura !! 

  Hola a todos internautas ! Tengo ya varios dias intentando sumar vectores, mi problematica esta en los valores absoluo que me tiene que devolver la variable suma  al operar con los dos vectores.

les dejare el codigo para que vean que es lo que quiero lograr.

int vector_1[5]={5, 978, 6, 4, 9}, vector_2{65, 9, 12, 66, 45}, suma=0;
 
for(int i=0; i<5; i++)
{
suma=suma + (vector_1[i]+vector_2[i]);
}
 
printf("%i", suma);
 

A simple vista solo con observar podemos darnos cuenta de que no hay error, el cogio hace la operacion de suma sobre los vectores, pero fijense lo que hace.

vector_1[1]=5 + vector_2[1]=65 esto seria igual a 70, y a si sucecivamente, no quiero esto lo que quiero es:


   5   978 6   4   9
+ 65 9    12 66 45
______________
665105294


que este ultimo seria el valo absoluto he tratado todas las formas y no logro nigun resultado de solucion, favor y aporten sus ideas, he intentado almacenar la suma en un vector al igual en una variable no vector, uff de todo !!

Hola a todos !!!   Expongo el thread para algunos que se preguntan si existiria alguna API para el trabajo de BD en C del estandar ANSI.

Comento todo el codigo para una mejor comprension del lector. El compilador utilizado es Dev-c++.

Con la inclusion de la lib windows.h ya pierde portablidad, pero la incluyo porque MySQL.h hace llamadas a sockets o sea winSock.h para poder establecer conexiones externas (ambiente Inet Global) y locales, la ventaja es que MySQL.h tambien esta para sistemas codigo abierto como Linux y Unix, pero en vez de windows.h habria que incluir otras librerias.

Nota: Algunas funciones no las comento, porque casi hacen las mismas llamadas y creo que entenderian el por que, pero si tienen alguna duda no olviden postear y claro cirtiquen el codigo falta optimizacion, aa se me olvido hacer la estrcutura de mi codigo con retornos para mayor optimizacion pero bueno algo es algo xD.

Salvedad: Doy por savido que los que lean este post es porque tienen conocimientos basicos de C y conocen bien los punteros a punteros y han trabajado con MySQL.

Antes de leer el codigo vean esto: (MYSQL_RES  *) es un identificador o variable que puede contener filas de un determinado campo en nuestra BD para poder luego consultar este. (MYSQL_ROW) es tipo puntero a puntero aunque no se haga uso de * pero si vemos como consultamos sus datos nos daremos cuenta, este acepta valores o elementos que se encuentran en "MYSQL_RES *" o sea lo que recojimos con "MYSQL_RES *" esta variable los puede manejar sin problemas. (MYSQL *) este acepta elementos o valores de un retorno a una variable del mismo tipo para luego enviar y recibir datos, o sea es quien nos envia, devuelve, conecta y desconecta del servidor MySQL.

#include <stdio.h>
#include <windows.h>
#include <mysql/mysql.h>
 
//prototipos de funciones
 
void mostrar(MYSQL *con, MYSQL_ROW row, MYSQL_RES *resultado, char *consulta);
void insertar(MYSQL *con, char *nombre, int id);
void borrar(MYSQL *con, MYSQL_RES *res, MYSQL_ROW row, int id);
void update(MYSQL *con);
void buscar(MYSQL *con, MYSQL_RES *res, MYSQL_ROW row, int id);
 
//cuerpo de funciones
 
void mostrar(MYSQL *con, MYSQL_ROW row, MYSQL_RES *resultado, char *consulta)
{
    //concatena las constantes a la variable consulta 
    sprintf(consulta, "select * from amigo;");
    //hacemos consulta y verificamos que se cumple
    if((mysql_query(con, consulta)==0))
    {
                         //guardamos resultado en la variable resultado que es de tipo MYSQL_RES *
                         resultado=mysql_use_result(con);
 
                         printf("Usuario    ID\n\n");
                         //leemos los datos almacenados en resultadoy lo devolvemos a la variable row que es de tipo MYSQL_ROW
                         while(row=mysql_fetch_row(resultado))
                         {
                                                              printf("%s---%s\n", row[0], row[1]);
                                                              }
                         }
                         //preguntamos si se ha llegado al final de nuestra variable resultado
                         if(!mysql_eof(resultado))
                         {
                                            printf("Error de lectura %s\n", mysql_error(con));
                                            }
                                            //cerramos conexion ya establecida
                                            //mysql_close(con);
 
                                            fflush(stdin);
                                            getchar();
 
                                            system("cls");
 
     }
 
void insertar(MYSQL *con, char *nombre, int id)
{
     char consulta[50];
 
     sprintf(consulta, "INSERT INTO amigo VALUES('%s', '%i');", nombre, id);
 
     if((mysql_query(con, consulta)==0))
     {
                          printf("Se agrego la nueva persona a la BD\n");
                          fflush(stdin);
                          getchar();
                          }
                          else
                          {
                              printf("Error no se pudo crear la nueva persona %s \n", mysql_error(con));
                              }
     system("cls");
     }
 
void borrar(MYSQL *con, MYSQL_RES *resultado, MYSQL_ROW row, int id)
{
     char consulta[50];
 
     sprintf(consulta, "DELETE FROM amigo WHERE id='%i';", id);
 
     if(mysql_query(con, consulta)==0)
     {
 
                      printf("Se elimino persona correctamente de la BD\n");
                      fflush(stdin);
                      getchar();
                      }
 
     system("cls");
     }
 
void update(MYSQL *con)
{
     char nombre[10], consulta[50];
     int op, id;
 
     printf("Que deseas modificar\n\n1:Nombre\n2:id\nOpcion: ");
     scanf("%i", &op);
 
     if(op==1)
     {
              printf("Inserta el ID de la persona a eliminar: ");
              scanf("%i", &id);
              printf("Inserte Nuevo Nombre: ");
              fflush(stdin);
              gets(nombre);
              printf("\n");
              sprintf(consulta, "UPDATE amigo SET nombre='%s' WHERE id='%d';", nombre, id);
              }
     else
     {
         printf("Inserte Nombre de la persona a elimininar: ");
         fflush(stdin);
         gets(nombre);
         printf("Inserte nuevo ID ");
         scanf("%i", &id);
         sprintf(consulta, "UPDATE amigo SET id='%i' WHERE nombre='%s';", id, nombre);
         }
 
     if(mysql_query(con, consulta)==0)
     {
                          printf("Se guardaron los datos correctamente");
                          getchar();
                          system("cls");
                          }
     }
 
void buscar(MYSQL *con, MYSQL_RES *res, MYSQL_ROW row, int id)
{
 
     char consulta[50];
 
     sprintf(consulta, "SELECT nombre, id FROM amigo WHERE id='%i';", id);
 
     if(mysql_query(con, consulta)==0)
     {
                         printf("Los datos se buscaron correctamente\n\n");
                         fflush(stdin);
 
                         res=mysql_use_result(con);
 
                         printf("Nombre      ID User\n\n");
 
                         while(row=mysql_fetch_row(res))
                         {
                                                        printf("%s      %s", row[0], row[1]);
                                                        }
                         }
 
                         getchar();
                         system("cls");
     }
 
int main()
{
    MYSQL *con;
    MYSQL_RES *resultado;
    MYSQL_ROW row;
    char consulta[1024], nombre[25];
    int id;
    int op;
    //inicializamos conexion SQL a algun atributo en este caso NULL.
    con = mysql_init(NULL);
    //establecemos conexion SQL y comprobamos que funciona
    if(!mysql_real_connect(con, "localhost", "root", NULL, "prueba", 3306, NULL, 0))
    {
                                printf("Error conectando con BD Prueba %s\n", mysql_error(con));
                                }
 
    printf("Que quieres hacer\n\n1:Leer BD\n2:Insertar Datos\n3:Eliminar Datos\n4:Actualizar Datos\n5:Buscar Datos\n\nEliga Opcion: ");
 
    scanf("%d", &op);
 
    switch(op)
    {
    case 1:
    system("cls");
    mostrar(con, row, resultado, consulta);
    return main();
    //break;
 
    case 2:
         system("cls");
         printf("Introduzca Nombre de persona: ");
         fflush(stdin);
         gets(nombre);
         printf("\n");
         printf("ID de persona: ");
         scanf("%i", &id);
         insertar(con, nombre, id);
         return main();
         //break;
 
   case 3:
        system("cls");
        printf("Inserte el ID de persona: ");
        fflush(stdin);
        scanf("%i", &id);
        borrar(con, resultado, row, id);  
        return main();    
        //break;
 
    case 4:
         system("cls");
         update(con);
         return main();
         //break;
 
    case 5:
         system("cls");
         printf("Inserte ID de persona a Buscar: ");
         scanf("%i", &id);
         system("cls");
         buscar(con, resultado, row, id);  
         return main();
 
    default:
            printf("Error no existe opcion\n\n");
            getchar();
            break;    
    }
    //cerramos conexion SQL
    mysql_close(con);
    getchar();
    }
 

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/