Foros del Web » Programación para mayores de 30 ;) » C/C++ »

Dudas de principiante en Win Api

Estas en el tema de Dudas de principiante en Win Api en el foro de C/C++ en Foros del Web. Buenas. Postee esta duda en otro foro pero no he obtenido respuesta asi que la planteo aqui a ver si alguien sabe responderme. Bien, he ...
  #1 (permalink)  
Antiguo 29/08/2011, 10:52
 
Fecha de Ingreso: abril-2009
Ubicación: En foros del web, normalmente en Web general, HTML y CSS.
Mensajes: 258
Antigüedad: 14 años, 11 meses
Puntos: 3
Dudas de principiante en Win Api

Buenas. Postee esta duda en otro foro pero no he obtenido respuesta asi que la planteo aqui a ver si alguien sabe responderme.

Bien, he podido crear eventos a los menus/sub-menus como se puede ver en este ejemplo:

Código C++:
Ver original
  1. case WM_COMMAND:
  2.             switch(LOWORD(wParam))
  3.             {
  4.                 case item1_menu2:
  5.                     MessageBox(hwnd, "Mensaje de prueba", "Titulo del mensaje", MB_OK);
  6.                     break;
  7.                 case item2_menu2:
  8.                     PostQuitMessage(0);
  9.                     break;
  10.             }
  11.             break;

Como sigo algunas guías en inglés por falta de material en castellano no comprendí muy bien lo que hace switch(LOWORD(wParam)) pero puedo suponer razonando que es algo asi como "al darle clic a ...", corregídme si me equivoco.

Ahora, he intentado crear un evento a un botón y un edit pero no lo consigo; aqui os dejo el código (en rojo lo correspondiente al botón, lo demás es lo que te da como plantilla Code::Blocks):

Cita:
#include <windows.h>

/* Declare Windows procedure */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/* Make the class name into a global variable */
char szClassName[ ] = "CodeBlocksWindowsApp";

HINSTANCE mi_instance;

int WINAPI WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nCmdShow)
{
HWND hwnd; /* This is the handle for our window */
MSG messages; /* Here messages to the application are saved */
WNDCLASSEX wincl; /* Data structure for the windowclass */
mi_instance = hThisInstance;

/* The Window structure */
wincl.hInstance = hThisInstance;
wincl.lpszClassName = szClassName;
wincl.lpfnWndProc = WindowProcedure; /* This function is called by windows */
wincl.style = CS_DBLCLKS; /* Catch double-clicks */
wincl.cbSize = sizeof (WNDCLASSEX);

/* Use default icon and mouse-pointer */
wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
wincl.lpszMenuName = NULL; /* No menu */
wincl.cbClsExtra = 0; /* No extra bytes after the window class */
wincl.cbWndExtra = 0; /* structure or the window instance */
/* Use Windows's default colour as the background of the window */
wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

/* Register the window class, and if it fails quit the program */
if (!RegisterClassEx (&wincl))
return 0;

/* The class is registered, let's create the program*/
hwnd = CreateWindowEx (
0, /* Extended possibilites for variation */
szClassName, /* Classname */
"Code::Blocks Template Windows App", /* Title Text */
WS_OVERLAPPEDWINDOW, /* default window */
CW_USEDEFAULT, /* Windows decides the position */
CW_USEDEFAULT, /* where the window ends up on the screen */
544, /* The programs width */
375, /* and height in pixels */
HWND_DESKTOP, /* The window is a child-window to desktop */
NULL, /* No menu */
hThisInstance, /* Program Instance handler */
NULL /* No Window Creation data */
);

/* Make the window visible on the screen */
ShowWindow (hwnd, nCmdShow);

/* Run the message loop. It will run until GetMessage() returns 0 */
while (GetMessage (&messages, NULL, 0, 0))
{
/* Translate virtual-key messages into character messages */
TranslateMessage(&messages);
/* Send message to WindowProcedure */
DispatchMessage(&messages);
}

/* The program return-value is 0 - The value that PostQuitMessage() gave */
return messages.wParam;
}


/* This function is called by the Windows function DispatchMessage() */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) /* handle the messages */
{
case WM_CREATE:
{
HWND hwnd_boton1 = CreateWindowEx (NULL, "BUTTON", "Texto", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 100, 100, 90, 25, hwnd, NULL, mi_instance, NULL);
break;
}


case WM_DESTROY:
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
default: /* for messages that we don't deal with */
return DefWindowProc (hwnd, message, wParam, lParam);
}

return 0;
}
Para crear el evento he añadido debajo del WM_CREATE esto otro basándome en los ejemplos de los tutoriales (en rojo señalo dónde me da error):

Cita:
case WM_COMMAND:
{
if ((HWND)lParam==hwnd_boton1)
{
MessageBox(NULL, "Se ha presionado el boton", "Título", MB_OK | MB_ICONEXCLAMATION);
}
break;
}
De ahi me surge otra duda: ¿Por qué para crear eventos en los menus se usa (LOWORD(wParam)) y en botones ((HWND)lParam==hwnd_boton1) si en ambos casos se hace "clic" para activar el evento?.

Aparte de eso se me complica el hacer programas algo más currados por el hecho de no poder definir un "int main ()" ni funciones/clases (cuando lo hago el programa se salta la interfaz y vuelve a la linea de comandos); es mas, si imprimo en pantalla un mensaje con "cout" en vez de salir en la ventana del programa me sale en una línea de comandos. Entonces, ¿dónde se declaran y definen las funciones/clases (en general cualquier acción que no sea WM_CREATE, WM_COMMAND...) en un programa creado con Win API?, ¿y se puede crear un "int main ()"? (ya he mencionado lo que me da como plantilla Code::Blocks).

Gracias por adelantado. Saludos.
__________________
¿Por qué Anónimo?, porque como está el mundo no podemos considerarnos humanos...

Última edición por Anonimo12; 29/08/2011 a las 11:06
  #2 (permalink)  
Antiguo 29/08/2011, 13:23
Avatar de Instru  
Fecha de Ingreso: noviembre-2002
Ubicación: Mexico
Mensajes: 2.751
Antigüedad: 21 años, 4 meses
Puntos: 52
Respuesta: Dudas de principiante en Win Api

Hola de nuevo.
Tus cuestiones si son algo complicadas de entender. Por eso en lo personal, no me agrada la WINAPI.

Pero la experiencia me ha llevado a usarla y a entenderla hasta cierto punto.

En primer instancia.
Un "requisito" que te pide Windows para programar un aplicacion con ventanas es de que tengas un WinMain, a diferencia de otros sistemas operativos donde con el mismo main() es mas que suficiente.

Aun asi, WinMain es en escencia muy parecida a main.

Podrias por ejemplo hacer un programa que solo tuviera winmain y ya.

Lo cual crearia una aplicacion que no mostraria nada en pantalla(no ventanas, no consolas, nada), solo tendria su espacio en la barra de ventanas. Y bueno, como buena aplicacion sin nada, se cerraria automaticamente tras un parpadeo(Corrijanme si me equivoco).

Ahora, una vez teniendo es como base, se necesitan 2 cosas.
Una ventana en este caso. Que veo que ya conoces las funciones mas importantes para crear ventanas. Lo complicado de esto, es que hay millones de maneras y combinaciones diferentes de crear ventanas(colores, tamaños, tipos y otros parametros obscuros). Aqui lo importante es saber que es lo mas usual, y a menos que sepas ya que quieres algo "no usual" entonces te metes a investigar los parametros. Por ejemplo. Algo usuarl, seria una ventana con los colores predeterminados, de un tamaño mmm de 100x100, con sus botones de minimizar, maximizar y cerrar.

Ahora, ya tienes una ventana, sin embargo no por crearla significa que ya se ve. Tienes que indicarle al Windows varias cosas, entre ellas, decirle que has creado una nueva ventana y que quieres como "registrarla" para que windows la tenga en su "lista de ventanas", despues informarle que tu ventana ya esta lista para ser mostrada. Entonces, a partir de ahi, Windows hace la "magia" de como y cuando mostrar tu pantalla. Tu no programas los botones minimizar o cerrar. Windows se encarga de manejar todo eso por ti.(En realidad se trata de el ambiente grafico de windows).
Por ejemplo si tienes varias aplicaciones abiertas, Windows tiene que decidir cuando se y cuando no se ve tu aplicacion. Todo esto qeuda escondido tanto para el usuario como para el programador.

Ahora. Ya sabemos como mostrar una ventana.
Pero queremos poder controlar lo que sucede dentro de esa ventana.
A diferencia de otros sistemas operativos, Windows usa un sistema de eventos-mensajes.

La manera de que Windows y tu se comuniquen con la ventana es a traves de mensajes.

Por lo mismo creas un loop(while, do while o for) que se encargue de 2 cosas, de procesar lo mensajes que te interesan, y de enviar los mensajes a tu aplicacion.

En este caso, es lo que el ciclo principal hace.
Dentro del ciclo, tienes una funcion que lo que hace es interceptar los mensajes que envia la aplicacion.
Sin embargo no nos interesan toooodos los mensajes ya que son muuuuchos y a estas alturas no todos son de utilidad.

Si no mal recuerdo algunos mensajes comunes son WM_CREATE, WM_COMMAND, WM_DESTROY, etc. Puedes ver en la MSDN para que sirven especificamente.

Pero bueno, el mensaje por si solo no siempre ayuda mucho. Muchas veces la aplicacion o el sistema operativo necesita enviar datos aparte del mensaje.

Entonces usa variables parametro, que por lo comun acostumbran llamarlas wparam o lparam.
Y pues haciendo especulacion supongo que son de 32 bits.
Estas variables van a contener los datos que quieres enviar o que acabas de recibir junto con el mensaje.

Que datos hay ahi?? eso depende del mensaje. Para eso hay que ver la MSDN y ver en que formato se envian o reciben los datos.
A veces 2 datos diferentes se juntan en una sola variable. Como 2 datos de 16 bits.
Entonces para separarlos hay de 2, o usamos los operadores binarios &, |, ^, o usamos las macros que la WINAPI ofrece: LOWORD, HIWORD.

por eso la instruccion

switch(LOWORD(wParam))

significa que vamos a filtrar los valores bajos de 16 bits de la variable wParam y pues con los cases ya filtramos los datos, que muchas veces son mas mensajes(submensajes).

Espero que con esta explicacion entiendas la estructura de un programa Windows.
El chsite no es saber que significan los tipos de variables o ver como es una estructura. El punto es entender los pilares de una aplicacion windows sencilla.
Que en este caso podria yo decir que es el sistema de eventos-mensajes.
Si entiendes bien este sistema, puedes simplificar muuucho los codigos, y veras que al final de cuentas no va a diferir taaanto de una aplicaicon para consola.

Saludos
  #3 (permalink)  
Antiguo 29/08/2011, 13:52
Avatar de Munire  
Fecha de Ingreso: julio-2010
Ubicación: en el ciberdespacio (España)
Mensajes: 150
Antigüedad: 13 años, 8 meses
Puntos: 4
Respuesta: Dudas de principiante en Win Api

Cita:
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) /* handle the messages */
{
case WM_CREATE:
{
HWND hwnd_boton1 = CreateWindowEx (NULL, "BUTTON", "Texto", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 100, 100, 90, 25, hwnd, NULL, mi_instance, NULL);
break;
}

case WM_DESTROY:
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
default: /* for messages that we don't deal with */
return DefWindowProc (hwnd, message, wParam, lParam);
}

return 0;
}
la funcion createwindowEx() va antes del switch. y dentro del case WM_CREATE se pone la funcion SendMessage para mostrar lo que has creado


Cita:
si imprimo en pantalla un mensaje con "cout" en vez de salir en la ventana del programa me sale en una línea de comandos.
es que cout sirve solo para mostrar por consola.

te dejo un ejemplo para que veas como se crea un boton y como se pone texto



Código C++:
Ver original
  1. #include <windows.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <tchar.h>
  5.  
  6. const int MN_MENSAJE=1025;
  7. const int MN_SALIR=1026;
  8. const int MN_SAL=1027;
  9. // Global variables
  10.  
  11. // The main window class name.
  12. static TCHAR szWindowClass[] = _T("win32app");
  13.  
  14. // The string that appears in the application's title bar.
  15. static TCHAR szTitle[] = _T("Win32 Application");
  16.  
  17. HINSTANCE hInst, miinstance;
  18.  
  19. // Forward declarations of functions included in this code module:
  20. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  21.  
  22.  
  23. int WINAPI WinMain(HINSTANCE hInstance,
  24.                    HINSTANCE hPrevInstance,
  25.                    LPSTR lpCmdLine,
  26.                    int nCmdShow)
  27. {
  28.     WNDCLASSEX wcex;
  29.     miinstance = hInstance;
  30.     wcex.cbSize = sizeof(WNDCLASSEX);
  31.     wcex.style          = CS_HREDRAW | CS_VREDRAW;
  32.     wcex.lpfnWndProc    = WndProc;
  33.     wcex.cbClsExtra     = 0;
  34.     wcex.cbWndExtra     = 0;
  35.     wcex.hInstance      = hInstance;
  36.     wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPLICATION));
  37.     wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
  38.     wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
  39.     wcex.lpszMenuName   = NULL;
  40.     wcex.lpszClassName  = szWindowClass;
  41.     wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_APPLICATION));
  42.  
  43.     if (!RegisterClassEx(&wcex))
  44.     {
  45.         MessageBox(NULL,
  46.             _T("Call to RegisterClassEx failed!"),
  47.             _T("Win32 Guided Tour"),
  48.             NULL);
  49.        
  50.         return 1;
  51.     }
  52.  
  53.     hInst = hInstance; // Store instance handle in our global variable
  54.  
  55.     // The parameters to CreateWindow explained:
  56.     // szWindowClass: the name of the application
  57.     // szTitle: the text that appears in the title bar
  58.     // WS_OVERLAPPEDWINDOW: the type of window to create
  59.     // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
  60.     // 500, 100: initial size (width, length)
  61.     // NULL: the parent of this window
  62.     // NULL: this application dows not have a menu bar
  63.     // hInstance: the first parameter from WinMain
  64.     // NULL: not used in this application
  65.     HWND hWnd = CreateWindow(
  66.         szWindowClass,
  67.         szTitle,
  68.         WS_OVERLAPPEDWINDOW,
  69.         CW_USEDEFAULT, CW_USEDEFAULT,
  70.         500, 500,
  71.         NULL,
  72.         NULL,
  73.         hInstance,
  74.         NULL
  75.     );
  76.    
  77.     if (!hWnd)
  78.     {
  79.         MessageBox(NULL,
  80.             _T("Call to CreateWindow failed!"),
  81.             _T("Win32 Guided Tour"),
  82.             NULL);
  83.  
  84.         return 1;
  85.     }
  86.  
  87.     // The parameters to ShowWindow explained:
  88.     // hWnd: the value returned from CreateWindow
  89.     // nCmdShow: the fourth parameter from WinMain
  90.     ShowWindow(hWnd,
  91.         nCmdShow);
  92.     UpdateWindow(hWnd);
  93.  
  94.     // Main message loop:
  95.     MSG msg;
  96.     while (GetMessage(&msg, NULL, 0, 0))
  97.     {
  98.         TranslateMessage(&msg);
  99.         DispatchMessage(&msg);
  100.     }
  101.  
  102.     return (int) msg.wParam;
  103. }
  104.  
  105.  
  106. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  107. {
  108.     PAINTSTRUCT ps;
  109.     HDC hdc;
  110.     TCHAR greeting[] = _T("Hello, World!");
  111.     HMENU menu1 = CreateMenu();
  112.     HMENU menu2 = CreateMenu();
  113.     HMENU menu3 = CreateMenu();
  114.    
  115.         static HFONT hFont = CreateFont(14, 0, 0, 0, 100, 0, 0, 0,0, 0, 0, 0, VARIABLE_PITCH | FF_SWISS, _T("Helv"));
  116.         static HWND hwndButton1 = CreateWindowEx(0,_T("BUTTON"), _T("Nuestro boton"), WS_CHILD|WS_VISIBLE|WS_TABSTOP, 300, 300, 100, 20, hWnd, 0, miinstance, NULL);
  117.         static HWND hwndEdit1 = CreateWindowEx(0,_T("Edit"), _T("asd"), WS_CHILD|WS_VISIBLE|WS_TABSTOP, 100, 100, 100, 20, hWnd, 0, miinstance, NULL);
  118.  
  119.     switch (message)
  120.     {
  121.  
  122.     case WM_CREATE:
  123.         AppendMenu(menu2, MF_STRING, MN_MENSAJE, _T("Mensaje"));
  124.         AppendMenu(menu2, MF_STRING, MN_SALIR, _T("Salir"));
  125.         AppendMenu(menu3, MF_STRING, MN_SAL, _T("opc1"));
  126.         AppendMenu(menu3, MF_STRING, MN_SAL, _T("opc2"));
  127.         AppendMenu(menu1, MF_STRING | MF_POPUP, (UINT)menu2, _T("MiMenu"));
  128.         AppendMenu(menu1, MF_STRING | MF_POPUP, (UINT)menu3, _T("Opciones"));
  129.         SetMenu (hWnd, menu1);
  130.         SendMessage(hwndButton1, WM_SETFONT, (WPARAM) hFont, true);
  131.         SendMessage(hwndEdit1, WM_SETFONT, (WPARAM) hFont, true);
  132.  
  133.         break;
  134.      
  135.     case WM_COMMAND:
  136.         switch(LOWORD(wParam))
  137.         {
  138.         case MN_MENSAJE:
  139.             MessageBox(hWnd, _T("Hola Mundo"), _T("Title"), MB_OK);
  140.             break;
  141.         case MN_SALIR:
  142.             PostQuitMessage(0);
  143.             break;
  144.         }
  145.         break;
  146.  
  147.     case WM_PAINT:
  148.         hdc = BeginPaint(hWnd, &ps);
  149.  
  150.         // Here your application is laid out.   LPCWSTR
  151.         // For this introduction, we just print out "Hello, World!"
  152.         // in the top left corner.
  153.         TextOut(hdc,
  154.             200, 200,
  155.             greeting, _tcslen(greeting));
  156.        
  157.         // End application specific layout section.
  158.        
  159.         EndPaint(hWnd, &ps);
  160.         break;
  161.     case WM_DESTROY:
  162.         PostQuitMessage(0);
  163.         break;
  164.     default:
  165.         return DefWindowProc(hWnd, message, wParam, lParam);
  166.         break;
  167.     }
  168.  
  169.     return 0;
  170. }
  #4 (permalink)  
Antiguo 29/08/2011, 16:48
 
Fecha de Ingreso: abril-2009
Ubicación: En foros del web, normalmente en Web general, HTML y CSS.
Mensajes: 258
Antigüedad: 14 años, 11 meses
Puntos: 3
Respuesta: Dudas de principiante en Win Api

Instru: Gracias por tomarte las molestias con esa explicación, ya lo veo más claro :)

Munire: Asi que la declaración y definición de los botones/edit va fuera del Switch, mientras que la declaración de los menus va fuera y la definición en WM_CREATE; ya veo como se organiza.

Sobre poner un texto me funciona a la perfección, basándome en tu ejemplo he hecho uno sencillo:

Código C++:
Ver original
  1. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  2. {
  3.  
  4.     PAINTSTRUCT ps;
  5.     HDC hdc;
  6.     TCHAR texto[] = _T("Hello, World!");
  7.  
  8.  
  9.  
  10.     switch (message)                  /* handle the messages */
  11.     {
  12.         case WM_PAINT:
  13.         hdc = BeginPaint(hwnd, &ps);
  14.         TextOut(hdc, 200, 200, texto, _tcslen(texto));
  15.         EndPaint(hwnd, &ps);
  16.         break;
  17.  
  18.  
  19.         case WM_DESTROY:
  20.             PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
  21.             break;
  22.         default:                      /* for messages that we don't deal with */
  23.             return DefWindowProc (hwnd, message, wParam, lParam);
  24.     }
  25.  
  26.     return 0;
  27. }

El PAINTSTRUCT ps puedo suponer que es para crear un objeto (ps) de la estructura "PAINTSTRUCT", el HDC hdc será lo mismo pero no tengo ni idea de para qué sirve y el TCHAR está claro que es el texto en si.

Luego abajo hdc = BeginPaint(hwnd, &ps); me hago una idea por encima pero no lo tengo claro aunque he comprobado que puedo hacer lo siguiente:

Cita:
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{

PAINTSTRUCT ps;
HDC hdc;
TCHAR texto[] = _T("Hello, World!");
TCHAR texto2[] = _T("Otro texto");



switch (message) /* handle the messages */
{
case WM_PAINT:
hdc = BeginPaint(hwnd, &ps);
TextOut(hdc, 200, 200, texto, _tcslen(texto));
TextOut(hdc, 300, 300, texto2, _tcslen(texto2));
EndPaint(hwnd, &ps);

break;


case WM_DESTROY:
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
default: /* for messages that we don't deal with */
return DefWindowProc (hwnd, message, wParam, lParam);
}

return 0;
}
Puedo crear varios textos sin necesidad de crear más "hdc" ni "paintstruct", es mas, he eliminido el EndPaint (hwnd, &ps) y no he encontrado ningún problema (¿por qué se debe finalizar la impresión?).

Ahora, aun poniendo la declaracón/definición del botón antes del switch no me deja crearle un evento, he probado 4583 cosas pero nada, puedo crear un evento a los menus y me va perfectamente pero no a los botones/edit. Cuando le doy clic al botón no consigo que realice ninguna acción ni cuando escribo un texto en los edit no me lo guarda en una variable. Aqui te dejo el código del mejor resultado que he conseguido creandole un evento a un botón:

Código C++:
Ver original
  1. #include <windows.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <tchar.h>
  5.  
  6.  
  7. HINSTANCE miinstance;
  8.  
  9.  
  10. /*  Declare Windows procedure  */
  11. LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
  12.  
  13. /*  Make the class name into a global variable  */
  14. char szClassName[ ] = "CodeBlocksWindowsApp";
  15.  
  16. int WINAPI WinMain (HINSTANCE hThisInstance,
  17.                      HINSTANCE hPrevInstance,
  18.                      LPSTR lpszArgument,
  19.                      int nCmdShow)
  20. {
  21.     HWND hwnd;               /* This is the handle for our window */
  22.     MSG messages;            /* Here messages to the application are saved */
  23.     WNDCLASSEX wincl;        /* Data structure for the windowclass */
  24.  
  25.     miinstance = hThisInstance;
  26.  
  27.  
  28.  
  29.     /* The Window structure */
  30.     wincl.hInstance = hThisInstance;
  31.     wincl.lpszClassName = szClassName;
  32.     wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
  33.     wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
  34.     wincl.cbSize = sizeof (WNDCLASSEX);
  35.  
  36.     /* Use default icon and mouse-pointer */
  37.     wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  38.     wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
  39.     wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
  40.     wincl.lpszMenuName = NULL;                 /* No menu */
  41.     wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
  42.     wincl.cbWndExtra = 0;                      /* structure or the window instance */
  43.     /* Use Windows's default colour as the background of the window */
  44.     wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
  45.  
  46.     /* Register the window class, and if it fails quit the program */
  47.     if (!RegisterClassEx (&wincl))
  48.         return 0;
  49.  
  50.     /* The class is registered, let's create the program*/
  51.     hwnd = CreateWindowEx (
  52.            0,                   /* Extended possibilites for variation */
  53.            szClassName,         /* Classname */
  54.            "Code::Blocks Template Windows App",       /* Title Text */
  55.            WS_OVERLAPPEDWINDOW, /* default window */
  56.            CW_USEDEFAULT,       /* Windows decides the position */
  57.            CW_USEDEFAULT,       /* where the window ends up on the screen */
  58.            544,                 /* The programs width */
  59.            375,                 /* and height in pixels */
  60.            HWND_DESKTOP,        /* The window is a child-window to desktop */
  61.            NULL,                /* No menu */
  62.            hThisInstance,       /* Program Instance handler */
  63.            NULL                 /* No Window Creation data */
  64.            );
  65.  
  66.     /* Make the window visible on the screen */
  67.     ShowWindow (hwnd, nCmdShow);
  68.  
  69.     /* Run the message loop. It will run until GetMessage() returns 0 */
  70.     while (GetMessage (&messages, NULL, 0, 0))
  71.     {
  72.         /* Translate virtual-key messages into character messages */
  73.         TranslateMessage(&messages);
  74.         /* Send message to WindowProcedure */
  75.         DispatchMessage(&messages);
  76.     }
  77.  
  78.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
  79.     return messages.wParam;
  80. }
  81.  
  82.  
  83. /*  This function is called by the Windows function DispatchMessage()  */
  84.  
  85. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  86. {
  87.  
  88.      HWND boton1 = CreateWindowEx (0,"BUTTON", "Texto", WS_CHILD|WS_VISIBLE|WS_TABSTOP, 100, 100, 100, 20, hwnd, 0, miinstance, NULL);
  89.  
  90.     switch (message)                  /* handle the messages */
  91.     {
  92.        case WM_COMMAND:
  93.             if((HWND)lParam==boton1)
  94.             {
  95.                 MessageBox (NULL, "Esto es un texto", "Título", MB_OK | MB_ICONEXCLAMATION);
  96.             }
  97.             break;
  98.  
  99.         case WM_DESTROY:
  100.             PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
  101.             break;
  102.         default:                      /* for messages that we don't deal with */
  103.             return DefWindowProc (hwnd, message, wParam, lParam);
  104.     }
  105.  
  106.     return 0;
  107. }

Se me queda pillada la ventana completamente vacia y al rato aparece el botón pero aunque le doy no hace nada. En fin no se me ocurren más cosas que probar y me he recorrido medio internet asi que vuelvo a recurrir a vosotros a ver si podéis decime cómo se hace.

Sientos las molestias, gracias por adelantado. Saludos.
__________________
¿Por qué Anónimo?, porque como está el mundo no podemos considerarnos humanos...

Última edición por Anonimo12; 29/08/2011 a las 17:00
  #5 (permalink)  
Antiguo 30/08/2011, 05:46
Avatar de Munire  
Fecha de Ingreso: julio-2010
Ubicación: en el ciberdespacio (España)
Mensajes: 150
Antigüedad: 13 años, 8 meses
Puntos: 4
Respuesta: Dudas de principiante en Win Api

Se te ha olvidado poner el case WM_CREATE:



Código:
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
 
     HWND boton1 = CreateWindowEx (0,"BUTTON", "Texto", WS_CHILD|WS_VISIBLE|WS_TABSTOP, 100, 100, 100, 20, hwnd, 0, miinstance, NULL);
 
    switch (message)                  /* handle the messages */
    {

       case WM_CREATE:
            SendMessage( boton1, WM_SETFONT, (WPARAM) hFont, true);
            break;

       case WM_COMMAND:
            if((HWND)lParam==boton1)
            {
                MessageBox (NULL, "Esto es un texto", "Título", MB_OK | MB_ICONEXCLAMATION);
            }
            break;
 
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }
 
    return 0;
}
una cosa importante: los textos en estas funciones (p.e MessageBox o CreateWindowEx) no se ponen como const char es decir "texto const char", se ponen como tipo LPCTSTR. esto supone añadir _T antes del texto.

_T("texto del tipo LPCTSTR")

las funciones quedarian asi:

Código C++:
Ver original
  1. CreateWindowEx(0,_T("BUTTON"), _T("Nuestro boton"), WS_CHILD|WS_VISIBLE|WS_TABSTOP, 300, 300, 100, 20, hWnd, 0, miinstance, NULL);
  2. MessageBox(hWnd, _T("Hola Mundo"), _T("Title"), MB_OK);


¿como se sabe esto? pues por que en la declaracion de la funcion no pone

funcion(..., char * texto,...)

si no

funcion(..., LPCTSTR texto, ...)


por ejemplo la declaracion de MessageBox

int WINAPI MessageBox(
__in_opt HWND hWnd,
__in_opt LPCTSTR lpText,
__in_opt LPCTSTR lpCaption,
__in UINT uType
);

http://msdn.microsoft.com/en-us/library/ms645505




Cita:
Puedo crear varios textos sin necesidad de crear más "hdc" ni "paintstruct", es mas, he eliminido el EndPaint (hwnd, &ps) y no he encontrado ningún problema (¿por qué se debe finalizar la impresión?).
yo no lo eliminaria, si está es por algo, no crees?
  #6 (permalink)  
Antiguo 30/08/2011, 18:27
 
Fecha de Ingreso: abril-2009
Ubicación: En foros del web, normalmente en Web general, HTML y CSS.
Mensajes: 258
Antigüedad: 14 años, 11 meses
Puntos: 3
Respuesta: Dudas de principiante en Win Api

Gracias ya me va a la perfección. Aprovecho el mismo tema para preguntar otra cosa y asi no spammeo:

Cómo puedo hacer para guardar un valor introducido en un edit, por ejemplo:

Tengo un edit--> el usuario introduce un texto o número ---> al darle a enter o a un botón ese texto/número se guarda en una variable. Creo y solo creo que lo he conseguido de la siguiente forma, pero al intentar imprimir en pantalla el valor no puedo:

Código C++:
Ver original
  1. #include <windows.h>
  2. #include <tchar.h>
  3.  
  4. enum {ID_boton1 = 1000, ID_edit1};
  5.  
  6. /*  Declare Windows procedure  */
  7. LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
  8.  
  9. /*  Make the class name into a global variable  */
  10. char szClassName[ ] = "CodeBlocksWindowsApp";
  11.  
  12.  
  13. HINSTANCE estancia;
  14. HWND boton1;
  15. HWND edit1;
  16.  
  17.  
  18. int WINAPI WinMain (HINSTANCE hThisInstance,
  19.                      HINSTANCE hPrevInstance,
  20.                      LPSTR lpszArgument,
  21.                      int nCmdShow)
  22. {
  23.     HWND hwnd;               /* This is the handle for our window */
  24.     MSG messages;            /* Here messages to the application are saved */
  25.     WNDCLASSEX wincl;        /* Data structure for the windowclass */
  26.  
  27.     estancia = hThisInstance;
  28.  
  29.     /* The Window structure */
  30.     wincl.hInstance = hThisInstance;
  31.     wincl.lpszClassName = szClassName;
  32.     wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
  33.     wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
  34.     wincl.cbSize = sizeof (WNDCLASSEX);
  35.  
  36.     /* Use default icon and mouse-pointer */
  37.     wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  38.     wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
  39.     wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
  40.     wincl.lpszMenuName = NULL;                 /* No menu */
  41.     wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
  42.     wincl.cbWndExtra = 0;                      /* structure or the window instance */
  43.     /* Use Windows's default colour as the background of the window */
  44.     wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
  45.  
  46.     /* Register the window class, and if it fails quit the program */
  47.     if (!RegisterClassEx (&wincl))
  48.         return 0;
  49.  
  50.     /* The class is registered, let's create the program*/
  51.     hwnd = CreateWindowEx (
  52.            0,                   /* Extended possibilites for variation */
  53.            szClassName,         /* Classname */
  54.            "Code::Blocks Template Windows App",       /* Title Text */
  55.            WS_OVERLAPPEDWINDOW, /* default window */
  56.            CW_USEDEFAULT,       /* Windows decides the position */
  57.            CW_USEDEFAULT,       /* where the window ends up on the screen */
  58.            544,                 /* The programs width */
  59.            375,                 /* and height in pixels */
  60.            HWND_DESKTOP,        /* The window is a child-window to desktop */
  61.            NULL,                /* No menu */
  62.            hThisInstance,       /* Program Instance handler */
  63.            NULL                 /* No Window Creation data */
  64.            );
  65.  
  66.     /* Make the window visible on the screen */
  67.     ShowWindow (hwnd, nCmdShow);
  68.  
  69.     /* Run the message loop. It will run until GetMessage() returns 0 */
  70.     while (GetMessage (&messages, NULL, 0, 0))
  71.     {
  72.         /* Translate virtual-key messages into character messages */
  73.         TranslateMessage(&messages);
  74.         /* Send message to WindowProcedure */
  75.         DispatchMessage(&messages);
  76.     }
  77.  
  78.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
  79.     return messages.wParam;
  80. }
  81.  
  82.  
  83.  
  84.  
  85. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  86. {
  87.  
  88.  
  89.  
  90.     PAINTSTRUCT ps;
  91.     HDC hdc;
  92.     TCHAR texto [256];   //no sé si esto está bien o tengo que decalararlo como "static char texto [256]"
  93.  
  94.     switch (message)
  95.     {
  96.         case WM_CREATE:
  97.         {
  98.  
  99.             //Botón y edit
  100.  
  101.             boton1 = CreateWindow (_T("Button"), _T("Texto"), BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE, 80, 100, 70, 25, hwnd, (HMENU) ID_boton1, estancia, 0);
  102.             edit1 = CreateWindow (_T("Edit"), 0, WS_CHILD | WS_VISIBLE, 160, 100, 100, 35, hwnd, (HMENU) ID_edit1, estancia, 0);
  103.             break;
  104.         }
  105.  
  106.         case WM_COMMAND:
  107.         switch (wParam)
  108.         {
  109.             // Al presionar el boton1 se obtiene lo que hay en el edit1 y se guarda en texto
  110.  
  111.             case ID_boton1:
  112.             GetWindowText(edit1, texto, 255);
  113.         }
  114.  
  115.         break;
  116.  
  117.  
  118.         case WM_PAINT:
  119.         hdc = BeginPaint(hwnd, &ps);
  120.  
  121.         TextOut(hdc, 200, 200, texto, _tcslen(texto));   //Imprime en pantalla lo que se ha guardado en la variable "texto"
  122.  
  123.         EndPaint(hwnd, &ps);
  124.         break;
  125.  
  126.         case WM_DESTROY:
  127.             PostQuitMessage (0);
  128.             break;
  129.         default:
  130.             return DefWindowProc (hwnd, message, wParam, lParam);
  131.     }
  132.  
  133.     return 0;
  134. }

He puesto comentarios después del "WindowProcedure" explicando lo que he hecho, de primeras puedo suponer que "TextOut" sirve solo para imprimir textos declarados anteriormente en el código y no los que se introducen en el edit y guardan en variables, por tanto no sé como se hace.

Saludos.
__________________
¿Por qué Anónimo?, porque como está el mundo no podemos considerarnos humanos...
  #7 (permalink)  
Antiguo 31/08/2011, 03:48
Avatar de Munire  
Fecha de Ingreso: julio-2010
Ubicación: en el ciberdespacio (España)
Mensajes: 150
Antigüedad: 13 años, 8 meses
Puntos: 4
Respuesta: Dudas de principiante en Win Api

antes de nada decirte que no se que pasa pero no puedo compilar tu codigo en mi IDE (Visual Studio 2010) por lo que no puedo comprobarlo.


otra cosa, por que lo pones asi
Código C++:
Ver original
  1. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  2. {
  3.  
  4.  
  5.  
  6.     PAINTSTRUCT ps;
  7.     HDC hdc;
  8.     TCHAR texto [256];   //no sé si esto está bien o tengo que decalararlo como "static char texto [256]"
  9.  
  10.     switch (message)
  11.     {
  12.         case WM_CREATE:
  13.         {
  14.             boton1 = CreateWindow (_T("Button"), _T("Texto"), BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE, 80, 100, 70, 25, hwnd, (HMENU) ID_boton1, estancia, 0);

y no como te dije? CreateWindowEx antes del switch y SendMessage( boton1, WM_SETFONT, (WPARAM) hFont, true); dentro del case CREATE;

es por curiosidad, por que no se que diferencia habrá.

###########################################


aqui te falta un break;

Código:
        case WM_COMMAND:
        switch (wParam)
        {
            // Al presionar el boton1 se obtiene lo que hay en el edit1 y se guarda en texto
 
            case ID_boton1:
            GetWindowText(edit1, texto, 255);
            break;
        }
###########################################

respecto a tu pregunta:

estas ordenando que muestre por pantalla el texto dentro del case PAINT: es decir te lo va a mostrar nada mas arrancar el programa. y como no le has dado al boton1 para que coja el texto del Edit1 no hay texto que mostrar.
lo que tienes que hacer es mostrar el texto al apretar el boton1 y despues de cogerlo con el GetWindowText().


Código:
        case WM_COMMAND:
        switch (wParam)
        {
            case ID_boton1:
            GetWindowText(edit1, texto, 255);
            // MOSTAR TEXTO
           break;
        }
  #8 (permalink)  
Antiguo 31/08/2011, 10:05
 
Fecha de Ingreso: abril-2009
Ubicación: En foros del web, normalmente en Web general, HTML y CSS.
Mensajes: 258
Antigüedad: 14 años, 11 meses
Puntos: 3
Respuesta: Dudas de principiante en Win Api

Cita:
y no como te dije? CreateWindowEx antes del switch y SendMessage( boton1, WM_SETFONT, (WPARAM) hFont, true); dentro del case CREATE;

es por curiosidad, por que no se que diferencia habrá.
No te lo comenté, pero al usar varios botones y edit simultáneamente me fallan los compiladores (en algunos me pone "no compilado" sin mostrar ningún error y en otros se queda pillado directamente), por tanto probé con los datos que me diste pero metiéndolo en el WM_CREATE todo ya que, razonando, no estoy declarando el botón/edit sino creándolo (definiéndolo) y eso va dentro del create según pone en el ejemplo del último comentario de esta página http://www.cplusplus.com/forum/windows/3933/

Cita:
respecto a tu pregunta:

estas ordenando que muestre por pantalla el texto dentro del case PAINT: es decir te lo va a mostrar nada mas arrancar el programa. y como no le has dado al boton1 para que coja el texto del Edit1 no hay texto que mostrar.
lo que tienes que hacer es mostrar el texto al apretar el boton1 y despues de cogerlo con el GetWindowText().
Muchas gracias, ¿entonces lo del GetWindoText() lo tengo bien?, es decir, guarda el número/texto introducido en la variable ¿cierto?; por lo tanto lo que está mal es la impresión del texto en pantalla como me has comentado. Ahora mismo no puedo probarlo pero ¿sería de esta forma o el TextOut solo va dentro de WM_PAINT?:

Código C++:
Ver original
  1. case WM_COMMAND:
  2.         switch (wParam)
  3.         {
  4.             case ID_boton1:
  5.             GetWindowText(edit1, texto, 255);
  6.            
  7.             //Imprimir en pantalla
  8.             hdc = BeginPaint(hwnd, &ps);
  9.             TextOut(hdc, 200, 200, texto, _tcslen(texto));
  10.             EndPaint(hwnd, &ps);
  11.            break;
  12.         }

Si el TextOut() solo funciona dentro del WM_PAINT ¿qué función debería usar al querer imprimir en pantalla desde WM_COMMAND?...

Saludos.
__________________
¿Por qué Anónimo?, porque como está el mundo no podemos considerarnos humanos...

Última edición por Anonimo12; 31/08/2011 a las 10:23
  #9 (permalink)  
Antiguo 31/08/2011, 15:39
Avatar de Munire  
Fecha de Ingreso: julio-2010
Ubicación: en el ciberdespacio (España)
Mensajes: 150
Antigüedad: 13 años, 8 meses
Puntos: 4
Respuesta: Dudas de principiante en Win Api

prueba con

SetWindowText(label1, texto);

label1 es una etiqueta donde puedes poner un texto que tendras que crear.
  #10 (permalink)  
Antiguo 01/09/2011, 11:47
 
Fecha de Ingreso: abril-2009
Ubicación: En foros del web, normalmente en Web general, HTML y CSS.
Mensajes: 258
Antigüedad: 14 años, 11 meses
Puntos: 3
Respuesta: Dudas de principiante en Win Api

EDITO: Perfecto!, me ha funcionado de esta forma:

Código C++:
Ver original
  1. #include <windows.h>
  2. #include <tchar.h>
  3.  
  4. enum {ID_boton1 = 1000, ID_edit1};
  5.  
  6. /*  Declare Windows procedure  */
  7. LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
  8.  
  9. /*  Make the class name into a global variable  */
  10. char szClassName[ ] = "CodeBlocksWindowsApp";
  11.  
  12.  
  13. HINSTANCE estancia;
  14. HWND boton1;
  15. HWND edit1;
  16. HWND label;
  17.  
  18.  
  19. int WINAPI WinMain (HINSTANCE hThisInstance,
  20.                      HINSTANCE hPrevInstance,
  21.                      LPSTR lpszArgument,
  22.                      int nCmdShow)
  23. {
  24.     HWND hwnd;               /* This is the handle for our window */
  25.     MSG messages;            /* Here messages to the application are saved */
  26.     WNDCLASSEX wincl;        /* Data structure for the windowclass */
  27.  
  28.     estancia = hThisInstance;
  29.  
  30.     /* The Window structure */
  31.     wincl.hInstance = hThisInstance;
  32.     wincl.lpszClassName = szClassName;
  33.     wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
  34.     wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
  35.     wincl.cbSize = sizeof (WNDCLASSEX);
  36.  
  37.     /* Use default icon and mouse-pointer */
  38.     wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  39.     wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
  40.     wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
  41.     wincl.lpszMenuName = NULL;                 /* No menu */
  42.     wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
  43.     wincl.cbWndExtra = 0;                      /* structure or the window instance */
  44.     /* Use Windows's default colour as the background of the window */
  45.     wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
  46.  
  47.     /* Register the window class, and if it fails quit the program */
  48.     if (!RegisterClassEx (&wincl))
  49.         return 0;
  50.  
  51.     /* The class is registered, let's create the program*/
  52.     hwnd = CreateWindowEx (
  53.            0,                   /* Extended possibilites for variation */
  54.            szClassName,         /* Classname */
  55.            "Code::Blocks Template Windows App",       /* Title Text */
  56.            WS_OVERLAPPEDWINDOW, /* default window */
  57.            CW_USEDEFAULT,       /* Windows decides the position */
  58.            CW_USEDEFAULT,       /* where the window ends up on the screen */
  59.            544,                 /* The programs width */
  60.            375,                 /* and height in pixels */
  61.            HWND_DESKTOP,        /* The window is a child-window to desktop */
  62.            NULL,                /* No menu */
  63.            hThisInstance,       /* Program Instance handler */
  64.            NULL                 /* No Window Creation data */
  65.            );
  66.  
  67.     /* Make the window visible on the screen */
  68.     ShowWindow (hwnd, nCmdShow);
  69.  
  70.     /* Run the message loop. It will run until GetMessage() returns 0 */
  71.     while (GetMessage (&messages, NULL, 0, 0))
  72.     {
  73.         /* Translate virtual-key messages into character messages */
  74.         TranslateMessage(&messages);
  75.         /* Send message to WindowProcedure */
  76.         DispatchMessage(&messages);
  77.     }
  78.  
  79.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
  80.     return messages.wParam;
  81. }
  82.  
  83.  
  84.  
  85.  
  86. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  87. {
  88.  
  89.     TCHAR texto [256];
  90.  
  91.     switch (message)
  92.     {
  93.         case WM_CREATE:
  94.         {
  95.  
  96.             label = CreateWindow(_T("static"), 0, WS_CHILD | WS_VISIBLE, 10, 10, 175, 25, hwnd, 0, estancia, 0);
  97.             boton1 = CreateWindow (_T("Button"), _T("Texto"), BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE, 80, 100, 70, 25, hwnd, (HMENU) ID_boton1, estancia, 0);
  98.             edit1 = CreateWindow (_T("Edit"), 0, WS_CHILD | WS_VISIBLE, 160, 100, 300, 20, hwnd, (HMENU) ID_edit1, estancia, 0);
  99.             break;
  100.         }
  101.  
  102.         case WM_COMMAND:
  103.         switch (wParam)
  104.         {
  105.             case ID_boton1:
  106.             GetWindowText(edit1, texto, 255);
  107.             SetWindowText(label, texto);
  108.         }
  109.  
  110.         break;
  111.  
  112.         case WM_DESTROY:
  113.             PostQuitMessage (0);
  114.             break;
  115.         default:
  116.             return DefWindowProc (hwnd, message, wParam, lParam);
  117.     }
  118.  
  119.     return 0;
  120. }

Ahora estoy intentando hacer varias cosas:

-Cambiar la estética del label (color, imagen de fondo, etc.).
-Situar el texto directamente sobre la ventana del programa sin el cuadradito de fondo (estilo TextOut).
-Ir añadiendo textos conforme se le vaya dando al botón, es decir, si escribes "hola" y le das al botón se imprime en el label, si luego escribes "mundo" y le das al botón que se sitúe alado de "hola" quedando "hola mundo", y asi sucesivamente.

Lo ire comentando aqui conforme vaya encontrando la forma de hacer lo que he mencionado por si a alguien le sirve.

Saludos!.
__________________
¿Por qué Anónimo?, porque como está el mundo no podemos considerarnos humanos...

Última edición por Anonimo12; 01/09/2011 a las 13:40

Etiquetas: api, código, dudas, funcion, principiante, programa, struct, win7
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta




La zona horaria es GMT -6. Ahora son las 06:05.