Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Paint XY (V1.1) - main.cpp

main.cpp

 Caricato da: Dany
Scarica il programma completo

  1. //Dichiarazione librerie
  2. #include <windows.h>
  3. #include <Windowsx.h>
  4. #include <commctrl.h>
  5. #include <cmath>
  6. #include <cstring>
  7. //Dichiarazioni per visual style (grafica win 7)
  8. #pragma comment( lib, "comctl32.lib")
  9. #pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' \processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
  10. //Fine Dichiarazioni...
  11. //Namespace:
  12. using namespace std;
  13. //Dichiarazione variabili globali:
  14. //Class Name
  15. static char g_szClassName[] = "MainWindow",name[]="CurveWindow",name3[]="SettingWindow";
  16. static HINSTANCE g_hInst = NULL;
  17. //Timer
  18. const UINT idTimer1 = 1;
  19. UINT nTimerDelay = 1;
  20. //Bitmap
  21. HBITMAP hbmBall, hbmMask,griglia,maskgri;
  22. BITMAP bm;
  23. //Coordinate Punto funzione
  24. int ballX, ballY;
  25. //Variabile che indica se è stato cliccato il tasto disegna nella finestra delle curve
  26. int agg;  
  27. //Font dei Caratteri:
  28. RECT rect;
  29. HFONT hfont;
  30. LOGFONT lf;
  31. //Precisione nel disegno delle funzioni
  32. float prec=100;
  33. float preprec;   //Se si clicca annulla nella setting window ripristina il valore precedente di prec.
  34. //Progress Bar in Curve Window
  35. HWND prog;
  36.  
  37. //Dichiarazione della WndProc Della MainWindow
  38. LRESULT CALLBACK WndProc(HWND hwnd ,UINT Message, WPARAM wParam, LPARAM lParam);
  39. //Disegna il punto utilizzato nelle rappresentazioni di cruve e funzioni.
  40. void DrawBall(HDC hdc)
  41. {
  42.    HDC hdcMemory;
  43.    hdcMemory = CreateCompatibleDC(hdc);
  44.  
  45.    SelectObject(hdcMemory, hbmMask);
  46.    BitBlt(hdc, ballX, ballY, bm.bmWidth, bm.bmHeight, hdcMemory, 0, 0, SRCAND);
  47.  
  48.    SelectObject(hdcMemory, hbmBall);
  49.    BitBlt(hdc, ballX, ballY, bm.bmWidth, bm.bmHeight, hdcMemory, 0, 0, SRCPAINT);
  50.  
  51.    DeleteDC(hdcMemory);
  52. }
  53. //Disegna la griglia di sfondo
  54. void DrawGriglia(HDC hdc)
  55. {
  56.      HDC hdcMemory;
  57.      hdcMemory=CreateCompatibleDC(hdc);
  58.          SelectObject(hdcMemory, maskgri);
  59.          BitBlt(hdc, 0, 0, 1000, 1000, hdcMemory, 0, 0, SRCAND);
  60.          SelectObject(hdcMemory, griglia);
  61.      BitBlt(hdc, 0, 0, 1000, 1000, hdcMemory, 0, 0, SRCPAINT);
  62.      DeleteDC(hdcMemory);
  63. }
  64. //Dichiarazione variabili in WndProc
  65. //Variabili disegno funzione
  66. float i,x,y;
  67. float inc=0.01;
  68. //Variabili Menu:
  69. HMENU file,hfile,info,hinfo,modifica,hmodifica;
  70. int MENU_FILE_EXIT=0;  //Valore ritorno se si clicca su "Esci"
  71. int MENU_FILE_CURV=1;  //Valore ritorno se si clicca su "Disegna curve"
  72. int MENU_FILE_FUNZ=2;  //Valore ritorno se si clicca su "Disegna funzione"
  73. int MENU_FILE_ABOU=3;  //Valore ritorno se si clicca su "Informazioni su "Paint XY"
  74. int MENU_FILE_CLEA=6;  //Valore ritorno se si clicca su "Pulisci"
  75. int MENU_FILE_SETT=7;  //Valore ritorno se si clicca su "Opzioni"
  76. //Variabile che specificano il tipo di curva scelto.
  77. int curva;   //retta=1,parabola=2,ellisse=3,iperbole=4,circonferenza=5,parabola(x)=6
  78. //Variabili di lettura degli edit nella finestra delle curve...
  79. char numa[5],numb[5],numc[5];
  80. //...e di converzione di questi:
  81. float a,b,c;
  82. /*Array necessari per ridisegnare le curve nel caso si riduce a icona la finestra...
  83. Gli array memorizzano i vari coefficienti per ogni curva e vengono letti per ridisegnarle.*/
  84. float ca[20],cb[20],cc[20];
  85. float da[20],db[20],dc[20];
  86. float ea[20],eb[20],ec[20];
  87. float fa[20],fb[20],fc[20];
  88. float ga[20],gb[20],gc[20];
  89. float ha[20],hb[20],hc[20];
  90. //Variabili contatrici
  91. int k,l,l2,l3,l4,l5,l6;
  92. /*Variabile che indica se si è già tentato di disegnare la funzione:
  93. Per non rendere troppo pesante l'avvio del programma, il prog inizierà a
  94. ridisegnare le funzioni (se la finestra viene ridotta e riaperta) solo dopo
  95. aver premuto il tasto "disegna" nella CurveWindow.*/
  96. int bo;
  97. LRESULT CALLBACK WndProc(HWND hwnd ,UINT Message, WPARAM wParam, LPARAM lParam)
  98. {  
  99.         InitCommonControls ();   //Applicazione visual style
  100.    switch(Message)
  101.    {
  102.       case WM_CREATE:
  103.                   //Nella finestra principale:
  104.                   //Inizializzazione delle immagini BMP
  105.           hbmBall = LoadBitmap(g_hInst, "BALLBMP");
  106.           griglia = LoadBitmap(g_hInst, "gri");
  107.           hbmMask = LoadBitmap(g_hInst, "MASKBMP");
  108.                   maskgri = LoadBitmap(g_hInst, "maskgri");
  109.           if(!hbmBall || !hbmMask)
  110.           {
  111.            MessageBox(hwnd, "Load of resources failed.", "Error",MB_OK | MB_ICONEXCLAMATION);
  112.            return -1;
  113.           }
  114.           GetObject(hbmBall, sizeof(bm), &bm);
  115.                   //Timer:
  116.           SetTimer(hwnd, idTimer1, nTimerDelay, NULL);
  117.                   //Menu:
  118.                   //Dichiarazione Menu:
  119.                   file=CreateMenu();
  120.                   hfile=CreatePopupMenu();
  121.                   info=CreateMenu();
  122.                   hinfo=CreatePopupMenu();
  123.                   modifica=CreateMenu();
  124.                   hmodifica=CreatePopupMenu();
  125.                   //Creazione Menu:
  126.                   /*File*/
  127.           AppendMenu(file,MF_STRING|MF_POPUP,(UINT_PTR) hfile,TEXT("File"));
  128.                   AppendMenu(hfile,MF_STRING,MENU_FILE_SETT,TEXT("Impostazioni"));
  129.           AppendMenu(hfile,MF_STRING,MENU_FILE_EXIT,TEXT("Esci"));
  130.                   /*Modifica*/
  131.                   AppendMenu(file,MF_STRING|MF_POPUP,(UINT_PTR) hmodifica,TEXT("Grafico"));
  132.           AppendMenu(hmodifica,MF_STRING,MENU_FILE_CURV,TEXT("Disegna Curve"));
  133.                   AppendMenu(hmodifica,MF_STRING,MENU_FILE_CLEA,TEXT("Pulisci"));
  134.                   /*Info*/
  135.                   AppendMenu(file,MF_STRING|MF_POPUP,(UINT_PTR) hinfo,TEXT("Info"));
  136.                   AppendMenu(hinfo,MF_STRING,MENU_FILE_ABOU,TEXT("Informazioni su Paint XY"));
  137.                   //Rende visibile i menu
  138.                   SetMenu(hwnd,file);  
  139.           break;
  140.       case WM_TIMER:
  141.          if(hbmBall && hbmMask)
  142.          {
  143.             HDC hdcWindow;
  144.             hdcWindow = GetDC(hwnd);
  145.                         //Disegno Curve***********************************************************************
  146.                         if (agg>0)   //Se è stato cliccato il tasto 'disegna' nella fuinestra delle curve
  147.                         {
  148.                                 agg=0;       //reimposta il tasto
  149.                                 i=-10;
  150.                         while(i<=10)
  151.             {
  152.                                 i=i+inc;     //inc è l'incremento, modificabile nella setting window
  153.                                 x=i;
  154.                                 SendMessage(prog, PBM_SETPOS, (i+10)*100/20, 0);   //Setto la progressBar
  155.                                 if (curva==1)  //(retta)
  156.                                 {
  157.                                         a=atof(numa);
  158.                                         b=atof(numb);
  159.                                         c=atof(numc);
  160.                                         if (b!=0)
  161.                                         y=((-c-(a*x))/b);
  162.                                         else           //se la retta è parallela all'asse y
  163.                                         {
  164.                                                 x=c/a;
  165.                                                 y=i;
  166.                                         }
  167.                                         //Converte i numeri in coordinate in pixel:
  168.                                         ballX=ceil(500+(x*50));
  169.                                         ballY=ceil(500-(y*50));
  170.                                         DrawBall(hdcWindow);
  171.                                 }
  172.                                 if (curva==2)  //(parabola con asse parallelo all'asse delle y)
  173.                                 {
  174.                                         a=atof(numa);
  175.                                         b=atof(numb);
  176.                                         c=atof(numc);
  177.                                         y=(a*x*x)+(b*x)+c;
  178.                                         //Converte i numeri in coordinate in pixel:
  179.                                         ballX=ceil(500+(x*50));
  180.                                         ballY=ceil(500-(y*50));
  181.                                         DrawBall(hdcWindow);
  182.                                 }
  183.                                 if (curva==3)  //(Ellisse)
  184.                                 {
  185.                                         a=atof(numa);
  186.                                         b=atof(numb);
  187.                                         y=sqrt(b*b*(a*a-x*x)/(a*a));
  188.                                         //Converte i numeri in coordinate in pixel:
  189.                                         ballX=ceil(500+(x*50));
  190.                                         ballY=ceil(500-(y*50));
  191.                                         DrawBall(hdcWindow);
  192.                                         y=-sqrt(b*b*(a*a-x*x)/(a*a));
  193.                                         //Converte i numeri in coordinate in pixel:
  194.                                         ballX=ceil(500+(x*50));
  195.                                         ballY=ceil(500-(y*50));
  196.                                         DrawBall(hdcWindow);
  197.                                 }
  198.                                 if (curva==4)  //(Iperbole)
  199.                                 {
  200.                                         a=atof(numa);
  201.                                         b=atof(numb);
  202.                                         y=sqrt(b*b*(x*x-a*a)/(a*a));
  203.                                         //Converte i numeri in coordinate in pixel:
  204.                                         ballX=ceil(500+(x*50));
  205.                                         ballY=ceil(500-(y*50));
  206.                                         DrawBall(hdcWindow);
  207.                                         y=-sqrt(b*b*(x*x-a*a)/(a*a));
  208.                                         //Converte i numeri in coordinate in pixel:
  209.                                         ballX=ceil(500+(x*50));
  210.                                         ballY=ceil(500-(y*50));
  211.                                         DrawBall(hdcWindow);
  212.                                 }
  213.                                 if (curva==5)  //(Circonferenza)
  214.                                 {
  215.                                         a=atof(numa);
  216.                                         b=atof(numb);
  217.                                         c=atof(numc);
  218.                                         y=b+sqrt((c*c)-((x-a)*(x-a)));
  219.                                         //Converte i numeri in coordinate in pixel:
  220.                                         ballX=ceil(500+(x*50));
  221.                                         ballY=ceil(500-(y*50));
  222.                                         DrawBall(hdcWindow);
  223.                                         y=-b-sqrt((c*c)-((x-a)*(x-a)))+2*b;
  224.                                         //Converte i numeri in coordinate in pixel:
  225.                                         ballX=ceil(500+(x*50));
  226.                                         ballY=ceil(500-(y*50));
  227.                                         DrawBall(hdcWindow);
  228.                                 }
  229.                                 if (curva==6)  //(Parabola con asse parallelo all'asse delle x)
  230.                                 {
  231.                                         a=atof(numa);
  232.                                         b=atof(numb);
  233.                                         c=atof(numc);
  234.                                         y=(-b+sqrt(b*b-4*a*c+4*a*x))/2;
  235.                                         //Converte i numeri in coordinate in pixel:
  236.                                         ballX=ceil(500+(x*50));
  237.                                         ballY=ceil(500-(y*50));
  238.                                         DrawBall(hdcWindow);
  239.                                         y=-(-b+sqrt(b*b-4*a*c+4*a*x)+2*b)/2;
  240.                                         //Converte i numeri in coordinate in pixel:
  241.                                         ballX=ceil(500+(x*50));
  242.                                         ballY=ceil(500-(y*50));
  243.                                         DrawBall(hdcWindow);
  244.                                 }
  245.             }  
  246.                     }
  247.                     //Disegno Funzioni:************************************************************************
  248.                         ///
  249.                         ReleaseDC(hwnd, hdcWindow);
  250.                  }
  251.                   break;
  252.       case WM_COMMAND:
  253.                    if (LOWORD(wParam)==MENU_FILE_EXIT)
  254.                    {
  255.                            DestroyWindow(hwnd);    //Chiudo la finestra
  256.                    }
  257.            if (LOWORD(wParam)==MENU_FILE_CURV)
  258.                    {
  259.                            //Crea e visualizza la finestra
  260.                            MSG messages2;
  261.                HWND hwnd2 = CreateWindowEx (0,name,"Curve:",WS_SYSMENU|WS_MINIMIZEBOX|WS_VISIBLE,400,400,400,300,hwnd, NULL, g_hInst,NULL);
  262.                ShowWindow (hwnd2, 1);
  263.                while (GetMessage (&messages2, NULL, 0, 0))
  264.                            {
  265.                        TranslateMessage(&messages2);
  266.                        DispatchMessage(&messages2);
  267.                            }
  268.                    }
  269.                    if (LOWORD(wParam)==MENU_FILE_ABOU)
  270.                    {
  271.                            MessageBox(hwnd,"Paint XY - Versione 1.1","By Stromberg",MB_OK|MB_ICONINFORMATION);
  272.                    }
  273.                    if (LOWORD(wParam)==MENU_FILE_CLEA)
  274.                    {
  275.                            curva=0;
  276.                            bo=0;
  277.                            ShowWindow(hwnd,0);
  278.                            ShowWindow(hwnd,1);
  279.                            l=0;l2=0;l3=0;l4=0;l5=0;l6=0;  //Azzero le variabili contatrici degli array
  280.                    }
  281.                    if (LOWORD(wParam)==MENU_FILE_SETT)
  282.                    {
  283.                            //Crea e visualizza la finestra
  284.                            MSG messages4;
  285.                HWND hwnd4 = CreateWindowEx (0,name3,"Impostazioni:",WS_SYSMENU|WS_MINIMIZEBOX|WS_VISIBLE,400,400,390,200,hwnd, NULL, g_hInst,NULL);
  286.                            ShowWindow (hwnd4, 1);
  287.                            while (GetMessage (&messages4, NULL, 0, 0))
  288.                            {
  289.                        TranslateMessage(&messages4);
  290.                        DispatchMessage(&messages4);
  291.                            }
  292.                            preprec=prec;
  293.                    }
  294.            break;
  295.       case WM_PAINT:
  296.          if(hbmBall && hbmMask)
  297.          {
  298.             PAINTSTRUCT ps;
  299.             HDC hdcWindow;
  300.             hdcWindow = BeginPaint(hwnd, &ps);
  301.             DrawGriglia(hdcWindow);
  302.                         /*******RIDISEGNA LE FUNZIONI SE LA FINESTRA VIENE RIDOTTA/COPERTA*****/
  303.                         if (bo>0)     //Se il prog è appena stato aperto/pulito
  304.                         for (curva=1;curva<=6;curva++)    //Ciclo con tutti i tipi di curva
  305.                         for (i=-10;i<=10;i=i+inc)
  306.             {
  307.                                 x=i;
  308.                                 if (curva==1)  //(retta)
  309.                                 {
  310.                                         if (l>0)                //Se la curva non è mai stata disegnata, salta il ciclo
  311.                                         for  (k=0;k<=l-1;k++)    //Verifica tutte le posizioni dell'array e le usa per ridisegnare la funzione
  312.                                         {
  313.                                         a=ca[k];
  314.                                         b=cb[k];
  315.                                         c=cc[k];
  316.                                         if (b!=0)
  317.                                         y=((-c-(a*x))/b);
  318.                                         else            //RETTA PARALLELA ALL'ASSE DELLE X
  319.                                         {
  320.                                                 x=c/a;
  321.                                                 y=i;
  322.                                         }
  323.                                         //Converte i numeri in coordinate in pixel:
  324.                                         ballX=ceil(500+(x*50));
  325.                                         ballY=ceil(500-(y*50));
  326.                                         DrawBall(hdcWindow);
  327.                                         }
  328.                                 }
  329.                                 if (curva==2)  //(parabola con asse parallelo all'asse delle y)
  330.                                 {
  331.                                         if (l2>0)      //Se la curva non è mai stata disegnata, salta il ciclo
  332.                                         for(k=0;k<=l2-1;k++)    //Verifica tutte le posizioni dell'array e le usa per ridisegnare la funzione
  333.                                         {
  334.                                         a=da[k];
  335.                                         b=db[k];
  336.                                         c=dc[k];
  337.                                         y=(a*x*x)+(b*x)+c;
  338.                                         //Converte i numeri in coordinate in pixel:
  339.                                         ballX=ceil(500+(x*50));
  340.                                         ballY=ceil(500-(y*50));
  341.                                         DrawBall(hdcWindow);
  342.                                         }
  343.                                 }
  344.                                 if (curva==3)  //(Ellisse)
  345.                                 {
  346.                                         if (l3>0)       //Se la curva non è mai stata disegnata, salta il ciclo
  347.                                         for(k=0;k<=l3-1;k++)       //Verifica tutte le posizioni dell'array e le usa per ridisegnare la funzione
  348.                                         {
  349.                                         a=ea[k];
  350.                                         b=eb[k];
  351.                                         y=sqrt(b*b*(a*a-x*x)/(a*a));
  352.                                         //Converte i numeri in coordinate in pixel:
  353.                                         ballX=ceil(500+(x*50));
  354.                                         ballY=ceil(500-(y*50));
  355.                                         DrawBall(hdcWindow);
  356.                                         y=-sqrt(b*b*(a*a-x*x)/(a*a));
  357.                                         //Converte i numeri in coordinate in pixel:
  358.                                         ballX=ceil(500+(x*50));
  359.                                         ballY=ceil(500-(y*50));
  360.                                         DrawBall(hdcWindow);
  361.                                         }
  362.                                 }
  363.                                 if (curva==4)  //(Iperbole)
  364.                                 {
  365.                                         if (l4>0)    //Se la curva non è mai stata disegnata, salta il ciclo
  366.                                         for(k=0;k<=l4-1;k++)      //Verifica tutte le posizioni dell'array e le usa per ridisegnare la funzione
  367.                                         {
  368.                                         a=fa[k];
  369.                                         b=fb[k];
  370.                                         y=sqrt(b*b*(x*x-a*a)/(a*a));
  371.                                         //Converte i numeri in coordinate in pixel:
  372.                                         ballX=ceil(500+(x*50));
  373.                                         ballY=ceil(500-(y*50));
  374.                                         DrawBall(hdcWindow);
  375.                                         y=-sqrt(b*b*(x*x-a*a)/(a*a));
  376.                                         //Converte i numeri in coordinate in pixel:
  377.                                         ballX=ceil(500+(x*50));
  378.                                         ballY=ceil(500-(y*50));
  379.                                         DrawBall(hdcWindow);
  380.                                         }
  381.                                 }
  382.                                 if (curva==5)  //(Circonferenza)
  383.                                 {
  384.                                         if (l5>0)     //Se la curva non è mai stata disegnata, salta il ciclo
  385.                                         for(k=0;k<=l5-1;k++)     //Verifica tutte le posizioni dell'array e le usa per ridisegnare la funzione
  386.                                         {
  387.                                         a=ga[k];
  388.                                         b=gb[k];
  389.                                         c=gc[k];
  390.                                         y=b+sqrt((c*c)-((x-a)*(x-a)));
  391.                                         //Converte i numeri in coordinate in pixel:
  392.                                         ballX=ceil(500+(x*50));
  393.                                         ballY=ceil(500-(y*50));
  394.                                         DrawBall(hdcWindow);
  395.                                         y=-b-sqrt((c*c)-((x-a)*(x-a)))+2*b;
  396.                                         //Converte i numeri in coordinate in pixel:
  397.                                         ballX=ceil(500+(x*50));
  398.                                         ballY=ceil(500-(y*50));
  399.                                         DrawBall(hdcWindow);
  400.                                         }
  401.                                 }
  402.                                 if (curva==6)  //(Parabola con asse parallelo all'asse delle x)
  403.                                 {
  404.                                         if (l6>0)    //Se la curva non è mai stata disegnata, salta il ciclo
  405.                                         for(k=0;k<=l6-1;k++)     //Verifica tutte le posizioni dell'array e le usa per ridisegnare la funzione
  406.                                         {
  407.                                         a=ha[k];
  408.                                         b=hb[k];
  409.                                         c=hc[k];
  410.                                         y=(-b+sqrt(b*b-4*a*c+4*a*x))/2;
  411.                                         //Converte i numeri in coordinate in pixel:
  412.                                         ballX=ceil(500+(x*50));
  413.                                         ballY=ceil(500-(y*50));
  414.                                         DrawBall(hdcWindow);
  415.                                         y=-(-b+sqrt(b*b-4*a*c+4*a*x)+2*b)/2;
  416.                                         //Converte i numeri in coordinate in pixel:
  417.                                         ballX=ceil(500+(x*50));
  418.                                         ballY=ceil(500-(y*50));
  419.                                         DrawBall(hdcWindow);
  420.                                         }
  421.                                 }
  422.             }  
  423.             EndPaint(hwnd, &ps);
  424.          }
  425.                  break;
  426.       case WM_CLOSE:
  427.                   if(MessageBox(hwnd,"Vuoi davvero uscire?","Messaggio",MB_YESNO|MB_ICONQUESTION)==IDYES)
  428.          DestroyWindow(hwnd);
  429.          break;
  430.       case WM_DESTROY:
  431.          KillTimer(hwnd, idTimer1);
  432.          DeleteObject(hbmBall);
  433.          DeleteObject(hbmMask);
  434.          PostQuitMessage(0);
  435.          break;
  436.       default:
  437.          return DefWindowProc(hwnd, Message, wParam, lParam);
  438.    }
  439.    return 0;
  440. }
  441. //WndProc della finestra per rappresentare le curve
  442. //HBIMAP del pulsante di disegno
  443. HBITMAP bmp=(HBITMAP)LoadImage(0,"draw.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
  444. //HWND DEL PULSANTE DI DISEGNO
  445. HWND paint;
  446. //Variabili HWND:
  447. HWND radpar,radipe,radell,radret,radcir,radparx;  
  448. HWND edita,editb,editc,sintax;
  449. //Variabili controllo radiobutton in finestra di disegno curve
  450. int selret,selpar,selipe,selell,selcir,selparx;
  451. //Tooltipe
  452. TOOLINFO ti;
  453. HWND hwtoll;
  454. LRESULT CALLBACK WindowProcedure2 (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  455. {              
  456.         InitCommonControls ();      //Applicazione visual style
  457.         switch (message)                  
  458.         {
  459.                         case WM_PAINT:
  460.                                 PAINTSTRUCT ps;
  461.                                 HDC hdcWindow;
  462.                                 hdcWindow = BeginPaint(hwnd, &ps);
  463.                                 /****SETTO I CARATTERI DA UTILIZZARE: FONT, DIMENSIONI ECC...**/
  464.                                 hfont = CreateFont (20,0,0,0, 500, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS,
  465.                 CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, VARIABLE_PITCH, TEXT ("Monotype Corsiva"));
  466.                             SelectObject (hdcWindow, hfont);
  467.                             SetRect (& rect, 100,100,700,200);
  468.                 SetTextColor (hdcWindow, RGB (0,0,0));
  469.  
  470.                                 TextOut(hdcWindow,0,0,"Selezionare il tipo di curva ed inserire i parametri.",55);
  471.                                 TextOut(hdcWindow,5,190,"Coefficiente A:",15);
  472.                                 TextOut(hdcWindow,5,215,"Coefficiente B:",15);
  473.                                 TextOut(hdcWindow,5,240,"Coefficiente C:",15);
  474.                                 TextOut(hdcWindow,5,150,"L'equazione è del tipo:",23);
  475.                                 EndPaint(hwnd,&ps);
  476.                                 break;
  477.             case WM_CREATE:
  478.                                 //ProgressBar
  479.                                 prog=CreateWindowEx(NULL, PROGRESS_CLASS, NULL, WS_CHILD|WS_VISIBLE, 215,200, 150, 30, hwnd, NULL, NULL, 0);
  480.                                 //Crea radio-button per decidere il tipo di curva:
  481.                                 radret=CreateWindow("Button","Retta",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,0,20,55,20,hwnd,(HMENU) 1,NULL,NULL);
  482.                                 radpar=CreateWindow("Button","Parabola (y)",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,0,45,110,20,hwnd,(HMENU) 2,NULL,NULL);
  483.                                 radipe=CreateWindow("Button","Iperbole",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,0,70,80,20,hwnd,(HMENU) 3,NULL,NULL);
  484.                                 radell=CreateWindow("Button","Ellisse",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,0,95,70,20,hwnd,(HMENU) 4,NULL,NULL);
  485.                                 radcir=CreateWindow("Button","Circonferenza",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,0,120,135,20,hwnd,(HMENU) 5,NULL,NULL);
  486.                                 radparx=CreateWindow("Button","Parabola (x)",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,120,45,110,20,hwnd,(HMENU) 6,NULL,NULL);
  487.                                 //Crea EditBox per inserire i parametri
  488.                                 edita=CreateWindow("Edit","",WS_CHILD|WS_VISIBLE|WS_BORDER,150,190,50,20,hwnd,NULL,NULL,NULL);
  489.                                 editb=CreateWindow("Edit","",WS_CHILD|WS_VISIBLE|WS_BORDER,150,215,50,20,hwnd,NULL,NULL,NULL);
  490.                                 editc=CreateWindow("Edit","",WS_CHILD|WS_VISIBLE|WS_BORDER,150,240,50,20,hwnd,NULL,NULL,NULL);
  491.                                 //Crea EditBox per mostrare la sintassi di una cura selezionata
  492.                                 sintax=CreateWindow("Edit","",WS_CHILD|WS_VISIBLE|WS_BORDER|ES_READONLY,200,150,190,20,hwnd,NULL,NULL,NULL);
  493.                                 //Crea il pulsante che permette di disegnare la curva selezionata.
  494.                                 paint=CreateWindow("Button","",WS_VISIBLE|WS_CHILD|BS_BITMAP|WS_BORDER,295,35,83,83,hwnd,(HMENU) 7, NULL,NULL);
  495.                                 SendMessage(paint,BM_SETIMAGE,IMAGE_BITMAP,(LPARAM)bmp);
  496.                                 /****SETTO I CARATTERI DA UTILIZZARE: FONT, DIMENSIONI ECC...**/
  497.                                 GetObject (GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lf);
  498.                                 hfont = CreateFont (20,0,0,0, 500, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS,
  499.                 CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, VARIABLE_PITCH, TEXT ("Monotype Corsiva"));
  500.                                 SendMessage (edita, WM_SETFONT, (WPARAM) hfont, true);
  501.                                 SendMessage (editb, WM_SETFONT, (WPARAM) hfont, true);
  502.                                 SendMessage (editc, WM_SETFONT, (WPARAM) hfont, true);  
  503.                                 SendMessage (radret, WM_SETFONT, (WPARAM) hfont, true);
  504.                                 SendMessage (radpar, WM_SETFONT, (WPARAM) hfont, true);
  505.                                 SendMessage (radipe, WM_SETFONT, (WPARAM) hfont, true);  
  506.                                 SendMessage (radell, WM_SETFONT, (WPARAM) hfont, true);
  507.                                 SendMessage (radcir, WM_SETFONT, (WPARAM) hfont, true);  
  508.                                 SendMessage (radparx, WM_SETFONT, (WPARAM) hfont, true);
  509.                                 SendMessage (sintax, WM_SETFONT, (WPARAM) hfont, true);
  510.                                 /*TOOLTIP*/
  511.                                 hwtoll=CreateWindowEx(NULL, TOOLTIPS_CLASS, NULL,WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,0,0,0,0,paint, NULL, NULL,NULL);
  512.                                 SetWindowPos (hwtoll, HWND_TOPMOST, 0, 0, 0, 0,SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
  513.                                 GetClientRect (paint, &rect);
  514.                                 ////////////////////////////////// FORMATTAZIONE TOOLTIP
  515.                                 ti.cbSize = sizeof(TOOLINFO);
  516.                                 ti.uFlags = TTF_SUBCLASS;
  517.                                 ti.hwnd = paint;
  518.                                 ti.hinst = NULL;
  519.                                 ti.uId = 0;
  520.                                 ti.lpszText = "Disegna!";
  521.                                 ti.rect.left = rect.left;    
  522.                                 ti.rect.top = rect.top;
  523.                                 ti.rect.right = rect.right;
  524.                                 ti.rect.bottom = rect.bottom;
  525.                                 //////////////////////////////////
  526.                                 SendMessage(hwtoll, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
  527.                 break;
  528.                         case WM_COMMAND:
  529.                                 if (LOWORD(wParam)==1)
  530.                                 {
  531.                                         SetWindowText(sintax,"Ax+By+C=0");   //Mostro la sintassi della curva
  532.                                         Edit_Enable(editc,TRUE);    //Abilita l'edit relativo al coefficiente C poichè contenuto nella sintassi dell'equazione
  533.                                 }
  534.                                 if (LOWORD(wParam)==2)
  535.                                 {
  536.                                         SetWindowText(sintax,"Ax²+Bx+C=y");  //Mostro la sintassi della curva
  537.                                         Edit_Enable(editc,TRUE);
  538.                                 }
  539.                                 if (LOWORD(wParam)==3)
  540.                                 {
  541.                                         SetWindowText(sintax,"(x²/A²)-(y²/B²)=1");  //Mostro la sintassi della curva
  542.                                         Edit_Enable(editc,FALSE); //DisAbilita l'edit relativo al coefficiente C poichè Non contenuto nella sintassi dell'equazione
  543.                                 }
  544.                                 if (LOWORD(wParam)==4)
  545.                                 {
  546.                                         SetWindowText(sintax,"(x²/A²)+(y²/B²)=1");  //Mostro la sintassi della curva
  547.                                         Edit_Enable(editc,FALSE);
  548.                                 }
  549.                                 if (LOWORD(wParam)==5)
  550.                                 {
  551.                                         SetWindowText(sintax,"(x-A)²+(y-B)²=C²");  //Mostro la sintassi della curva
  552.                                         Edit_Enable(editc,TRUE);
  553.                                 }
  554.                                 if (LOWORD(wParam)==6)
  555.                                 {
  556.                                         SetWindowText(sintax,"Ay²+By+C=x");  //Mostro la sintassi della curva
  557.                                         Edit_Enable(editc,TRUE);
  558.                                 }
  559.                                 if (LOWORD(wParam)==7)
  560.                                 {
  561.                                         bo++;
  562.                                         //Controllo stato radiobutton
  563.                                         selret=SendMessage(radret,BM_GETCHECK,0,0);
  564.                                         selpar=SendMessage(radpar,BM_GETCHECK,0,0);
  565.                                         selell=SendMessage(radell,BM_GETCHECK,0,0);
  566.                                         selipe=SendMessage(radipe,BM_GETCHECK,0,0);
  567.                                         selcir=SendMessage(radcir,BM_GETCHECK,0,0);
  568.                                         selparx=SendMessage(radparx,BM_GETCHECK,0,0);
  569.                                         //Nel caso sia selezionato il radiobutton....
  570.                                         if (selret==BST_CHECKED)
  571.                                         {
  572.                                                 agg++; //Incremento la variabile che permette alla WM_TIMER in MainWindow di disegnare la curva
  573.                                                 GetWindowText(edita,numa,5);  //Leggi il valore del paramtero a
  574.                                                 GetWindowText(editb,numb,5);  //Leggi il valore del paramtero b
  575.                                                 GetWindowText(editc,numc,5);  //Leggi il valore del paramtero c
  576.                                                 curva=1;                      //Curva 1 Vuol dire retta
  577.                                                 //Memorizza nell'array i vari valori dei coefficianti così da ridisegnarli
  578.                                                 ca[l]=atof(numa);
  579.                                                 cb[l]=atof(numb);
  580.                                                 cc[l]=atof(numc);
  581.                                                 l++;
  582.                                         }
  583.                                         if (selpar==BST_CHECKED)
  584.                                         {
  585.                                                 agg++; //Incremento la variabile che permette alla WM_TIMER in MainWindow di disegnare la curva
  586.                                                 GetWindowText(edita,numa,5);  //Leggi il valore del paramtero a
  587.                                                 GetWindowText(editb,numb,5);  //Leggi il valore del paramtero b
  588.                                                 GetWindowText(editc,numc,5);  //Leggi il valore del paramtero c
  589.                                                 curva=2;                      //Curva 2 Vuol dire parabola
  590.                                                 //Memorizza nell'array i vari valori dei coefficianti così da ridisegnarli
  591.                                                 da[l2]=atof(numa);
  592.                                                 db[l2]=atof(numb);
  593.                                                 dc[l2]=atof(numc);
  594.                                                 l2++;
  595.                                         }
  596.                                         if (selell==BST_CHECKED)
  597.                                         {
  598.                                                 agg++; //Incremento la variabile che permette alla WM_TIMER in MainWindow di disegnare la curva
  599.                                                 GetWindowText(edita,numa,5);  //Leggi il valore del paramtero a
  600.                                                 GetWindowText(editb,numb,5);  //Leggi il valore del paramtero b
  601.                                                 curva=3;                                                //Curva 3 Vuol dire ellisse
  602.                                                 //Memorizza nell'array i vari valori dei coefficianti così da ridisegnarli
  603.                                                 ea[l3]=atof(numa);
  604.                                                 eb[l3]=atof(numb);
  605.                                                 l3++;
  606.                                         }
  607.                                         if (selipe==BST_CHECKED)
  608.                                         {
  609.                                                 agg++; //Incremento la variabile che permette alla WM_TIMER in MainWindow di disegnare la curva
  610.                                                 GetWindowText(edita,numa,5);  //Leggi il valore del paramtero a
  611.                                                 GetWindowText(editb,numb,5);  //Leggi il valore del paramtero b
  612.                                                 curva=4;                     //Curva 4 Vuol dire iperbole
  613.                                                 //Memorizza nell'array i vari valori dei coefficianti così da ridisegnarli
  614.                                                 fa[l4]=atof(numa);
  615.                                                 fb[l4]=atof(numb);
  616.                                                 l4++;
  617.                                         }
  618.                                         if (selcir==BST_CHECKED)
  619.                                         {
  620.                                                 agg++; //Incremento la variabile che permette alla WM_TIMER in MainWindow di disegnare la curva
  621.                                                 GetWindowText(edita,numa,5);  //Leggi il valore del paramtero a
  622.                                                 GetWindowText(editb,numb,5);  //Leggi il valore del paramtero b
  623.                                                 GetWindowText(editc,numc,5);  //Leggi il valore del paramtero c
  624.                                                 curva=5;                      //Curva 5 Vuol dire circonferenza
  625.                                                 //Memorizza nell'array i vari valori dei coefficianti così da ridisegnarli
  626.                                                 ga[l5]=atof(numa);
  627.                                                 gb[l5]=atof(numb);
  628.                                                 gc[l5]=atof(numc);
  629.                                                 l5++;
  630.                                         }
  631.                                         if (selparx==BST_CHECKED)
  632.                                         {
  633.                                                 agg++; //Incremento la variabile che permette alla WM_TIMER in MainWindow di disegnare la curva
  634.                                                 GetWindowText(edita,numa,5);  //Leggi il valore del paramtero a
  635.                                                 GetWindowText(editb,numb,5);  //Leggi il valore del paramtero b
  636.                                                 GetWindowText(editc,numc,5);  //Leggi il valore del paramtero c
  637.                                                 curva=6;                      //Curva 6 Vuol dire parabola con asse parallello all'asse x
  638.                                                 //Memorizza nell'array i vari valori dei coefficianti così da ridisegnarli
  639.                                                 ha[l6]=atof(numa);
  640.                                                 hb[l6]=atof(numb);
  641.                                                 hc[l6]=atof(numc);
  642.                                                 l6++;
  643.                                         }
  644.                                         if((selret!=BST_CHECKED) &&  (selpar!=BST_CHECKED) && (selipe!=BST_CHECKED) && (selell!=BST_CHECKED) && (selcir!=BST_CHECKED) && (selparx!=BST_CHECKED)) //Se non è selezionata alcuna curva:
  645.                                         {
  646.                                                 MessageBox(hwnd,"Selezionare una curva","Avviso!",MB_OK);
  647.                                         }
  648.                                 }
  649.                                 break;
  650.             case WM_DESTROY:
  651.                 PostQuitMessage (0);    
  652.                 break;
  653.             default:                  
  654.                 return DefWindowProc (hwnd, message, wParam, lParam);
  655.         }
  656.         return 0;
  657. }
  658. //VARIABILI:
  659. //HWND della finestra:
  660. HWND hwndTrack,sinistra,destra,save,cancel;
  661. //WndProc della finestra delle Impostazioni.
  662. LRESULT CALLBACK WindowProcedure4 (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  663. {      
  664.         InitCommonControls ();     //Applicazione visual style
  665.         switch(message)
  666.         {
  667.                 case WM_CREATE:
  668.                         //Salva-Annulla
  669.                         save=CreateWindow("Button","Salva",WS_VISIBLE|WS_CHILD,10,140,80,30,hwnd,(HMENU) 5,NULL,NULL);
  670.                         cancel=CreateWindow("Button","Annulla",WS_VISIBLE|WS_CHILD,300,140,80,30,hwnd,(HMENU) 6,NULL,NULL);
  671.                         //TrackBar
  672.                         hwndTrack = CreateWindowEx(0,TRACKBAR_CLASS,"Trackbar Control",WS_CHILD|WS_VISIBLE|TBS_AUTOTICKS|TBS_ENABLESELRANGE,
  673.                         100,25,120,30,hwnd,(HMENU)3,NULL,NULL);
  674.                         //Static
  675.                         sinistra=CreateWindow("STATIC", "Approssimativo", WS_CHILD | WS_VISIBLE,0, 0, 100, 30,hwnd, (HMENU)1, NULL, NULL);
  676.                         destra=CreateWindow("STATIC", "Preciso", WS_CHILD | WS_VISIBLE,0, 0, 80, 30,hwnd, (HMENU)2, NULL, NULL);
  677.                         //Configuro la TrackBar
  678.                         SendMessage(hwndTrack, TBM_SETRANGE,  TRUE,  MAKELONG(100, 1000)); //Gradazione
  679.                         SendMessage(hwndTrack, TBM_SETPAGESIZE, 0,  20);  
  680.                         SendMessage(hwndTrack, TBM_SETTICFREQ, 100, 0); //Densità
  681.                         SendMessage(hwndTrack, TBM_SETPOS, FALSE, prec); //Posizione iniziale
  682.                         SendMessage(hwndTrack, TBM_SETBUDDY, TRUE, (LPARAM) sinistra); //Static di riferimento sinistro
  683.                         SendMessage(hwndTrack, TBM_SETBUDDY, FALSE, (LPARAM) destra); //Static di riferimento destro
  684.                         /****SETTO I CARATTERI DA UTILIZZARE: FONT, DIMENSIONI ECC...**/
  685.                         GetObject (GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lf);
  686.                         hfont = CreateFont (20,0,0,0, 500, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS,
  687.             CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, VARIABLE_PITCH, TEXT ("Monotype Corsiva"));
  688.                         SendMessage(save,WM_SETFONT,(WPARAM) hfont,true);
  689.                         SendMessage(cancel,WM_SETFONT,(WPARAM) hfont,true);
  690.                         SendMessage(sinistra,WM_SETFONT,(WPARAM) hfont,true);
  691.                         SendMessage(destra,WM_SETFONT,(WPARAM) hfont,true);
  692.                         break;
  693.                 case WM_PAINT:
  694.                         PAINTSTRUCT ps;
  695.                         HDC hdcWindow;
  696.                         hdcWindow = BeginPaint(hwnd, &ps);
  697.                         /****SETTO I CARATTERI DA UTILIZZARE: FONT, DIMENSIONI ECC...**/
  698.                         hfont = CreateFont (22,0,0,0, 500, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS,
  699.             CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, VARIABLE_PITCH, TEXT ("Monotype Corsiva"));
  700.                         SelectObject (hdcWindow, hfont);
  701.                         SetRect (& rect, 100,100,700,200);
  702.             SetTextColor (hdcWindow, RGB (0,0,0));
  703.                        
  704.                         TextOut(hdcWindow,10,70,"Regolare l'accuratezza delle funzioni.",38);
  705.                         TextOut(hdcWindow,10,100,"Più è accurato, più punti vengono disegnati.",45);
  706.  
  707.                         EndPaint(hwnd,&ps);
  708.                         break;
  709.                 case WM_COMMAND:
  710.                         if (LOWORD(wParam)==5)
  711.                         {
  712.                                 prec=SendMessage(hwndTrack,TBM_GETPOS,NULL,NULL);   //Carico l'ultima posizione
  713.                                 inc=1/prec;    //calcolo l'incremento
  714.                                 DestroyWindow(hwnd);   //Chiudo la finestra
  715.                         }
  716.                         if (LOWORD(wParam)==6)
  717.                         {
  718.                                 prec=preprec;    //Annullo una eventuale modifica
  719.                                 DestroyWindow(hwnd);   //Chiudo la finestra
  720.                         }
  721.                         break;
  722.                 case WM_DESTROY:
  723.                         PostQuitMessage(0);    
  724.                         break;
  725.                 default:
  726.                         return DefWindowProc(hwnd,message,wParam,lParam);
  727.         }
  728.         return 0;
  729. }
  730. //Creazione finestra principale/Dichiarazione di hinstance per le altre finestre.
  731. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nCmdShow)
  732. {
  733.    InitCommonControls ();      //Applicazione visual style
  734.    WNDCLASSEX WndClass,WndClass2,WndClass3,WndClass4,WndClass5;
  735.    HWND hwnd;
  736.    MSG Msg;
  737.    
  738.    g_hInst = hInstance;
  739.    //Main Window
  740.    WndClass.cbSize        = sizeof(WNDCLASSEX);
  741.    WndClass.style         = 0;
  742.    WndClass.lpfnWndProc   = WndProc;
  743.    WndClass.cbClsExtra    = 0;
  744.    WndClass.cbWndExtra    = 0;
  745.    WndClass.hInstance     = g_hInst;
  746.    WndClass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  747.    WndClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
  748.    WndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
  749.    WndClass.lpszMenuName  = NULL;
  750.    WndClass.lpszClassName = g_szClassName;
  751.    WndClass.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
  752.    //Curve Window
  753.    WndClass2.cbSize        = sizeof(WNDCLASSEX);
  754.    WndClass2.style         = 0;
  755.    WndClass2.lpfnWndProc   = WindowProcedure2;
  756.    WndClass2.cbClsExtra    = 0;
  757.    WndClass2.cbWndExtra    = 0;
  758.    WndClass2.hInstance     = hInstance;
  759.    WndClass2.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  760.    WndClass2.hCursor       = LoadCursor(NULL, IDC_ARROW);
  761.    WndClass2.hbrBackground = (HBRUSH)(COLOR_BTNFACE+0);
  762.    WndClass2.lpszMenuName  = NULL;
  763.    WndClass2.lpszClassName = name;
  764.    WndClass2.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
  765.    //Setting Window
  766.    WndClass4.cbSize        = sizeof(WNDCLASSEX);
  767.    WndClass4.style         = 0;
  768.    WndClass4.lpfnWndProc   = WindowProcedure4;
  769.    WndClass4.cbClsExtra    = 0;
  770.    WndClass4.cbWndExtra    = 0;
  771.    WndClass4.hInstance     = hInstance;
  772.    WndClass4.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  773.    WndClass4.hCursor       = LoadCursor(NULL, IDC_ARROW);
  774.    WndClass4.hbrBackground = (HBRUSH)(16);
  775.    WndClass4.lpszMenuName  = NULL;
  776.    WndClass4.lpszClassName = name3;
  777.    WndClass4.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
  778.  
  779.    //Main Window
  780.    if(!RegisterClassEx(&WndClass))
  781.    {
  782.       MessageBox(0, "Window1 Registration Failed!", "Error!",
  783.          MB_ICONEXCLAMATION | MB_OK | MB_SYSTEMMODAL);
  784.       return 0;
  785.    }
  786.    //Second Window
  787.     if(!RegisterClassEx(&WndClass2))
  788.    {
  789.       MessageBox(0, "Window2 Registration Failed!", "Error!",
  790.          MB_ICONEXCLAMATION | MB_OK | MB_SYSTEMMODAL);
  791.       return 0;
  792.    }
  793.    //Fourt Window
  794.     if(!RegisterClassEx(&WndClass4))
  795.    {
  796.       MessageBox(0, "Window4 Registration Failed!", "Error!",
  797.          MB_ICONEXCLAMATION | MB_OK | MB_SYSTEMMODAL);
  798.       return 0;
  799.    }
  800.    //CREAZIONE:
  801.    //Main Window
  802.    hwnd = CreateWindowEx(WS_EX_CLIENTEDGE,g_szClassName,"Paint XY",
  803.       WS_SYSMENU|WS_MINIMIZEBOX|WS_VISIBLE,
  804.       CW_USEDEFAULT, CW_USEDEFAULT, 1015, 1100,NULL, NULL, g_hInst, NULL);
  805.    if (hwnd == NULL)
  806.    {
  807.       MessageBox(0, "Window Creation Failed!", "Error!",
  808.          MB_ICONEXCLAMATION | MB_OK | MB_SYSTEMMODAL);
  809.       return 0;
  810.    }
  811.    //Visualizza Main Window
  812.    ShowWindow(hwnd, nCmdShow);
  813.    UpdateWindow(hwnd);
  814.    //Messaggio da Main Window
  815.    while(GetMessage(&Msg, NULL, 0, 0))
  816.    {
  817.       TranslateMessage(&Msg);
  818.       DispatchMessage(&Msg);
  819.    }
  820.    return Msg.wParam;
  821. }