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

 

 


Tema destacado: Únete al Grupo Steam elhacker.NET


  Mostrar Temas
Páginas: [1] 2
1  Comunicaciones / Redes / Servidor de correo en: 5 Diciembre 2013, 14:50 pm
Buenas tardes:

Estoy desarrollando en Java un gestor de correos y necesito conectarme a un servidor de correos para el envío/recepción de los mensajes.

He hecho envíos con gmail y hotmail pero sé que te ponen restricciones en cuanto a la cantidad de mensajes que puedes mandar en un periodo de tiempo antes de que te bloqueen la cuenta. La aplicación es con fines comerciales así que necesito poder mandarlos a miles de usuarios.

Mi primera opción ha sido añadir como destinatarios a todos los receptores, pero gmail permite como máximo 500 y Hotmail 100. La segunda idea ha sido crear un bucle y mandar el mensaje varias veces añadiendo en cada envío a 100 destinatarios, pero como he comentado antes esto funciona solo durante un periodo de tiempo antes de que gmail te bloquee la cuenta.

¿Conocéis algún servidor de correos que ofrezca una API o un modo de comunicación con aplicaciones Java y dé mayor libertad en cuanto al envío masivo de e-mails?

Un saludo.
2  Programación / Programación C/C++ / Gestor de correos con C++ en: 2 Diciembre 2013, 15:44 pm
Buenas tardes:

Un pequeño comercio me ha encargado el desarrollo de una aplicación personalizada para el envío de correos. Mi primera opción de momento es Java, ya que tiene librerías estándar que ofrecen la mayoría de operaciones que voy a necesitar, y con las que he trabajado en otro momento.

Aún así, me atrae la idea de desarrollarlo en C++, pero no encuentro la luz en cuanto a librerías y referencias. Sé que con QT se pueden enviar e-mails de manera muy sencilla, pero necesito otras operaciones:

Descargar y subir lista de contactos de algún servidor (Gmail, hotmail, etc.)
Subir los correos borrador.
Enviar correos con imágenes insertadas en el mensaje (no adjuntas).
Enviar ficheros adjuntos (un pdf o un zip).

¿Alguien conoce alguna librería o API que se acerque?.

Gracias. Un saludo.
3  Foros Generales / Noticias / Cualquier palabra podrá ser usada como dominio de Internet en: 9 Enero 2012, 14:14 pm
Esta semana comienza la expansión de nombres de dominios. En contra de la voluntad de algunas grandes empresas, a partir del jueves 12 de enero cualquier persona o empresa podrá registrar cualquier palabra como extensión de una página web.

En la actualidad hay alrededor de 22 tipos de dominios de primer nivel como .com o .org, además de los códigos de países como .es para España. Las empresas creen que ya es suficiente, y 40 granes corporaciones, como por ejemplo Coca Cola, se han quejado de que con la expansión del dominio se elevan los costes y aumenta el riesgo de fraude y suplantación.

Este podría suponer uno de los mayores cambios en Internet desde su creación hace décadas, y estará coordinado por ICANN (Internet Corporation for Assigned Names and Numbers), que es una organización sin ánimo de lucro que opera a nivel internacional, y es responsable de asignar espacio de direcciones numéricas de protocolo de Internet (IP), así como la administración del sistema de nombres de dominio de primer nivel genéricos (gTLD) y de códigos de países (ccTLD).

El lanzamiento de los llamados "puntos de la marca" es el último gran cambio en las estrictas normas que rigen la nomenclatura de Internet desde el lanzamiento de .com en 1985. El mayor cambio reciente se produjo el año pasado cuando se puso en marcha el .xxx para dar a los sitios web para adultos su propio espacio en Internet. Este dominio cuenta con 250.000 sitios web en nueve meses.

Sin embargo, este nuevo cambio lleva la personalización de las páginas web a un nuevo nivel. De esta forma, muchas marcas o instituciones ven en ello muchas posibilidades, aunque otras ven problemas de suplantación de identidad. Proteger la marca les podría costar millones.

Los solicitantes tienen hasta el 12 de abril para inscribirse, y después tendrá lugar un proceso de evaluación de ocho meses. Los primeros sitios de nivel superior de dominio se espera que sean efectivos para 2013. Mientras tanto, ICANN espera que haya hasta 4.000 aplicaciones.

Fuente: http://www.20minutos.es/noticia/1270649/0/palabras/dominios/internet/
4  Programación / Programación C/C++ / Calculadora básica con interfaz [Win API][Terminada] en: 17 Septiembre 2011, 14:35 pm
Bueno, finalmente he acabado una calculadora muy sencilla con interfaz poniendo en práctica lo que he aprendido de la API de Windows; la cuelgo aqui por si le sirve a alguien de ejemplo (todas las funciones y códigos van comentados).

main.cpp:

Código
  1. #include <windows.h>
  2. #include <tchar.h>
  3. #include <stdio.h>
  4. #include <math.h>
  5.  
  6. //ID´s
  7. enum {ID_LABEL, ID_EDIT, ID_BOTONIGUAL, ID_BOTONRESET, ID_BOTONRESET2, ID_BOTONSUMAR, ID_BOTONRESTAR, ID_BOTONMULTIPLICAR, ID_BOTONDIVIDIR, ID_BOTONPORCENTAJE, ID_BOTONPOTENCIA, ID_BOTONRAIZ, ID_BOTONPI, ID_BOTONCOMA, ID_BOTONSIGNO, ID_BOTONCERO, ID_BOTON1, ID_BOTON2, ID_BOTON3, ID_BOTON4, ID_BOTON5, ID_BOTON6, ID_BOTON7, ID_BOTON8, ID_BOTON9};
  8.  
  9.  
  10. //Prototipos
  11. LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
  12.  
  13. void imprimirEdit (int i);                                                  //Funcion que concatena los numeros al hacer clic en los botones
  14. double calcular (double primer_num, double segundo_num, int operacion);     //Funcion que realiza las operaciones
  15.  
  16. HINSTANCE estancia;
  17. HWND label;
  18. HWND edit;
  19. //Iconos
  20. HICON iconoPotencia;
  21. HICON iconoRaiz;
  22. HICON iconoPi;
  23. //Botones
  24. HWND boton1;
  25. HWND boton2;
  26. HWND boton3;
  27. HWND boton4;
  28. HWND boton5;
  29. HWND boton6;
  30. HWND boton7;
  31. HWND boton8;
  32. HWND boton9;
  33. HWND boton0;
  34. HWND botonComa;
  35. HWND botonSigno;
  36. HWND botonIgual;
  37. HWND botonReset;
  38. HWND botonReset2;
  39. HWND botonSumar;
  40. HWND botonRestar;
  41. HWND botonMultiplicar;
  42. HWND botonDividir;
  43. HWND botonPorcentaje;
  44. HWND botonPotencia;
  45. HWND botonRaiz;
  46. HWND botonPi;
  47.  
  48.  
  49. char szClassName[ ] = "CodeBlocksWindowsApp";
  50.  
  51. int WINAPI WinMain (HINSTANCE hThisInstance,
  52.                      HINSTANCE hPrevInstance,
  53.                      LPSTR lpszArgument,
  54.                      int nCmdShow)
  55. {
  56.     HWND hwnd;               /* This is the handle for our window */
  57.     MSG messages;            /* Here messages to the application are saved */
  58.     WNDCLASSEX wincl;        /* Data structure for the windowclass */
  59.  
  60.     estancia = hThisInstance;
  61.  
  62.     /* The Window structure */
  63.     wincl.hInstance = hThisInstance;
  64.     wincl.lpszClassName = szClassName;
  65.     wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
  66.     wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
  67.     wincl.cbSize = sizeof (WNDCLASSEX);
  68.  
  69.     /* Use default icon and mouse-pointer */
  70.     wincl.hIcon = LoadIcon (estancia, "ICONO");
  71.     wincl.hIconSm = LoadIcon (estancia, "ICONO");
  72.     wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
  73.     wincl.lpszMenuName = NULL;                 /* No menu */
  74.     wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
  75.     wincl.cbWndExtra = 0;                      /* structure or the window instance */
  76.  
  77.     //Cargamos los iconos de los botones
  78.     iconoPotencia = LoadIcon (estancia, "POTENCIA");
  79.     iconoRaiz = LoadIcon (estancia, "RAIZ");
  80.     iconoPi = LoadIcon (estancia, "PI");
  81.  
  82.     //Color de fondo de la aplicacion
  83.     wincl.hbrBackground = (HBRUSH) CreateSolidBrush (RGB(88, 145, 192));
  84.  
  85.     if (!RegisterClassEx (&wincl))
  86.         return 0;
  87.  
  88.     hwnd = CreateWindowEx (
  89.            0,                   /* Extended possibilites for variation */
  90.            szClassName,         /* Classname */
  91.            "Calculadora by Alien-Z",
  92.            WS_OVERLAPPEDWINDOW, /* default window */
  93.            CW_USEDEFAULT,       /* Windows decides the position */
  94.            CW_USEDEFAULT,       /* where the window ends up on the screen */
  95.            300,                 /* The programs width */
  96.            300,                 /* and height in pixels */
  97.            HWND_DESKTOP,        /* The window is a child-window to desktop */
  98.            NULL,                /* No menu */
  99.            hThisInstance,       /* Program Instance handler */
  100.            NULL                 /* No Window Creation data */
  101.            );
  102.  
  103.     /* Make the window visible on the screen */
  104.     ShowWindow (hwnd, nCmdShow);
  105.  
  106.     /* Run the message loop. It will run until GetMessage() returns 0 */
  107.     while (GetMessage (&messages, NULL, 0, 0))
  108.     {
  109.         /* Translate virtual-key messages into character messages */
  110.         TranslateMessage(&messages);
  111.         /* Send message to WindowProcedure */
  112.         DispatchMessage(&messages);
  113.     }
  114.  
  115.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
  116.     return messages.wParam;
  117. }
  118.  
  119.  
  120. /*  This function is called by the Windows function DispatchMessage()  */
  121.  
  122. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  123. {
  124.     PAINTSTRUCT ps;
  125.     HDC hdc;
  126.     TCHAR greeting[] = _T("Alien-Z");
  127.     COLORREF color1 = RGB (192, 192, 192);
  128.  
  129.     //Variables
  130.     char cadenaEditMain [31];
  131.     static int operacion;
  132.     static double primer_num, segundo_num, resultado, signo;
  133.  
  134.  
  135.     switch (message)
  136.     {
  137.         case WM_CREATE:
  138.         {
  139.             //Elementos de la calculadora
  140.             label = CreateWindow ("Static", NULL, BS_CENTER | WS_CHILD | WS_VISIBLE, 20, 20, 250, 25, hwnd, 0, estancia, 0);
  141.             edit = CreateWindowEx (WS_EX_CLIENTEDGE, "edit", 0, ES_RIGHT | ES_NUMBER | WS_BORDER | WS_CHILD | WS_VISIBLE, 20, 50, 250, 25, hwnd, (HMENU)ID_EDIT, estancia, 0);
  142.  
  143.             boton1 = CreateWindow ("Button", "1", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 90, 40, 25, hwnd, (HMENU) ID_BOTON1, estancia, 0);
  144.             boton2 = CreateWindow ("Button", "2", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 90, 40, 25, hwnd, (HMENU) ID_BOTON2, estancia, 0);
  145.             boton3 = CreateWindow ("Button", "3", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 90, 40, 25, hwnd, (HMENU) ID_BOTON3, estancia, 0);
  146.             boton4 = CreateWindow ("Button", "4", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 120, 40, 25, hwnd, (HMENU) ID_BOTON4, estancia, 0);
  147.             boton5 = CreateWindow ("Button", "5", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 120, 40, 25, hwnd, (HMENU) ID_BOTON5, estancia, 0);
  148.             boton6 = CreateWindow ("Button", "6", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 120, 40, 25, hwnd, (HMENU) ID_BOTON6, estancia, 0);
  149.             boton7 = CreateWindow ("Button", "7", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 150, 40, 25, hwnd, (HMENU) ID_BOTON7, estancia, 0);
  150.             boton8 = CreateWindow ("Button", "8", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 150, 40, 25, hwnd, (HMENU) ID_BOTON8, estancia, 0);
  151.             boton9 = CreateWindow ("Button", "9", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 150, 40, 25, hwnd, (HMENU) ID_BOTON9, estancia, 0);
  152.             boton0 = CreateWindow ("Button", "0", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 180, 40, 25, hwnd, (HMENU) ID_BOTONCERO, estancia, 0);
  153.             botonComa = CreateWindow ("Button", ",", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 180, 40, 25, hwnd, (HMENU) ID_BOTONCOMA, estancia, 0);
  154.             botonSigno = CreateWindow ("Button", "+/-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 180, 40, 25, hwnd, (HMENU) ID_BOTONSIGNO, estancia, 0);
  155.             botonSumar = CreateWindow ("Button", "+", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 90, 40, 25, hwnd, (HMENU) ID_BOTONSUMAR, estancia, 0);
  156.             botonRestar = CreateWindow ("Button", "-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 120, 40, 25, hwnd, (HMENU) ID_BOTONRESTAR, estancia, 0);
  157.             botonMultiplicar = CreateWindow ("Button", "*", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 150, 40, 25, hwnd, (HMENU) ID_BOTONMULTIPLICAR, estancia, 0);
  158.             botonDividir = CreateWindow ("Button", "/", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 180, 40, 25, hwnd, (HMENU) ID_BOTONDIVIDIR, estancia, 0);
  159.             botonPorcentaje = CreateWindow ("Button", "%", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 90, 40, 25, hwnd, (HMENU) ID_BOTONPORCENTAJE, estancia, 0);
  160.             botonPotencia = CreateWindow ("Button", "x ²", BS_ICON | BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 120, 40, 25, hwnd, (HMENU) ID_BOTONPOTENCIA, estancia, 0);
  161.             botonRaiz = CreateWindow ("Button", "Raiz", BS_ICON | BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 150, 40, 25, hwnd, (HMENU) ID_BOTONRAIZ, estancia, 0);
  162.             botonPi = CreateWindow ("Button", "Pi", BS_ICON | BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 180, 40, 25, hwnd, (HMENU) ID_BOTONPI, estancia, 0);
  163.             botonIgual = CreateWindow ("Button", "=", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 220, 40, 25, hwnd, (HMENU) ID_BOTONIGUAL, estancia, 0);
  164.             botonReset = CreateWindow ("Button", "C", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 220, 40, 25, hwnd, (HMENU) ID_BOTONRESET, estancia, 0);
  165.             botonReset2 = CreateWindow ("Button", "CE", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 220, 40, 25, hwnd, (HMENU) ID_BOTONRESET2, estancia, 0);
  166.  
  167.             //Cambiar fuente de letra del lablel
  168.             static HFONT hFont = CreateFont (16, 0, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, VARIABLE_PITCH | FF_SWISS, "Comic Sans MS");
  169.             SendMessage(label, WM_SETFONT, (WPARAM) hFont, true);
  170.  
  171.             //Enviar iconos a los botones
  172.             SendMessage(botonPotencia, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoPotencia);
  173.             SendMessage(botonRaiz, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoRaiz);
  174.             SendMessage(botonPi, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoPi);
  175.  
  176.             //Bloquear el boton "maximizar"
  177.             DWORD dwStyle = (DWORD)GetWindowLong(hwnd, GWL_STYLE);
  178.             dwStyle &= ~WS_MAXIMIZEBOX;
  179.             SetWindowLong(hwnd, GWL_STYLE, (DWORD)dwStyle);
  180.             RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW);
  181.  
  182.             //Bloquear la opcion de cambiarle el tamaño a la ventana
  183.             dwStyle &= ~WS_SIZEBOX;
  184.             SetWindowLong(hwnd, GWL_STYLE, (DWORD)dwStyle);
  185.             RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW);
  186.         }
  187.  
  188.         case WM_COMMAND:
  189.         {
  190.             switch (wParam)
  191.             {
  192.                 case ID_BOTON1:                  //Al presionar el boton 1 se llama a la funcion "imprimirEdit" y se le envia el valor "1" que es lo que queremos que se concatene a lo que ya haya en el edit
  193.                 {
  194.                     imprimirEdit (1);
  195.                     break;
  196.                 }
  197.                 case ID_BOTON2:
  198.                 {
  199.                     imprimirEdit (2);
  200.                     break;
  201.                 }
  202.                 case ID_BOTON3:
  203.                 {
  204.                     imprimirEdit (3);
  205.                     break;
  206.                 }
  207.                 case ID_BOTON4:
  208.                 {
  209.                     imprimirEdit(4);
  210.                     break;
  211.                 }
  212.                 case ID_BOTON5:
  213.                 {
  214.                     imprimirEdit(5);
  215.                     break;
  216.                 }
  217.                 case ID_BOTON6:
  218.                 {
  219.                     imprimirEdit(6);
  220.                     break;
  221.                 }
  222.                 case ID_BOTON7:
  223.                 {
  224.                     imprimirEdit(7);
  225.                     break;
  226.                 }
  227.                 case ID_BOTON8:
  228.                 {
  229.                     imprimirEdit(8);
  230.                     break;
  231.                 }
  232.                 case ID_BOTON9:
  233.                 {
  234.                     imprimirEdit(9);
  235.                     break;
  236.                 }
  237.                 case ID_BOTONCERO:
  238.                 {
  239.                     imprimirEdit(0);
  240.                     break;
  241.                 }
  242.                 case ID_BOTONCOMA:
  243.                 {
  244.                     GetWindowText (edit, cadenaEditMain, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEditMain"
  245.                     if (strstr (cadenaEditMain, ".") == NULL)        //Analizamos "cadenaEditMain" y si no posee una coma se ejecuta lo que hay dentro del if (en caso de que ya tenga una coma no hace nada)
  246.                     {
  247.                         strcat (cadenaEditMain, ".");                //Se le añade una coma a lo que hay en "CadenaEditMain"
  248.                         SetWindowText (edit, cadenaEditMain);        //Se imprime el nuevo numero en el edit
  249.                     }
  250.                     break;
  251.                 }
  252.                 case ID_BOTONSIGNO:                                  //Boton que cambia el signo del numero
  253.                 {
  254.                     GetWindowText (edit, cadenaEditMain, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEditMain"
  255.                     signo = atof (cadenaEditMain);                   //Transforma la cadena obtenida en un double y lo guarda en "signo"
  256.                     signo *= -1;                                     //Se multiplica el numero por -1 (si es positivo se quedara negativo, y viceversa)
  257.                     sprintf (cadenaEditMain, "%f", signo);           //Se transforma el double obtenido en una cadena y se guarda en "cadenaEditMain"
  258.                     SetWindowText (edit, cadenaEditMain);            //Se imprime el nuevo numero en el edit
  259.                     break;
  260.                 }
  261.                 case ID_BOTONSUMAR:
  262.                 {
  263.                     operacion = 1;                                    //Cambia el valor de "operacion" para indicar que se va a sumar
  264.                     GetWindowText (edit, cadenaEditMain, 30);         //Obtiene el numero ingresado en el edit
  265.                     primer_num = atof (cadenaEditMain);               //Transforma la cadena obtenida en un double y lo guarda en "primer_num"
  266.                     SetWindowText (edit, "");                         //Limpia el edit
  267.                     break;
  268.                 }
  269.                 case ID_BOTONRESTAR:
  270.                 {
  271.                     operacion = 2;                                    //Cambia el valor de "operacion" para indicar que se va a restar
  272.                     GetWindowText (edit, cadenaEditMain, 30);
  273.                     primer_num = atof (cadenaEditMain);
  274.                     SetWindowText (edit, "");
  275.                     break;
  276.                 }
  277.                 case ID_BOTONMULTIPLICAR:
  278.                 {
  279.                     operacion = 3;                                    //Cambia el valor de "operacion" para indicar que se va a multiplicar
  280.                     GetWindowText (edit, cadenaEditMain, 30);
  281.                     primer_num = atof (cadenaEditMain);
  282.                     SetWindowText (edit, "");
  283.                     break;
  284.                 }
  285.                 case ID_BOTONDIVIDIR:
  286.                 {
  287.                     operacion = 4;                                    //Cambia el valor de "operacion" para indicar que se va a dividir
  288.                     GetWindowText (edit, cadenaEditMain, 30);
  289.                     primer_num = atof (cadenaEditMain);
  290.                     SetWindowText (edit, "");
  291.                     break;
  292.                 }
  293.                 case ID_BOTONPORCENTAJE:
  294.                 {
  295.                     operacion = 5;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar el porcentaje
  296.                     GetWindowText (edit, cadenaEditMain, 30);
  297.                     primer_num = atof (cadenaEditMain);
  298.                     SetWindowText (edit, "");
  299.                     break;
  300.                 }
  301.                 case ID_BOTONPOTENCIA:
  302.                 {
  303.                     operacion = 6;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar una potencia
  304.                     GetWindowText (edit, cadenaEditMain, 30);
  305.                     primer_num = atof (cadenaEditMain);
  306.                     SetWindowText (edit, "");
  307.                     SetWindowText (label, "¿A cuánto está elevado el número?");
  308.                     break;
  309.                 }
  310.                 case ID_BOTONRAIZ:
  311.                 {
  312.                     operacion = 7;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar la raiz
  313.                     GetWindowText (edit, cadenaEditMain, 30);
  314.                     primer_num = atof (cadenaEditMain);
  315.                     SetWindowText (edit, "");
  316.                     SetWindowText (label, "¿A cuánto está elevada la raiz?");
  317.                     break;
  318.                 }
  319.                 case ID_BOTONPI:
  320.                 {
  321.                     SetWindowText (edit, "3.141592653589793");        //Imprime en el edit el valor de PI
  322.                     break;
  323.                 }
  324.                 case ID_BOTONIGUAL:
  325.                 {
  326.                     GetWindowText (edit, cadenaEditMain, 30);         //Obtiene el numero ingresado en el edit
  327.                     segundo_num = atof (cadenaEditMain);              //Transforma la cadena obtenida en un double y lo guarda en "segundo_num"
  328.                     resultado = calcular (primer_num, segundo_num, operacion); //El resultado se obtiene apartir de la funcion "calcular", a esta funcion se le envian las variables "primer_num", "segundo_num" y "operacion"
  329.                     sprintf (cadenaEditMain, "%f", resultado);        //Se transforma el double obtenido en una cadena y se guarda en "cadenaEditMain"
  330.                     SetWindowText (edit, cadenaEditMain);             //Se imprime en el edit la cadena donde se encuentra el resultado
  331.                     //Reseteamos las variables
  332.                     primer_num = 0;
  333.                     segundo_num = 0;
  334.                     operacion = 0;
  335.                     break;
  336.                 }
  337.                 case ID_BOTONRESET:                                  //Boton que limpia las variables y datos para calcular de nuevo
  338.                 {
  339.                     primer_num = 0;
  340.                     segundo_num = 0;
  341.                     operacion = 0;
  342.                     SetWindowText (edit, "");
  343.                     SetWindowText (label, "");
  344.                     break;
  345.                 }
  346.                 case ID_BOTONRESET2:                                 //Boton que borra solo el ultimo numero introducido
  347.                 {
  348.                     segundo_num = 0;
  349.                     SetWindowText (edit, "");
  350.                     break;
  351.                 }
  352.  
  353.                 break;
  354.             }
  355.             break;
  356.         }
  357.  
  358.         case WM_PAINT:
  359.         {
  360.             hdc = BeginPaint(hwnd, &ps);
  361.             SetBkColor (hdc, RGB(88, 145, 192));
  362.             SetTextColor (hdc, color1);
  363.             TextOut(hdc, 230, 240, greeting, _tcslen(greeting));
  364.             EndPaint (hwnd, &ps);
  365.             break;
  366.         }
  367.  
  368.         case WM_DESTROY:
  369.             PostQuitMessage (0);
  370.             break;
  371.         default:
  372.             return DefWindowProc (hwnd, message, wParam, lParam);
  373.     }
  374.  
  375.     return 0;
  376. }
  377.  
  378. void imprimirEdit (int i)                        //Funcion que concatena los numeros al hacer clic en los botones
  379. {
  380.     char cadenaEdit [31];                        //Variable donde se guardara lo que hay en el edit (no es la misma variable que cadenaEditMain)
  381.     char numero [3];                             //Variable donde se guardara el numero de la tecla presionada
  382.     sprintf (numero, "%i", i);                   //Se transforma el numero (i) del tipo entero a una cadena
  383.  
  384.     GetWindowText (edit, cadenaEdit, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEdit"
  385.     strcat (cadenaEdit, numero);                 //Se une lo que hay en "CadenaEdit" y lo que hay en "numero" (es decir, se une lo que habia en el edit y el numero de la tecla presionada) y se queda guardada la nueva cifra en "cadenaEdit"
  386.     SetWindowText (edit, cadenaEdit);            //Se imprime el nuevo numero en el edit
  387. }
  388.  
  389. double calcular (double primer_num, double segundo_num, int operacion)   //Funcion que realiza las operaciones
  390. {
  391.     double resultado;                                                    //Variable donde se guardara el resultado (sera lo que se retorne)
  392.  
  393.     switch (operacion)                                                   //Ver lo que hay en la variable "operacion"
  394.     {
  395.         case 1:                                                          //En caso de que sea "1" se suma el primer numero al segundo
  396.         {
  397.             resultado = primer_num + segundo_num;
  398.             break;
  399.         }
  400.         case 2:                                                          //En caso de que sea "2" se le resta el segundo numero al primero
  401.         {
  402.             resultado = primer_num - segundo_num;
  403.             break;
  404.         }
  405.         case 3:                                                          //En caso de que sea "3" se multiplica el primer numero por el segundo
  406.         {
  407.             resultado = primer_num * segundo_num;
  408.             break;
  409.         }
  410.         case 4:                                                          //En caso de que sea "4" se divide el primer numero entre el segundo
  411.         {
  412.             resultado = primer_num / segundo_num;
  413.             break;
  414.         }
  415.         case 5:                                                          //En caso de que sea "5" se haya el tanto por cierto (primer numero) del segundo numero
  416.         {
  417.             resultado = (primer_num * segundo_num) / 100;
  418.             break;
  419.         }
  420.         case 6:                                                          //En caso de que sea "6" se obtiene la potencia del primer numero elevado al segundo
  421.         {
  422.             resultado = pow (primer_num, segundo_num);
  423.             break;
  424.         }
  425.         case 7:                                                          //En caso de que sea "7" se obtiene la raiz del primer numero (el segundo define si dicha raiz es cubica, cuadrada...)
  426.         {
  427.             resultado = pow (primer_num, 1/segundo_num);
  428.             break;
  429.         }
  430.         default:                                                         //Si no se realiza ninguna operacion se imprime en el label un mensaje, con esto sabriamos si ha habido algun error
  431.         {
  432.             SetWindowText (label, "No se ha realizado ninguna operacion.");
  433.             break;
  434.         }
  435.     }
  436.  
  437.     SetWindowText (label, "");                                           //Limpiamos el label
  438.     return resultado;                                                    //Devuelve el resultado
  439. }
  440.  

recursos.rc:

Código
  1. ICONO ICON "icono.ico"
  2. POTENCIA ICON "potencia.ico"
  3. RAIZ ICON "raiz.ico"
  4. PI ICON "pi.ico"
  5.  

Iconos (no he encontrado ningún servidor para subir .ico que acepte fondo transparente asi que he optado por MU): http://www.megaupload.com/?d=ZMPELBPE

Notas:
-Los iconos deben estar dentro de la carpeta del proyecto.
-Aun no he solucionado un pequeño inconveniente y es que solo opera con los dos últimos números introducidos, por ejemplo, si presionas 2+2*5 el resultado será 10 porque la última operación es 2*5, pero si después de cada cálculo presionas el botón igual hará todas las operaciones que le mandes sin problema.
-La función del botón "porcentaje" suele variar según la calculadora, en este caso hayas el X por ciento de Y, por ejemplo, 50 % 10 = 5 (el 50 por ciento de 10 es 5).


Espero que le sirva a alguien. Saludos.
5  Programación / Programación C/C++ / Iconos en botones (Win API) en: 16 Septiembre 2011, 21:32 pm
Buenas:

He llegado a un punto en el cual, para mejorar la interfaz de un programa, necesito ponerle iconos a los botones, fondos a los edit o static, etc. He encontrado por internet un par de cosas como la función CreateIcon (que me ha dado 500 errores) y esta otra forma:

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

Archivo de recursos:

Código
  1. RAIZ ICON "raiz.ico"

No me da ningún error y el programa se compila y ejecuta correctamente pero no imprime el icono.
6  Informática / Hardware / Consejo para comprar portátil en: 12 Septiembre 2011, 22:15 pm
Buenas:

Debido a los estudios tengo que comprarme un nuevo portátil asi que pregunto aqui para que me echéis una mano. Fui a la tienda APP de mi ciudad y me recomendaron dos ordenadores:

1- http://www.appinformatica.com/portatiles-pbell.-ts44-hr-232sp-15.6-i32310-4g-500g-nvidia512.php

Datos básicos: 4GB RAM | 500GB disco duro | Procesador i3-2310M | Tarjeta gráfica Nvidia Geforce GT 520M con 512 MB reales.

Precio: 470 € (me parece que está bastante bien de coste con todo lo que lleva).

2- http://www.appinformatica.com/portatiles-portatil-acer-tm5742-i3-350-6gb-640gb-w7hp.php

Datos básicos: 6GB RAM | 640GB disco duro | Procesador i3-350m | Tarjeta gráfica no lo pone.

Precio: 419 €

A ver si alguien les puede echar un vistazo para decirme por dónde tiro, el encargado de la tienda me aconsejó especialmente el primero pero luego mirando por internet me he dado cuenta de que hay piezas bastante más potentes.

Podéis ver más portátiles de la misma tienda desde aqui: http://www.appinformatica.com/portatiles.htm

Una pregunta que siempre surje a la hora de comprar un PC: ¿para qué lo voy a usar?, como ya he comenatado es para la universidad (ingeniería informática), asi que en ello entra la programación, gráficos (por eso necesito una tarjeta gráfica que no se quede obsoleta a los 2 años) y alguna cosa más.

No tiene por qué ser uno de esos 2 PC´s, si tienen alguna sugerencia mejor de esa página me gustaría oírla, o piezas específicas que me recomendéis, sin embargo también me gustaría saber qué opináis sobre los dos que he mencionado; el problema es que yo no estoy muy metido en el tema del hardware.

Gracias por adelantado. Saludos.
7  Programación / Programación C/C++ / Calculadora en Win API no imprime el resultado en: 11 Septiembre 2011, 18:33 pm
Buenas, en mis avances con la API de windows he conseguido hacer una calculadora muy básica con interfaz, sin embargo no me imprime el resultado, asi que después de varios días dándole vueltas y de habérselo planteado a un par de conocidos que no han encontrado el fallo lo posteo aqui:

Código
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. //ID´s
  6. enum {ID_LABEL, ID_EDIT, ID_BOTONIGUAL, ID_BOTONSUMAR, ID_BOTONRESTAR, ID_BOTONMULTIPLICAR, ID_BOTONDIVIDIR, ID_BOTONCOMA, ID_BOTONSIGNO, ID_BOTONCERO, ID_BOTON1, ID_BOTON2, ID_BOTON3, ID_BOTON4, ID_BOTON5, ID_BOTON6, ID_BOTON7, ID_BOTON8, ID_BOTON9};
  7.  
  8.  
  9. //Prototipos
  10. LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
  11.  
  12. void imprimirEdit (int i);                                                  //Funcion que concatena los numeros al hacer clic en los botones
  13. double calcular (double primer_num, double segundo_num, int operacion);     //Funcion que realiza las operaciones
  14.  
  15. HINSTANCE estancia;
  16. HWND label;
  17. HWND edit;
  18. //Botones->Numeros
  19. HWND boton1;
  20. HWND boton2;
  21. HWND boton3;
  22. HWND boton4;
  23. HWND boton5;
  24. HWND boton6;
  25. HWND boton7;
  26. HWND boton8;
  27. HWND boton9;
  28. HWND boton0;
  29. HWND botonComa;
  30. HWND botonSigno;
  31. //Botones->Operadores
  32. HWND botonIgual;
  33. HWND botonSumar;
  34. HWND botonRestar;
  35. HWND botonMultiplicar;
  36. HWND botonDividir;
  37.  
  38.  
  39.  
  40. /*  Make the class name into a global variable  */
  41. char szClassName[ ] = "CodeBlocksWindowsApp";
  42.  
  43. int WINAPI WinMain (HINSTANCE hThisInstance,
  44.                      HINSTANCE hPrevInstance,
  45.                      LPSTR lpszArgument,
  46.                      int nCmdShow)
  47. {
  48.     HWND hwnd;               /* This is the handle for our window */
  49.     MSG messages;            /* Here messages to the application are saved */
  50.     WNDCLASSEX wincl;        /* Data structure for the windowclass */
  51.  
  52.     estancia = hThisInstance;
  53.  
  54.     /* The Window structure */
  55.     wincl.hInstance = hThisInstance;
  56.     wincl.lpszClassName = szClassName;
  57.     wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
  58.     wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
  59.     wincl.cbSize = sizeof (WNDCLASSEX);
  60.  
  61.     /* Use default icon and mouse-pointer */
  62.     wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  63.     wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
  64.     wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
  65.     wincl.lpszMenuName = NULL;                 /* No menu */
  66.     wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
  67.     wincl.cbWndExtra = 0;                      /* structure or the window instance */
  68.     /* Use Windows's default colour as the background of the window */
  69.     wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
  70.  
  71.     /* Register the window class, and if it fails quit the program */
  72.     if (!RegisterClassEx (&wincl))
  73.         return 0;
  74.  
  75.     /* The class is registered, let's create the program*/
  76.     hwnd = CreateWindowEx (
  77.            0,                   /* Extended possibilites for variation */
  78.            szClassName,         /* Classname */
  79.            "Calculadora",       /* Title Text */
  80.            WS_OVERLAPPEDWINDOW, /* default window */
  81.            CW_USEDEFAULT,       /* Windows decides the position */
  82.            CW_USEDEFAULT,       /* where the window ends up on the screen */
  83.            544,                 /* The programs width */
  84.            375,                 /* and height in pixels */
  85.            HWND_DESKTOP,        /* The window is a child-window to desktop */
  86.            NULL,                /* No menu */
  87.            hThisInstance,       /* Program Instance handler */
  88.            NULL                 /* No Window Creation data */
  89.            );
  90.  
  91.     /* Make the window visible on the screen */
  92.     ShowWindow (hwnd, nCmdShow);
  93.  
  94.     /* Run the message loop. It will run until GetMessage() returns 0 */
  95.     while (GetMessage (&messages, NULL, 0, 0))
  96.     {
  97.         /* Translate virtual-key messages into character messages */
  98.         TranslateMessage(&messages);
  99.         /* Send message to WindowProcedure */
  100.         DispatchMessage(&messages);
  101.     }
  102.  
  103.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
  104.     return messages.wParam;
  105. }
  106.  
  107.  
  108. /*  This function is called by the Windows function DispatchMessage()  */
  109.  
  110. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  111. {
  112.     //Variables
  113.     char cadenaEditMain [35];
  114.     static int operacion;
  115.     static double primer_num, segundo_num, resultado;
  116.  
  117.     PAINTSTRUCT ps;
  118.     HDC hdc;
  119.  
  120.  
  121.     switch (message)
  122.     {
  123.         case WM_CREATE:
  124.         {
  125.             label = CreateWindow ("Static","Texto", WS_CHILD | WS_VISIBLE, 20, 20, 175, 25, hwnd, 0, estancia, 0);
  126.             edit = CreateWindowEx (WS_EX_CLIENTEDGE, "edit", 0, ES_RIGHT | ES_NUMBER | WS_BORDER | WS_CHILD | WS_VISIBLE, 20, 50, 175, 25, hwnd, (HMENU)ID_EDIT, estancia, 0);
  127.  
  128.             boton1 = CreateWindow ("Button", "1", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 90, 40, 25, hwnd, (HMENU) ID_BOTON1, estancia, 0);
  129.             boton2 = CreateWindow ("Button", "2", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 90, 40, 25, hwnd, (HMENU) ID_BOTON2, estancia, 0);
  130.             boton3 = CreateWindow ("Button", "3", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 90, 40, 25, hwnd, (HMENU) ID_BOTON3, estancia, 0);
  131.             boton4 = CreateWindow ("Button", "4", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 120, 40, 25, hwnd, (HMENU) ID_BOTON4, estancia, 0);
  132.             boton5 = CreateWindow ("Button", "5", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 120, 40, 25, hwnd, (HMENU) ID_BOTON5, estancia, 0);
  133.             boton6 = CreateWindow ("Button", "6", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 120, 40, 25, hwnd, (HMENU) ID_BOTON6, estancia, 0);
  134.             boton7 = CreateWindow ("Button", "7", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 150, 40, 25, hwnd, (HMENU) ID_BOTON7, estancia, 0);
  135.             boton8 = CreateWindow ("Button", "8", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 150, 40, 25, hwnd, (HMENU) ID_BOTON8, estancia, 0);
  136.             boton9 = CreateWindow ("Button", "9", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 150, 40, 25, hwnd, (HMENU) ID_BOTON9, estancia, 0);
  137.             boton0 = CreateWindow ("Button", "0", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 180, 40, 25, hwnd, (HMENU) ID_BOTONCERO, estancia, 0);
  138.             botonComa = CreateWindow ("Button", ",", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 180, 40, 25, hwnd, (HMENU) ID_BOTONCOMA, estancia, 0);
  139.             botonSigno = CreateWindow ("Button", "+/-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 180, 40, 25, hwnd, (HMENU) ID_BOTONSIGNO, estancia, 0);
  140.             botonSumar = CreateWindow ("Button", "+", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 90, 40, 25, hwnd, (HMENU) ID_BOTONSUMAR, estancia, 0);
  141.             botonRestar = CreateWindow ("Button", "-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 120, 40, 25, hwnd, (HMENU) ID_BOTONRESTAR, estancia, 0);
  142.             botonMultiplicar = CreateWindow ("Button", "*", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 150, 40, 25, hwnd, (HMENU) ID_BOTONMULTIPLICAR, estancia, 0);
  143.             botonDividir = CreateWindow ("Button", "/", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 180, 40, 25, hwnd, (HMENU) ID_BOTONDIVIDIR, estancia, 0);
  144.             botonIgual = CreateWindow ("Button", "=", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 220, 40, 25, hwnd, (HMENU) ID_BOTONIGUAL, estancia, 0);
  145.         }
  146.  
  147.         case WM_PAINT:
  148.         {
  149.             hdc = BeginPaint(hwnd, &ps);
  150. 			EndPaint(hwnd, &ps);
  151. 			return 0;
  152.         }
  153.  
  154.         case WM_COMMAND:
  155.         {
  156.             switch (wParam)
  157.             {
  158.                 case ID_BOTON1:                  //Al presionar el boton 1 se llama a la funcion "imprimirEdit" y se le envia el valor "1" que es lo que queremos que se concatene a lo que ya haya en el edit
  159.                 {
  160.                     imprimirEdit (1);
  161.                     break;
  162.                 }
  163.                 case ID_BOTON2:
  164.                 {
  165.                     imprimirEdit (2);
  166.                     break;
  167.                 }
  168.                 case ID_BOTON3:
  169.                 {
  170.                     imprimirEdit (3);
  171.                     break;
  172.                 }
  173.                 case ID_BOTON4:
  174.                 {
  175.                     imprimirEdit(4);
  176.                     break;
  177.                 }
  178.                 case ID_BOTON5:
  179.                 {
  180.                     imprimirEdit(5);
  181.                     break;
  182.                 }
  183.                 case ID_BOTON6:
  184.                 {
  185.                     imprimirEdit(6);
  186.                     break;
  187.                 }
  188.                 case ID_BOTON7:
  189.                 {
  190.                     imprimirEdit(7);
  191.                     break;
  192.                 }
  193.                 case ID_BOTON8:
  194.                 {
  195.                     imprimirEdit(8);
  196.                     break;
  197.                 }
  198.                 case ID_BOTON9:
  199.                 {
  200.                     imprimirEdit(9);
  201.                     break;
  202.                 }
  203.                 case ID_BOTONCERO:
  204.                 {
  205.                     imprimirEdit(0);
  206.                     break;
  207.                 }
  208.                 case ID_BOTONCOMA:
  209.                 {
  210.                     break;
  211.                 }
  212.                 case ID_BOTONSUMAR:
  213.                 {
  214.                     operacion = 1;                                    //Cambia el valor de "operacion" para indicar que se va a sumar
  215.                     GetWindowText (edit, cadenaEditMain, 34);         //Obtiene el numero ingresado en el edit
  216.                     primer_num = atof (cadenaEditMain);               //Transforma la cadena obtenida en un double y lo guarda en "primer_num"
  217.                     SetWindowText (edit, "");                         //Limpia el edit
  218.                     break;
  219.                 }
  220.                 case ID_BOTONRESTAR:
  221.                 {
  222.                     operacion = 2;                                    //Cambia el valor de "operacion" para indicar que se va a restar
  223.                     GetWindowText (edit, cadenaEditMain, 34);
  224.                     primer_num = atof (cadenaEditMain);
  225.                     SetWindowText (edit, "");
  226.                     break;
  227.                 }
  228.                 case ID_BOTONMULTIPLICAR:
  229.                 {
  230.                     operacion = 3;                                    //Cambia el valor de "operacion" para indicar que se va a multiplicar
  231.                     GetWindowText (edit, cadenaEditMain, 34);
  232.                     primer_num = atof (cadenaEditMain);
  233.                     SetWindowText (edit, "");
  234.                     break;
  235.                 }
  236.                 case ID_BOTONDIVIDIR:
  237.                 {
  238.                     operacion = 4;                                    //Cambia el valor de "operacion" para indicar que se va a dividir
  239.                     GetWindowText (edit, cadenaEditMain, 34);
  240.                     primer_num = atof (cadenaEditMain);
  241.                     SetWindowText (edit, "");
  242.                     break;
  243.                 }
  244.                 case ID_BOTONIGUAL:
  245.                 {
  246.                     GetWindowText (edit, cadenaEditMain, 34);         //Obtiene el numero ingresado en el edit
  247.                     segundo_num = atof (cadenaEditMain);              //Transforma la cadena obtenida en un double y lo guarda en "segundo_num"
  248.                     resultado = calcular (primer_num, segundo_num, operacion); //El resultado se obtiene apartir de la funcion "calcular", a esta funcion se le envian las variables "primer_num", "segundo_num" y "operacion"
  249.                     sprintf (cadenaEditMain, "%f", resultado);        //Se transforma el double obtenido en una cadena y se guarda en "cadenaEditMain"
  250.                     SetWindowText (edit, cadenaEditMain);             //Se imprime en el edit la cadena donde se encuentra el resultado
  251.                     break;
  252.                 }
  253.  
  254.                 break;
  255.             }
  256.             break;
  257.         }
  258.  
  259.         case WM_DESTROY:
  260.             PostQuitMessage (0);
  261.             break;
  262.         default:
  263.             return DefWindowProc (hwnd, message, wParam, lParam);
  264.     }
  265.  
  266.     return 0;
  267. }
  268.  
  269. void imprimirEdit (int i)                        //Funcion que concatena los numeros al hacer clic en los botones
  270. {
  271.     char cadenaEdit [35];                        //Variable donde se guardara lo que hay en el edit (no es la misma variable que cadenaEditMain)
  272.     char numero [2];                             //Variable donde se guardara el numero de la tecla presionada
  273.     sprintf (numero, "%i", i);                   //Se transforma el numero (i) del tipo entero a una cadena
  274.  
  275.     GetWindowText (edit, cadenaEdit, 34);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEdit"
  276.     strcat (cadenaEdit, numero);                 //Se une lo que hay en "CadenaEdit" y lo que hay en "numero" (es decir, se une lo que habia en el edit y el numero de la tecla presionada) y se queda guardada la nueva cifra en "cadenaEdit"
  277.     SetWindowText (edit, cadenaEdit);            //Se imprime el nuevo numero en el edit
  278. }
  279.  
  280. double calcular (double primer_num, double segundo_num, int operacion)   //Funcion que realiza las operaciones
  281. {
  282.     double resultado;                                                    //Variable donde se guardara el resultado (sera lo que se retorne)
  283.  
  284.     switch (operacion)                                                   //Ver lo que hay en la variable "operacion"
  285.     {
  286.         case 1:                                                          //En caso de que sea "1" se suma el primer numero al segundo
  287.         {
  288.             resultado = primer_num + segundo_num;
  289.             break;
  290.         }
  291.         case 2:                                                          //En caso de que sea "2" se resta el primer numero al segundo
  292.         {
  293.             resultado = primer_num - segundo_num;
  294.             break;
  295.         }
  296.         case 3:                                                          //En caso de que sea "3" se multiplica el primer numero por el segundo
  297.         {
  298.             resultado = primer_num * segundo_num;
  299.             break;
  300.         }
  301.         case 4:                                                          //En caso de que sea "4" se divide el primer numero entre el segundo
  302.         {
  303.             resultado = primer_num / segundo_num;
  304.             break;
  305.         }
  306.         default:                                                         //Si no se realiza ninguna operacion se imprime en el edit un mensaje, con esto sabriamos si ha habido algun error
  307.         {
  308.             SetWindowText (edit, "No se ha realizado ninguna operacion.");
  309.             break;
  310.         }
  311.     }
  312.  
  313.     return resultado;                                                    //Devuelve el resultado
  314. }
  315.  

El fallo está en que al darle al signo igual, en vez de imprimir el resultado, manda el segundo número introducido. Todas las funciones y procesos van comentados.

Gracias por adelantado, saludos.

EDITO: El code está corregido, le faltan cosas como borrar números, limpiar el edit o cambiar de signo, pero lo que lleva por ahora funciona bien.
8  Comunicaciones / Redes / No abren los puertos del router en: 4 Septiembre 2011, 19:06 pm
Buenas:

A ver si me podéis ayudar en un pequeño problemilla, y es que he intentado abrir los puertos de 2 routers diferentes, uno ZyXEL ( he seguido esta guía: http://www.adslzone.net/tutorial-20.2.html ) y otro Netgear. La cosa es que después de seguir todo el procedimiento y de darle a "Save" y a "Apply" el puerto sigue cerrado.

Si alguien sabe cuál puede ser la razón de esto le agradecería que me lo comentara. Saludos.
9  Programación / Programación C/C++ / Crear eventos en botones [Win API] en: 28 Agosto 2011, 22:30 pm
Buenas:

Siguiendo el consejo de тαптяαпсє me he puesto a explorar Win API y he conseguido crear menus/sub-menus, botones y edit aparte de utilizar algunas funciones para toquetear archivos y leer datos básicos del disco duro (me pudo la curiosidad y pasé de la interfaz a otras cosas  :xD).

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

Código
  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):

Citar
#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):

Citar
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?.

Gracias por adelantado. Saludos.
10  Programación / Programación C/C++ / Por dónde sigo... en: 24 Agosto 2011, 20:27 pm
Buenas:

Después de un tiempo explorando la programación en C++ he acabado varios libros/tutoriales, sin embargo ahora mismo estoy atascado.

En principio os comento que me he visto por completo los video-tutoriales de Jesus Conde (os lo dejo para que veais el temario): http://foro.elhacker.net/programacion_cc/video_tutorial_programacion_c-t249577.0.html

Luego estuve revisando "C con clase" para practicar, resolver dudas y completar cosas que no venían en los video-tutoriales: http://c.conclase.net/curso/index.php

Asi que después de 2 dias buscando por internet guías y libros para seguir avanzando no he encontrado nada nuevo. De primeras destaco que no he dado nada relacionado con internet, es decir, programar aplicaciones que conectan a la red. Tampoco he visto mucho sobre archivos (solo un poco por encima: crear archivos, guardarlos, cargarlos y poco más). Y no tengo idea alguna de cómo salir de la tabla de comandos y crear una interfaz para un programa; ya me comentaron que en C++ esto era a base de códigos pero he revisado bastantes páginas y solo mencionan muy por encima algunas cosas sobre la librería "windows.h" sin explicar comandos ni códigos (tampoco estoy muy seguro de que sea la librería estándar para crear interfaces). Otra cosa es, ¿de qué forma se puede "comunicar" el programa con el sistema operativo?, es decir, forzarlo a hacer acciones (apagar, acceder a un disco duro, comprobar datos del SO, leer dispositivos y un largo etcétera).

Vamos, que las funciones, clases, objetos, punteros, referencias, herencias y el resto de cosas que he aprendido solo me sirven para hacer calculadoras  :xD.

Espero que me aconsejéis por dónde continuar y alguna guía que seguir. Gracias por adelantado, saludos.
Páginas: [1] 2
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines