1
  1. Этот сайт использует файлы cookie. Продолжая пользоваться данным сайтом, Вы соглашаетесь на использование нами Ваших файлов cookie. Узнать больше.
Приветствуем вас,Гость, на форуме IFUD.WS. Обязательно рекомендуется к прочтению правила форума http://ifud.ws/threads/obnovleno-pravila-foruma.7759

Win Binary Operations

Тема в разделе "Программирование", создана пользователем By_Cryptor, 21 апр 2014.

  1. TopicStarter Overlay
    By_Cryptor

    By_Cryptor

    Регистрация:
    13 мар 2014
    Сообщения:
    354
    Симпатии:
    522
    [​IMG]

    Код:
    /*
     
    *************************************************************************************
    * Compilado con Dev C++, MinGw                                                    *
    *                                                                                  *
    *  Author: Leonardo A. Reichert                                                  *
    *  Date: 03/09/13 15:10                                                          *
    *  Description: Aplicacion simple que te ayudara a reconocer el funcionamiento de  *
    *              los operadores binarios.                                        *
    *                                                                                  *
    *************************************************************************************
     
    Se necesita linkear la libreria libgdi32.a
     
    */
     
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <windows.h>
     
     
    enum{
        CM_RESOLVE=1,
        CM_EDIT_N1,
        CM_EDIT_N1x,
        CM_EDIT_N2,
        CM_EDIT_N2x,
        CM_COMBO_TYPE_OP,
        CM_HELP_SELECT_OP,
        CM_EDIT_RESULT,
        CM_EDIT_RESULTx,
        CM_BUTTON_RESOLVE,
        CM_OPT_REPR_DEC,
        CM_OPT_REPR_BIN,
        CM_OPT_REPR_OCT,
        CM_OPT_REPR_HEX,
        CM_OPT_DEC,
        CM_OPT_BIN,
        CM_OPT_OCT,
        CM_OPT_HEX,
        CM_HELP_USE_OPERS,
        CM_ABOUT
    };
     
    #define INPUT_DEC_LEN 10
    #define INPUT_BIN_LEN 32
    #define INPUT_OCT_LEN 11
    #define INPUT_HEX_LEN 8
     
    #define DIGITS_HEX "0123456789ABCDEF"
    #define DIGITS_DEC "0123456789"
    #define DIGITS_OCT "01234567"
    #define DIGITS_BIN "01"
     
    HWND hEditN1;
    HWND hEditN1Repr;
    HWND hEditN2;
    HWND hEditN2Repr;
    HWND hComboBoxOp;
    HWND hButtonOpHelp;
    HWND hEditResult;
    HWND hEditResultRepr;
    HWND hButtonResolve;
     
    HMENU hMenuBar;
    HMENU hMenuVista;
    HMENU hMenuVistaNum;
    HMENU hMenuVistaNumRepr;
    HMENU hMenuHelp;
     
    void About(HWND hParent){
     
        MessageBox(hParent,
    "\
    ... Win-Binary-Operations ...\n\
    \n\
    Esta aplicación te ayudara a comprender\n\
    practicando libremente las operaciones\n\
    binarias que realiza un procesador.\n\
    Podes usar numeros de 32 bits, sin signo.\n\
    \n\
    Copyright (C) 2013 Leonardo Adrian Reichert.",
     
    "Acerca de Win-Binary-Operations", MB_ICONINFORMATION);
     
    }
     
    void Help(HWND hParent){
     
        MessageBox(hParent,
    "Los operadores binarios son usados en ingeniería informática.\n\
    Puede que si te adentras en un tema profundo necesites aprender\n\
    sobre estos operadores para realizar operaciones binarias de\n\
    tal manera que puedas resolver tu problema.\n\
    \n\
    Presiona el botón [?] en la derecha de la ventana para\n\
    consultar cada operador que selecciones.\n\
    \n\
    Tienes la ventaja de observar cada numero en distintas bases.\n\
    Solo se pueden usar numeros de 32 bits, sin signo.\n\
    Respetando asi, cada limitación de los numeros introducidos:\n\
        * Decimal (0 a 4294967295)\n\
        * Binario (0 a 11111111111111111111111111111111)\n\
        * Octal (0 a 37777777777)\n\
        * Hexadecimal (0 a FFFFFFFF)", "Win-Binary-Operations - ayuda",
        MB_ICONINFORMATION);
    }
     
    char * GetWinText(HWND hWin){
     
        int size = GetWindowTextLength(hWin)+1;
                 
        char * out = (char*)malloc(size);
        if(out == NULL)
            return NULL;
     
        GetWindowText(hWin, out, size);
     
        return out;
    }
     
    void MakeMenus(HWND hParent){
     
        hMenuBar = CreateMenu();
        hMenuVista = CreateMenu();
        hMenuVistaNum = CreateMenu();
        hMenuVistaNumRepr = CreateMenu();
        hMenuHelp = CreateMenu();
     
        AppendMenu(hMenuBar, MF_STRING|MF_POPUP, (UINT)hMenuVista, "&Vista");
     
        AppendMenu(hMenuVista, MF_STRING|MF_POPUP, (UINT)hMenuVistaNum, "&Números");
        AppendMenu(hMenuVistaNum, MF_STRING, CM_OPT_DEC, "&Decimal");
        AppendMenu(hMenuVistaNum, MF_STRING, CM_OPT_BIN, "&Binario");
        AppendMenu(hMenuVistaNum, MF_STRING, CM_OPT_OCT, "&Octal");
        AppendMenu(hMenuVistaNum, MF_STRING, CM_OPT_HEX, "&Hexadecimal");
        CheckMenuRadioItem(hMenuVistaNum, CM_OPT_DEC, CM_OPT_HEX, CM_OPT_DEC, MF_BYCOMMAND);
     
        AppendMenu(hMenuVista, MF_STRING|MF_POPUP, (UINT)hMenuVistaNumRepr, "&Representación");
        AppendMenu(hMenuVistaNumRepr, MF_STRING, CM_OPT_REPR_DEC, "&Decimal");
        AppendMenu(hMenuVistaNumRepr, MF_STRING, CM_OPT_REPR_BIN, "&Binario");
        AppendMenu(hMenuVistaNumRepr, MF_STRING, CM_OPT_REPR_OCT, "&Octal");
        AppendMenu(hMenuVistaNumRepr, MF_STRING, CM_OPT_REPR_HEX, "&Hexadecimal");
        CheckMenuRadioItem(hMenuVistaNumRepr, CM_OPT_REPR_DEC, CM_OPT_REPR_HEX, CM_OPT_REPR_BIN, MF_BYCOMMAND);
     
        AppendMenu(hMenuBar, MF_STRING|MF_POPUP, (UINT)hMenuHelp, "&Ayuda");
        AppendMenu(hMenuHelp, MF_STRING, CM_HELP_USE_OPERS, "Operadores binarios");
        AppendMenu(hMenuHelp, MF_SEPARATOR, 0, 0);
        AppendMenu(hMenuHelp, MF_STRING, CM_ABOUT, "Acerca de Win-Binary-Operations");
     
        SetMenu(hParent, hMenuBar);
    }
     
    char * Itoa(unsigned int num, char * out, int base){
     
        /*
        Esta funcion es usada si se requiere, convertir un numero en una cadena de caracteres, eligiendo la base desde 2 a 16.
     
        Si el parametro out es NULL, entonces, la funcion devuelve una nueva cadena iniciada con la funcion malloc.
        Si la funcion falla, el valor devuelto es NULL.
        */
     
        if(out==NULL){
            out = (char*)malloc(34);
            if(out==NULL)
                return 0;
            }
     
        int i=0;
     
        do{
            *(out+i) = DIGITS_HEX[num%base];
     
            num /= base;
     
            i++;
        }while(num);
     
        *(out+i) = 0;
     
        strrev(out);
     
        return out;
    }
     
    unsigned int Atoi(const char * str, int base){
     
        /*
        Esta funcion es usada si se requiere, convertir una cadena a numero de base entre 2 y 16
     
        Cuidado: Se asume que el parametro str, no debe contener caracteres fuera de DIGITS_HEX cadena.
        Este cuidado se debe llevar a cabo fuera de esta funcion.
        */
     
        unsigned int num=0;
        unsigned short int e;
     
     
        while(*str){
          num *= base;
     
            for(e=0; e<base; e++){
                if(*(DIGITS_HEX+e) == *str)
                    num += e;
                }
     
            str++;
            }
     
        return num;
    }
     
    UINT GetMenuRadioOn(HMENU hMenu){
     
        unsigned short int i = GetMenuItemCount(hMenu);
     
        while(i--){
     
            if((GetMenuState(hMenu, i, MF_BYPOSITION)&MFS_CHECKED) == MFS_CHECKED)
                return GetMenuItemID(hMenu, i);
     
            }
     
        return 0;
    }
     
     
    BOOL EditNumChangeBase(HWND hEdit, int from_base, int to_base){
     
        char * text = GetWinText(hEdit);
        if(text==NULL)
            return 1;
     
        unsigned int numb = Atoi(text, from_base);
        free(text);
     
        char * nwtext = Itoa(numb, 0, to_base);
     
        SetWindowText(hEdit, nwtext);
        free(nwtext);
     
        int limit_text = 0;
        switch(to_base){
            case 2:
                limit_text = INPUT_BIN_LEN;
                break;
            case 8:
                limit_text = INPUT_OCT_LEN;
                break;
            case 10:
                limit_text = INPUT_DEC_LEN;
                break;
            case 16:
                limit_text = INPUT_HEX_LEN;
                break;
            }
     
        SendMessage(hEdit, EM_SETLIMITTEXT, limit_text, 0);
     
        return 0;
    }
     
    int GetBaseFromCommand(UINT cmd){
     
        switch(cmd){
            case CM_OPT_DEC:
            case CM_OPT_REPR_DEC:
                return 10;
            case CM_OPT_BIN:
            case CM_OPT_REPR_BIN:
                return 2;
            case CM_OPT_OCT:
            case CM_OPT_REPR_OCT:
                return 8;
            case CM_OPT_HEX:
            case CM_OPT_REPR_HEX:
                return 16;
            }
     
        return 10;
    }
     
    char * GetBufferPermisActual(){
        unsigned short int actual_base = GetBaseFromCommand(GetMenuRadioOn(hMenuVistaNum));
                         
        switch(actual_base){
            case 2:
                return DIGITS_BIN;
            case 8:
                return DIGITS_OCT;
            case 10:
                return DIGITS_DEC;
            case 16:
                return DIGITS_HEX;
            }
     
        return DIGITS_DEC;
    }
     
    BOOL ChrInStr(char * str, char chr){
     
        for(; *str; str++){
            if(*str==chr)
                break;
            }
     
        return *str;
    }
     
    void HelpOpers(HWND hParent, int oper){
     
        char titles[][39] = {
        "Operador binario Not",
        "Operador binario And",
        "Operador binario Or",
        "Operador binario Xor",
        "Operador binario de despl. a izquierda",
        "Operador binario de despl. a derecha"
        };
     
        char * helpmsg = "No haz seleccionado un operador.";
     
        switch(oper){
        case 0:
            helpmsg = "El operador Not:\n\
    Es una negacion logica a cada bit, cambia cada 0 a 1, y los 1 a 0.\n\
    Ejemplo:\n\
    a = 255 (binario 11111111)\n\
    NOT a\n\
    = -256 (binario -100000000)\n\
    \n\
    Nota: en este programa no se toma en cuenta los numeros negativos.";
            break;
        case 1:
            helpmsg = "El operador And:\n\
    Opera en dos numeros enteros (a & b), resulta en 1\n\
    para cada bit si los bit de a y b son iguales a 1,\n\
    resulta 0 para los otro casos.\n\
    Ejemplo:\n\
    a = 44 (binario 101100)\n\
    b = 13 (binario 001101)\n\
    a And b = 12 (binario 01100)";
            break;
        case 2:
            helpmsg = "El operador Or:\n\
    Cambia cada 0 por 1, resulta 1 si cualquiera de los bits operandos\n\
    son 1, pero resulta 0 si ambos bits son 0.\n\
    Ejemplo:\n\
    a = 25 (binario 11001)\n\
    b = 19 (binario 10011)\n\
    a Or b = 27 (binario 11011)";
            break;
        case 3:
            helpmsg = "El operador Xor:\n\
    Opera en dos numeros enteros, resulta 1 si los dos bits son diferentes,\n\
    resulta 0 si son iguales.\n\
    Ejemplo:\n\
    a = 11 (binario 1011)\n\
    b = 12 (binario 1100)\n\
    a Xor b = 7 (binario 0111)";
            break;
        case 4:
            helpmsg = "El operador de desplazamiento a la izquierda:\n\
    Desplaza los bits hacia la izquierda, osea que agrega 0 en la izquierda\n\
    del numero binario tantas veces como se indique.\n\
    Ejemplo:\n\
    a = 29 (binario 11101)\n\
    b = 2 (binario 10)\n\
    a << b = 116 (binario 1110100)";
            break;
        case 5:
            helpmsg = "El operador de desplazamiento a la derecha:\n\
    Desplaza los bits hacia la derecha, osea que los bits de la\n\
    izquierda se pierden tantas veces como se indique.\n\
    Ejemplo:\n\
    a = 13 (binario 1101)\n\
    b = 2 (binario 10)\n\
    a >> b = 3 (binario 11)";
            break;
        }
     
        MessageBox(hParent, helpmsg, titles[oper], MB_ICONINFORMATION);
     
    }
     
    unsigned int bit_level(unsigned int num){
     
        int bits=0;
     
        while(num){
            bits += 1;
     
            num /= 2;
            }
     
        return bits;
    }
     
    unsigned int bit_despl_left(unsigned int num, unsigned int despl){
     
        if((bit_level(num)+despl) > INPUT_BIN_LEN ){
            return -1;
            }
     
        return num<<despl;
    }
     
    /* Esta función es llamada por la función del API DispatchMessage() */
    LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){
        switch (msg){ /* manipulador del mensaje */
            case WM_DESTROY:
                PostQuitMessage(0); /* envía un mensaje WM_QUIT a la cola de mensajes */
                break;
            case WM_COMMAND:
                switch(LOWORD(wParam)){
                    case CM_HELP_USE_OPERS:
                        Help(hwnd);
                        break;
                    case CM_ABOUT:
                        About(hwnd);
                        break;
                    case CM_OPT_DEC:
                    case CM_OPT_BIN:
                    case CM_OPT_OCT:
                    case CM_OPT_HEX:
                        {
                 
                        /*se obtiene la base actual*/
                        int actual_base = GetBaseFromCommand(GetMenuRadioOn(hMenuVistaNum));
                 
                        /*se cambia la base actual*/
                        CheckMenuRadioItem(hMenuVistaNum, CM_OPT_DEC, CM_OPT_HEX, wParam, MF_BYCOMMAND);
                 
                        /*se trabaja con la anterior base*/
                        EditNumChangeBase(hEditN1, actual_base, GetBaseFromCommand(wParam));
                 
                        EditNumChangeBase(hEditN2, actual_base, GetBaseFromCommand(wParam));
                 
                        EditNumChangeBase(hEditResult, actual_base, GetBaseFromCommand(wParam));
                 
                        switch(wParam){
                                case CM_OPT_DEC:
                                    SendMessage(hEditN1, EM_SETLIMITTEXT, INPUT_DEC_LEN, 0);
                                    SendMessage(hEditN2, EM_SETLIMITTEXT, INPUT_DEC_LEN, 0);
                                    break;
                                case CM_OPT_BIN:
                                    SendMessage(hEditN1, EM_SETLIMITTEXT, INPUT_BIN_LEN, 0);
                                    SendMessage(hEditN2, EM_SETLIMITTEXT, INPUT_BIN_LEN, 0);
                                    break;
                                case CM_OPT_OCT:
                                    SendMessage(hEditN1, EM_SETLIMITTEXT, INPUT_OCT_LEN, 0);
                                    SendMessage(hEditN2, EM_SETLIMITTEXT, INPUT_OCT_LEN, 0);
                                    break;
                                case CM_OPT_HEX:
                                    SendMessage(hEditN1, EM_SETLIMITTEXT, INPUT_HEX_LEN, 0);
                                    SendMessage(hEditN2, EM_SETLIMITTEXT, INPUT_HEX_LEN, 0);
                                    break;
                            }
                 
                        }
                        break;
                    case CM_OPT_REPR_DEC:
                    case CM_OPT_REPR_BIN:
                    case CM_OPT_REPR_OCT:
                    case CM_OPT_REPR_HEX:
                        {
                        int actual_base = GetBaseFromCommand(GetMenuRadioOn(hMenuVistaNumRepr));
                 
                        EditNumChangeBase(hEditN1Repr, actual_base, GetBaseFromCommand(wParam));
                 
                        EditNumChangeBase(hEditN2Repr, actual_base, GetBaseFromCommand(wParam));
                 
                        EditNumChangeBase(hEditResultRepr, actual_base, GetBaseFromCommand(wParam));
                 
                        CheckMenuRadioItem(hMenuVistaNumRepr, CM_OPT_REPR_DEC, CM_OPT_REPR_HEX, wParam, MF_BYCOMMAND);
                        }
                        break;
                    case CM_COMBO_TYPE_OP:
                        switch(HIWORD(wParam)){
                            case CBN_SELCHANGE:
                                {
                                int cursel = SendMessage(hComboBoxOp, CB_GETCURSEL, 0, 0);
                         
                                if(cursel==0)
                                    SendMessage(hEditN2, EM_SETREADONLY, 1, 0);
                                else
                                    SendMessage(hEditN2, EM_SETREADONLY, 0, 0);
                                }
                                break;
                            }
                        break;
                    case CM_RESOLVE:
                        {
                 
                        //GetMenuRadioOn(hMenuVistaNum);
                 
                        int actual_base = GetBaseFromCommand(GetMenuRadioOn(hMenuVistaNum));
                 
                        char * text_num1 = GetWinText(hEditN1);
                        if(text_num1==NULL)
                            return 0;
                     
                        char * text_num2 = GetWinText(hEditN2);
                        if(text_num2==NULL){
                            free(text_num1);
                            return 0;
                            }
                 
                        unsigned int n1 = Atoi(text_num1, actual_base);
                        unsigned int n2 = Atoi(text_num2, actual_base);
                 
                        free(text_num1);
                        free(text_num2);
                 
                        int oper = SendMessage(hComboBoxOp, CB_GETCURSEL, 0, 0);
                 
                        unsigned int result = 0;
                 
                        switch(oper){
                                case 0:
                                    result = ~n1;
                                    if((int)result < 0)
                                        result = -result;
                                    break;
                                case 1:
                                    result = n1&n2;
                                    break;
                                case 2:
                                    result = n1|n2;
                                    break;
                                case 3:
                                    result = n1^n2;
                                    break;
                                case 4:
                                    result = bit_despl_left(n1, n2);
                                    if(result==-1){
                                        MessageBox(hwnd, "Fuera del rango.\nLos numeros que se pueden usar son de 32 bits (entero sin signo), no mas.", "Error", MB_ICONERROR);
                                        return 0;
                                        }
                                    break;
                                case 5:
                                    result = n1>>n2;
                                    break;
                            }
                 
                        char * text_result = Itoa(result, NULL, actual_base);
                 
                        SetWindowText(hEditResult, text_result);
                        free(text_result);
                 
                        short actual_base_repr = GetBaseFromCommand(GetMenuRadioOn(hMenuVistaNumRepr));
                 
                        char * text_result_repr = Itoa(result, NULL, actual_base_repr);
                 
                        SetWindowText(hEditResultRepr, text_result_repr);
                        free(text_result_repr);
                 
                        //return 0;
                        }
                        SetFocus(hwnd);
                        break;
                    case CM_HELP_SELECT_OP:
                        HelpOpers(hwnd, SendMessage(hComboBoxOp, CB_GETCURSEL, 0, 0));
                        break;
                    case CM_EDIT_N1:
                    case CM_EDIT_N2:
                        switch(HIWORD(wParam)){
                            case EN_UPDATE:
                                {
                                HWND hEdit = (HWND)lParam;
                         
                                DWORD hSel = SendMessage(hEdit, EM_GETSEL, 0, 0);
                         
                                char * text = GetWinText(hEdit);
                                if(text==NULL){
                                    return 0;
                                    }
                         
                                strupr(text);
                         
                                char * permis = GetBufferPermisActual();
                         
                                int i;
                                int e;
                         
                                for(i=0; *(text+i); i++){
                                    if(!ChrInStr(permis, *(text+i))){
                                        for(e=i; *(text+e); e++){
                                            *(text+e) = *(text+e+1);
                                            }
                                 
                                        SetWindowText(hEdit, text);
                                        SendMessage(hEdit, EM_SETSEL, LOWORD(hSel)-1, HIWORD(hSel)-1);
                                        break;
                                        }
                                    }
                         
                                }
                                break;
                            case EN_CHANGE:
                                {
                         
                                /*Ver si han sido iniciados los controles*/
                                if(!(hEditN1 && hEditN2))
                                    return 0;
                         
                                int actual_base = GetBaseFromCommand(GetMenuRadioOn(hMenuVistaNum));
                         
                                int actual_base_repr = GetBaseFromCommand(GetMenuRadioOn(hMenuVistaNumRepr));
                         
                                HWND hEdit = (HWND)lParam;
                                HWND hEditRepr;
                         
                                if(hEdit==hEditN1){
                                    hEditRepr = hEditN1Repr;
                                    }
                                else if(hEdit==hEditN2){
                                    hEditRepr = hEditN2Repr;
                                    }
                         
                                char * text = GetWinText(hEdit);
                                if(text==NULL){
                                    return 0;
                                    }
                         
                                if(actual_base==16)
                                    strupr(text);
                         
                                unsigned int num_text = Atoi(text, actual_base);
                         
                                char * text_repr = Itoa(num_text, NULL, actual_base_repr);
                                if(text_repr==NULL){
                                    free(text);
                                    return 0;
                                    }
                         
                                SetWindowText(hEditRepr, text_repr);
                         
                                free(text);
                                free(text_repr);
                                }
                                break;
                            }
                        break;
                    }
                break;
     
            default: /* para los mensajes de los que no nos ocupamos */
                return DefWindowProc(hwnd, msg, wParam, lParam);
            }
        return 0;
    }
     
    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow){
     
    HWND hWnd;
    MSG Message;
     
    WNDCLASS WndClass;
    WndClass.style = CS_HREDRAW | CS_VREDRAW;
    WndClass.lpfnWndProc = WindowProcedure;
    WndClass.cbClsExtra = 0;
    WndClass.cbWndExtra = 0;
    WndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
    WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    WndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    WndClass.hInstance = hInstance;
    WndClass.lpszClassName = "WIN_PRINCIPAL";
    WndClass.lpszMenuName = NULL;
    RegisterClass(&WndClass);
     
    hWnd = CreateWindow("WIN_PRINCIPAL",
                "Win-Binary-Operations",
                WS_MINIMIZEBOX | WS_SYSMENU,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                250,
                270,
                HWND_DESKTOP,
                NULL,
                hInstance,
                NULL
                );
     
    MakeMenus(hWnd);
    //HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
     
    HFONT hFont = CreateFont(-11, 0, 0, 0, FW_NORMAL, 0, 0, 0, 0, 3, 2, 1, 34, "Verdana");
    if(hFont==NULL){
        hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
        }
     
    HWND hLabelNum1 = CreateWindowEx(
        0,
        "Static",
        "1º número (a), y su representación:",
        WS_CHILD | WS_VISIBLE,
        10,10,225,19,
        hWnd,
        0,
        hInstance,0);
    SendMessage(hLabelNum1, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
    hEditN1 = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "Edit",
        "0",
        WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_UPPERCASE,
        10,30,110,19,
        hWnd,
        (HMENU)CM_EDIT_N1,
        hInstance,0);
    SendMessage(hEditN1, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
    SendMessage(hEditN1, EM_SETLIMITTEXT, INPUT_DEC_LEN, 0);
     
     
    hEditN1Repr = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "Edit",
        "0",
        WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_READONLY,
        125,30,110,19,
        hWnd,
        (HMENU)CM_EDIT_N2x,
        hInstance,0);
    SendMessage(hEditN1Repr, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
    HWND hLabelOps = CreateWindowEx(
        0,
        "Static",
        "Operación:",
        WS_CHILD | WS_VISIBLE,
        10,55,110,19,
        hWnd,
        0,
        hInstance,0);
    SendMessage(hLabelOps, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
     
    hComboBoxOp = CreateWindowEx(
        0,
        "ComboBox",
        0,
        WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_VSCROLL,
        20,75,185,100,
        hWnd,
        (HMENU)CM_COMBO_TYPE_OP,
        hInstance,0);
    SendMessage(hComboBoxOp, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
    char operations[][34] = {
        " ~ - Not - Complemento (a)",
        " & - And - Producto lógico",
        " | - Or - Suma lógica",
        " ^ - Xor - Suma exclusiva",
        "<< - Despl. izquierda",
        ">> - Despl. derecha",
        "\0"
        };
     
    int i;
    for(i=0; operations[0]; i++)
        SendMessage(hComboBoxOp, CB_ADDSTRING, 0, (LPARAM)operations);
     
    SendMessage(hComboBoxOp, CB_SETCURSEL, 0, 0);
     
    hButtonOpHelp = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "Button",
        "?",
        WS_CHILD | WS_VISIBLE,
        206,75,20,21,
        hWnd,
        (HMENU)CM_HELP_SELECT_OP,
        hInstance,0);
    SendMessage(hButtonOpHelp, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
     
    HWND hLabelNum2 = CreateWindowEx(
        0,
        "Static",
        "2º número (b), y su representación:",
        WS_CHILD | WS_VISIBLE,
        10,100,225,19,
        hWnd,
        0,
        hInstance,0);
    SendMessage(hLabelNum2, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
     
    hEditN2 = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "Edit",
        "0",
        WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_UPPERCASE | ES_READONLY,
        10,120,110,19,
        hWnd,
        (HMENU)CM_EDIT_N2,
        hInstance,0);
    SendMessage(hEditN2, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
    hEditN2Repr = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "Edit",
        "0",
        WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_READONLY,
        125,120,110,19,
        hWnd,
        (HMENU)CM_EDIT_N2x,
        hInstance,0);
    SendMessage(hEditN2Repr, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
     
    HWND hLabelResult = CreateWindowEx(
        0,
        "Static",
        "Resultado, y su representación:",
        WS_CHILD | WS_VISIBLE,
        10,145,225,19,
        hWnd,
        0,
        hInstance,0);
    SendMessage(hLabelResult, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
    hEditResult = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "Edit",
        "0",
        WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_READONLY,
        10,165,110,19,
        hWnd,
        0,
        hInstance,0);
    SendMessage(hEditResult, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
    hEditResultRepr = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "Edit",
        "0",
        WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_READONLY,
        125,165,110,19,
        hWnd,
        0,
        hInstance,0);
    SendMessage(hEditResultRepr, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     
    HWND hButtonResolve = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "Button",
        "Operar",
        WS_CHILD | WS_VISIBLE,
        70,190,100,25,
        hWnd,
        (HMENU)CM_RESOLVE,
        hInstance,0);
    SendMessage(hButtonResolve, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
                 
     
    ShowWindow(hWnd, SW_SHOWDEFAULT);
    while(TRUE == GetMessage(&Message, 0, 0, 0)){
        TranslateMessage(&Message);
        DispatchMessage(&Message);
        }
     
    return Message.wParam;
    }




    Please login or register to view links
    ------------------------------------------------------------------------------------------------------------------------------------------------------​
    [​IMG]
     
    Метки:

Поделиться этой страницей

Загрузка...