ReactOS Fundraising Campaign 2012
 
€ 4,410 / € 30,000

Information | Donate

Home | Info | Community | Development | myReactOS | Contact Us

  1. Home
  2. Community
  3. Development
  4. myReactOS
  5. Fundraiser 2012

  1. Main Page
  2. Alphabetical List
  3. Data Structures
  4. Directories
  5. File List
  6. Data Fields
  7. Globals
  8. Related Pages

ReactOS Development > Doxygen

winproc.c
Go to the documentation of this file.
00001 /*
00002  * PROJECT:     PAINT for ReactOS
00003  * LICENSE:     LGPL
00004  * FILE:        base/applications/paint/winproc.c
00005  * PURPOSE:     Window procedure of the main window and all children apart from
00006  *              hPalWin, hToolSettings and hSelection
00007  * PROGRAMMERS: Benedikt Freisen
00008  */
00009 
00010 /* INCLUDES *********************************************************/
00011 
00012 //#include <htmlhelp.h>
00013 #include "precomp.h"
00014 
00015 /* FUNCTIONS ********************************************************/
00016 
00017 void
00018 selectTool(int tool)
00019 {
00020     ShowWindow(hSelection, SW_HIDE);
00021     activeTool = tool;
00022     pointSP = 0;                // resets the point-buffer of the polygon and bezier functions
00023     SendMessage(hToolSettings, WM_PAINT, 0, 0);
00024     ShowWindow(hTrackbarZoom, (tool == 6) ? SW_SHOW : SW_HIDE);
00025 }
00026 
00027 void
00028 updateCanvasAndScrollbars()
00029 {
00030     ShowWindow(hSelection, SW_HIDE);
00031     MoveWindow(hImageArea, 3, 3, imgXRes * zoom / 1000, imgYRes * zoom / 1000, FALSE);
00032     InvalidateRect(hScrollbox, NULL, TRUE);
00033     InvalidateRect(hImageArea, NULL, FALSE);
00034 
00035     SetScrollPos(hScrollbox, SB_HORZ, 0, TRUE);
00036     SetScrollPos(hScrollbox, SB_VERT, 0, TRUE);
00037 }
00038 
00039 void
00040 zoomTo(int newZoom, int mouseX, int mouseY)
00041 {
00042     int tbPos = 0;
00043     int tempZoom = newZoom;
00044 
00045     long clientRectScrollbox[4];
00046     long clientRectImageArea[4];
00047     int x, y, w, h;
00048     GetClientRect(hScrollbox, (LPRECT) &clientRectScrollbox);
00049     GetClientRect(hImageArea, (LPRECT) &clientRectImageArea);
00050     w = clientRectImageArea[2] * clientRectScrollbox[2] / (clientRectImageArea[2] * newZoom / zoom);
00051     h = clientRectImageArea[3] * clientRectScrollbox[3] / (clientRectImageArea[3] * newZoom / zoom);
00052     x = max(0, min(clientRectImageArea[2] - w, mouseX - w / 2)) * newZoom / zoom;
00053     y = max(0, min(clientRectImageArea[3] - h, mouseY - h / 2)) * newZoom / zoom;
00054 
00055     zoom = newZoom;
00056 
00057     ShowWindow(hSelection, SW_HIDE);
00058     MoveWindow(hImageArea, 3, 3, imgXRes * zoom / 1000, imgYRes * zoom / 1000, FALSE);
00059     InvalidateRect(hScrollbox, NULL, TRUE);
00060     InvalidateRect(hImageArea, NULL, FALSE);
00061 
00062     SendMessage(hScrollbox, WM_HSCROLL, SB_THUMBPOSITION | (x << 16), 0);
00063     SendMessage(hScrollbox, WM_VSCROLL, SB_THUMBPOSITION | (y << 16), 0);
00064 
00065     while (tempZoom > 125)
00066     {
00067         tbPos++;
00068         tempZoom = tempZoom >> 1;
00069     }
00070     SendMessage(hTrackbarZoom, TBM_SETPOS, (WPARAM) TRUE, (LPARAM) tbPos);
00071 }
00072 
00073 void
00074 drawZoomFrame(int mouseX, int mouseY)
00075 {
00076     HDC hdc;
00077     HPEN oldPen;
00078     HBRUSH oldBrush;
00079     LOGBRUSH logbrush;
00080     int rop;
00081 
00082     long clientRectScrollbox[4];
00083     long clientRectImageArea[4];
00084     int x, y, w, h;
00085     GetClientRect(hScrollbox, (LPRECT) &clientRectScrollbox);
00086     GetClientRect(hImageArea, (LPRECT) &clientRectImageArea);
00087     w = clientRectImageArea[2] * clientRectScrollbox[2] / (clientRectImageArea[2] * 2);
00088     h = clientRectImageArea[3] * clientRectScrollbox[3] / (clientRectImageArea[3] * 2);
00089     x = max(0, min(clientRectImageArea[2] - w, mouseX - w / 2));
00090     y = max(0, min(clientRectImageArea[3] - h, mouseY - h / 2));
00091 
00092     hdc = GetDC(hImageArea);
00093     oldPen = SelectObject(hdc, CreatePen(PS_SOLID, 0, 0));
00094     logbrush.lbStyle = BS_HOLLOW;
00095     oldBrush = SelectObject(hdc, CreateBrushIndirect(&logbrush));
00096     rop = SetROP2(hdc, R2_NOT);
00097     Rectangle(hdc, x, y, x + w, y + h);
00098     SetROP2(hdc, rop);
00099     DeleteObject(SelectObject(hdc, oldBrush));
00100     DeleteObject(SelectObject(hdc, oldPen));
00101     ReleaseDC(hImageArea, hdc);
00102 }
00103 
00104 void
00105 alignChildrenToMainWindow()
00106 {
00107     int x, y, w, h;
00108     RECT clientRect;
00109     GetClientRect(hMainWnd, &clientRect);
00110 
00111     if (IsWindowVisible(hToolBoxContainer))
00112     {
00113         x = 56;
00114         w = clientRect.right - 56;
00115     }
00116     else
00117     {
00118         x = 0;
00119         w = clientRect.right;
00120     }
00121     if (IsWindowVisible(hPalWin))
00122     {
00123         y = 49;
00124         h = clientRect.bottom - 49;
00125     }
00126     else
00127     {
00128         y = 3;
00129         h = clientRect.bottom - 3;
00130     }
00131 
00132     MoveWindow(hScrollbox, x, y, w, IsWindowVisible(hStatusBar) ? h - 23 : h, TRUE);
00133     MoveWindow(hPalWin, x, 9, 255, 32, TRUE);
00134 }
00135 
00136 BOOL drawing;
00137 
00138 LRESULT CALLBACK
00139 WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
00140 {
00141     switch (message)            /* handle the messages */
00142     {
00143         case WM_CREATE:
00144             ptStack = NULL;
00145             ptSP = 0;
00146             break;
00147 
00148         case WM_DESTROY:
00149             PostQuitMessage(0); /* send a WM_QUIT to the message queue */
00150             break;
00151 
00152         case WM_CLOSE:
00153             if (hwnd == hwndMiniature)
00154             {
00155                 ShowWindow(hwndMiniature, SW_HIDE);
00156                 showMiniature = FALSE;
00157                 break;
00158             }
00159             if (!imageSaved)
00160             {
00161                 TCHAR programname[20];
00162                 TCHAR saveprompttext[100];
00163                 TCHAR temptext[500];
00164                 LoadString(hProgInstance, IDS_PROGRAMNAME, programname, SIZEOF(programname));
00165                 LoadString(hProgInstance, IDS_SAVEPROMPTTEXT, saveprompttext, SIZEOF(saveprompttext));
00166                 _stprintf(temptext, saveprompttext, filename);
00167                 switch (MessageBox(hwnd, temptext, programname, MB_YESNOCANCEL | MB_ICONQUESTION))
00168                 {
00169                     case IDNO:
00170                         DestroyWindow(hwnd);
00171                         break;
00172                     case IDYES:
00173                         SendMessage(hwnd, WM_COMMAND, IDM_FILESAVEAS, 0);
00174                         DestroyWindow(hwnd);
00175                         break;
00176                 }
00177             }
00178             else
00179             {
00180                 DestroyWindow(hwnd);
00181             }
00182             break;
00183 
00184         case WM_INITMENUPOPUP:
00185             switch (lParam)
00186             {
00187                 case 0:
00188                     if (isAFile)
00189                     {
00190                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERPLANE,
00191                                        MF_ENABLED | MF_BYCOMMAND);
00192                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERCENTERED,
00193                                        MF_ENABLED | MF_BYCOMMAND);
00194                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERSTRETCHED,
00195                                        MF_ENABLED | MF_BYCOMMAND);
00196                     }
00197                     else
00198                     {
00199                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERPLANE,
00200                                        MF_GRAYED | MF_BYCOMMAND);
00201                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERCENTERED,
00202                                        MF_GRAYED | MF_BYCOMMAND);
00203                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERSTRETCHED,
00204                                        MF_GRAYED | MF_BYCOMMAND);
00205                     }
00206                     break;
00207                 case 1:
00208                     EnableMenuItem(GetMenu(hMainWnd), IDM_EDITUNDO,
00209                                    (undoSteps > 0) ? (MF_ENABLED | MF_BYCOMMAND) : (MF_GRAYED | MF_BYCOMMAND));
00210                     EnableMenuItem(GetMenu(hMainWnd), IDM_EDITREDO,
00211                                    (redoSteps > 0) ? (MF_ENABLED | MF_BYCOMMAND) : (MF_GRAYED | MF_BYCOMMAND));
00212                     if (IsWindowVisible(hSelection))
00213                     {
00214                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCUT, MF_ENABLED | MF_BYCOMMAND);
00215                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCOPY, MF_ENABLED | MF_BYCOMMAND);
00216                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITDELETESELECTION, MF_ENABLED | MF_BYCOMMAND);
00217                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITINVERTSELECTION, MF_ENABLED | MF_BYCOMMAND);
00218                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCOPYTO, MF_ENABLED | MF_BYCOMMAND);
00219                     }
00220                     else
00221                     {
00222                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCUT, MF_GRAYED | MF_BYCOMMAND);
00223                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCOPY, MF_GRAYED | MF_BYCOMMAND);
00224                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITDELETESELECTION, MF_GRAYED | MF_BYCOMMAND);
00225                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITINVERTSELECTION, MF_GRAYED | MF_BYCOMMAND);
00226                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCOPYTO, MF_GRAYED | MF_BYCOMMAND);
00227                     }
00228                     OpenClipboard(hMainWnd);
00229                     if (GetClipboardData(CF_BITMAP) != NULL)
00230                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITPASTE, MF_ENABLED | MF_BYCOMMAND);
00231                     else
00232                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITPASTE, MF_GRAYED | MF_BYCOMMAND);
00233                     CloseClipboard();
00234                     break;
00235                 case 3:
00236                     if (IsWindowVisible(hSelection))
00237                         EnableMenuItem(GetMenu(hMainWnd), IDM_IMAGECROP, MF_ENABLED | MF_BYCOMMAND);
00238                     else
00239                         EnableMenuItem(GetMenu(hMainWnd), IDM_IMAGECROP, MF_GRAYED | MF_BYCOMMAND);
00240                     CheckMenuItem(GetMenu(hMainWnd), IDM_IMAGEDRAWOPAQUE, (transpBg == 0) ?
00241                                   (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00242                     break;
00243             }
00244             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWTOOLBOX,
00245                           IsWindowVisible(hToolBoxContainer) ?
00246                               (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00247             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWCOLORPALETTE,
00248                           IsWindowVisible(hPalWin) ?
00249                               (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00250             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWSTATUSBAR,
00251                           IsWindowVisible(hStatusBar) ?
00252                               (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00253 
00254             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWSHOWGRID,
00255                           showGrid ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00256             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWSHOWMINIATURE,
00257                           showMiniature ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00258 
00259             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM125,
00260                           (zoom == 125) ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00261             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM25,
00262                           (zoom == 250) ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00263             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM50,
00264                           (zoom == 500) ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00265             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM100,
00266                           (zoom == 1000) ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00267             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM200,
00268                           (zoom == 2000) ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00269             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM400,
00270                           (zoom == 4000) ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00271             CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM800,
00272                           (zoom == 8000) ? (MF_CHECKED | MF_BYCOMMAND) : (MF_UNCHECKED | MF_BYCOMMAND));
00273 
00274             break;
00275 
00276         case WM_SIZE:
00277             if (hwnd == hMainWnd)
00278             {
00279                 int test[] = { LOWORD(lParam) - 260, LOWORD(lParam) - 140, LOWORD(lParam) - 20 };
00280                 SendMessage(hStatusBar, WM_SIZE, wParam, lParam);
00281                 SendMessage(hStatusBar, SB_SETPARTS, 3, (LPARAM)&test);
00282                 alignChildrenToMainWindow();
00283             }
00284             if (hwnd == hImageArea)
00285             {
00286                 MoveWindow(hSizeboxLeftTop,
00287                            0,
00288                            0, 3, 3, TRUE);
00289                 MoveWindow(hSizeboxCenterTop,
00290                            imgXRes * zoom / 2000 + 3 * 3 / 4,
00291                            0, 3, 3, TRUE);
00292                 MoveWindow(hSizeboxRightTop,
00293                            imgXRes * zoom / 1000 + 3,
00294                            0, 3, 3, TRUE);
00295                 MoveWindow(hSizeboxLeftCenter,
00296                            0,
00297                            imgYRes * zoom / 2000 + 3 * 3 / 4, 3, 3, TRUE);
00298                 MoveWindow(hSizeboxRightCenter,
00299                            imgXRes * zoom / 1000 + 3,
00300                            imgYRes * zoom / 2000 + 3 * 3 / 4, 3, 3, TRUE);
00301                 MoveWindow(hSizeboxLeftBottom,
00302                            0,
00303                            imgYRes * zoom / 1000 + 3, 3, 3, TRUE);
00304                 MoveWindow(hSizeboxCenterBottom,
00305                            imgXRes * zoom / 2000 + 3 * 3 / 4,
00306                            imgYRes * zoom / 1000 + 3, 3, 3, TRUE);
00307                 MoveWindow(hSizeboxRightBottom,
00308                            imgXRes * zoom / 1000 + 3,
00309                            imgYRes * zoom / 1000 + 3, 3, 3, TRUE);
00310             }
00311             if ((hwnd == hImageArea) || (hwnd == hScrollbox))
00312             {
00313                 long clientRectScrollbox[4];
00314                 long clientRectImageArea[4];
00315                 SCROLLINFO si;
00316                 GetClientRect(hScrollbox, (LPRECT) &clientRectScrollbox);
00317                 GetClientRect(hImageArea, (LPRECT) &clientRectImageArea);
00318                 si.cbSize = sizeof(SCROLLINFO);
00319                 si.fMask  = SIF_PAGE | SIF_RANGE;
00320                 si.nMax   = clientRectImageArea[2] + 6 - 1;
00321                 si.nMin   = 0;
00322                 si.nPage  = clientRectScrollbox[2];
00323                 SetScrollInfo(hScrollbox, SB_HORZ, &si, TRUE);
00324                 GetClientRect(hScrollbox, (LPRECT) clientRectScrollbox);
00325                 si.nMax   = clientRectImageArea[3] + 6 - 1;
00326                 si.nPage  = clientRectScrollbox[3];
00327                 SetScrollInfo(hScrollbox, SB_VERT, &si, TRUE);
00328                 MoveWindow(hScrlClient,
00329                            -GetScrollPos(hScrollbox, SB_HORZ), -GetScrollPos(hScrollbox, SB_VERT),
00330                            max(clientRectImageArea[2] + 6, clientRectScrollbox[2]),
00331                            max(clientRectImageArea[3] + 6, clientRectScrollbox[3]), TRUE);
00332             }
00333             break;
00334 
00335         case WM_HSCROLL:
00336             if (hwnd == hScrollbox)
00337             {
00338                 SCROLLINFO si;
00339                 si.cbSize = sizeof(SCROLLINFO);
00340                 si.fMask = SIF_ALL;
00341                 GetScrollInfo(hScrollbox, SB_HORZ, &si);
00342                 switch (LOWORD(wParam))
00343                 {
00344                     case SB_THUMBTRACK:
00345                     case SB_THUMBPOSITION:
00346                         si.nPos = HIWORD(wParam);
00347                         break;
00348                     case SB_LINELEFT:
00349                         si.nPos -= 5;
00350                         break;
00351                     case SB_LINERIGHT:
00352                         si.nPos += 5;
00353                         break;
00354                     case SB_PAGELEFT:
00355                         si.nPos -= si.nPage;
00356                         break;
00357                     case SB_PAGERIGHT:
00358                         si.nPos += si.nPage;
00359                         break;
00360                 }
00361                 SetScrollInfo(hScrollbox, SB_HORZ, &si, TRUE);
00362                 MoveWindow(hScrlClient, -GetScrollPos(hScrollbox, SB_HORZ),
00363                            -GetScrollPos(hScrollbox, SB_VERT), imgXRes * zoom / 1000 + 6,
00364                            imgYRes * zoom / 1000 + 6, TRUE);
00365             }
00366             break;
00367 
00368         case WM_VSCROLL:
00369             if (hwnd == hScrollbox)
00370             {
00371                 SCROLLINFO si;
00372                 si.cbSize = sizeof(SCROLLINFO);
00373                 si.fMask = SIF_ALL;
00374                 GetScrollInfo(hScrollbox, SB_VERT, &si);
00375                 switch (LOWORD(wParam))
00376                 {
00377                     case SB_THUMBTRACK:
00378                     case SB_THUMBPOSITION:
00379                         si.nPos = HIWORD(wParam);
00380                         break;
00381                     case SB_LINEUP:
00382                         si.nPos -= 5;
00383                         break;
00384                     case SB_LINEDOWN:
00385                         si.nPos += 5;
00386                         break;
00387                     case SB_PAGEUP:
00388                         si.nPos -= si.nPage;
00389                         break;
00390                     case SB_PAGEDOWN:
00391                         si.nPos += si.nPage;
00392                         break;
00393                 }
00394                 SetScrollInfo(hScrollbox, SB_VERT, &si, TRUE);
00395                 MoveWindow(hScrlClient, -GetScrollPos(hScrollbox, SB_HORZ),
00396                            -GetScrollPos(hScrollbox, SB_VERT), imgXRes * zoom / 1000 + 6,
00397                            imgYRes * zoom / 1000 + 6, TRUE);
00398             }
00399             break;
00400 
00401         case WM_GETMINMAXINFO:
00402             if (hwnd == hMainWnd)
00403             {
00404                 MINMAXINFO *mm = (LPMINMAXINFO) lParam;
00405                 (*mm).ptMinTrackSize.x = 330;
00406                 (*mm).ptMinTrackSize.y = 430;
00407             }
00408             break;
00409 
00410         case WM_PAINT:
00411             DefWindowProc(hwnd, message, wParam, lParam);
00412             if (hwnd == hImageArea)
00413             {
00414                 HDC hdc = GetDC(hImageArea);
00415                 StretchBlt(hdc, 0, 0, imgXRes * zoom / 1000, imgYRes * zoom / 1000, hDrawingDC, 0, 0, imgXRes,
00416                            imgYRes, SRCCOPY);
00417                 if (showGrid && (zoom >= 4000))
00418                 {
00419                     HPEN oldPen = SelectObject(hdc, CreatePen(PS_SOLID, 1, 0x00a0a0a0));
00420                     int counter;
00421                     for(counter = 0; counter <= imgYRes; counter++)
00422                     {
00423                         MoveToEx(hdc, 0, counter * zoom / 1000, NULL);
00424                         LineTo(hdc, imgXRes * zoom / 1000, counter * zoom / 1000);
00425                     }
00426                     for(counter = 0; counter <= imgXRes; counter++)
00427                     {
00428                         MoveToEx(hdc, counter * zoom / 1000, 0, NULL);
00429                         LineTo(hdc, counter * zoom / 1000, imgYRes * zoom / 1000);
00430                     }
00431                     DeleteObject(SelectObject(hdc, oldPen));
00432                 }
00433                 ReleaseDC(hImageArea, hdc);
00434                 SendMessage(hSelection, WM_PAINT, 0, 0);
00435                 SendMessage(hwndMiniature, WM_PAINT, 0, 0);
00436             }
00437             else if (hwnd == hwndMiniature)
00438             {
00439                 RECT mclient;
00440                 HDC hdc;
00441                 GetClientRect(hwndMiniature, &mclient);
00442                 hdc = GetDC(hwndMiniature);
00443                 StretchBlt(hdc, 0, 0, mclient.right, mclient.bottom, hDrawingDC, 0, 0, imgXRes, imgYRes, SRCCOPY);
00444                 ReleaseDC(hwndMiniature, hdc);
00445             }
00446             break;
00447 
00448             // mouse events used for drawing   
00449 
00450         case WM_SETCURSOR:
00451             if (hwnd == hImageArea)
00452             {
00453                 switch (activeTool)
00454                 {
00455                     case TOOL_FILL:
00456                         SetCursor(hCurFill);
00457                         break;
00458                     case TOOL_COLOR:
00459                         SetCursor(hCurColor);
00460                         break;
00461                     case TOOL_ZOOM:
00462                         SetCursor(hCurZoom);
00463                         break;
00464                     case TOOL_PEN:
00465                         SetCursor(hCurPen);
00466                         break;
00467                     case TOOL_AIRBRUSH:
00468                         SetCursor(hCurAirbrush);
00469                         break;
00470                     default:
00471                         SetCursor(LoadCursor(NULL, IDC_CROSS));
00472                 }
00473             }
00474             else
00475                 DefWindowProc(hwnd, message, wParam, lParam);
00476             break;
00477 
00478         case WM_LBUTTONDOWN:
00479             if (hwnd == hImageArea)
00480             {
00481                 if ((!drawing) || (activeTool == TOOL_COLOR))
00482                 {
00483                     SetCapture(hImageArea);
00484                     drawing = TRUE;
00485                     startPaintingL(hDrawingDC, GET_X_LPARAM(lParam) * 1000 / zoom, GET_Y_LPARAM(lParam) * 1000 / zoom,
00486                                    fgColor, bgColor);
00487                 }
00488                 else
00489                 {
00490                     SendMessage(hwnd, WM_LBUTTONUP, wParam, lParam);
00491                     undo();
00492                 }
00493                 SendMessage(hImageArea, WM_PAINT, 0, 0);
00494                 if ((activeTool == TOOL_ZOOM) && (zoom < 8000))
00495                     zoomTo(zoom * 2, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
00496             }
00497             break;
00498 
00499         case WM_RBUTTONDOWN:
00500             if (hwnd == hImageArea)
00501             {
00502                 if ((!drawing) || (activeTool == TOOL_COLOR))
00503                 {
00504                     SetCapture(hImageArea);
00505                     drawing = TRUE;
00506                     startPaintingR(hDrawingDC, GET_X_LPARAM(lParam) * 1000 / zoom, GET_Y_LPARAM(lParam) * 1000 / zoom,
00507                                    fgColor, bgColor);
00508                 }
00509                 else
00510                 {
00511                     SendMessage(hwnd, WM_RBUTTONUP, wParam, lParam);
00512                     undo();
00513                 }
00514                 SendMessage(hImageArea, WM_PAINT, 0, 0);
00515                 if ((activeTool == TOOL_ZOOM) && (zoom > 125))
00516                     zoomTo(zoom / 2, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
00517             }
00518             break;
00519 
00520         case WM_LBUTTONUP:
00521             if ((hwnd == hImageArea) && drawing)
00522             {
00523                 ReleaseCapture();
00524                 drawing = FALSE;
00525                 endPaintingL(hDrawingDC, GET_X_LPARAM(lParam) * 1000 / zoom, GET_Y_LPARAM(lParam) * 1000 / zoom, fgColor,
00526                              bgColor);
00527                 SendMessage(hImageArea, WM_PAINT, 0, 0);
00528                 if (activeTool == TOOL_COLOR)
00529                 {
00530                     int tempColor =
00531                         GetPixel(hDrawingDC, GET_X_LPARAM(lParam) * 1000 / zoom, GET_Y_LPARAM(lParam) * 1000 / zoom);
00532                     if (tempColor != CLR_INVALID)
00533                         fgColor = tempColor;
00534                     SendMessage(hPalWin, WM_PAINT, 0, 0);
00535                 }
00536                 SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) "");
00537             }
00538             break;
00539 
00540         case WM_RBUTTONUP:
00541             if ((hwnd == hImageArea) && drawing)
00542             {
00543                 ReleaseCapture();
00544                 drawing = FALSE;
00545                 endPaintingR(hDrawingDC, GET_X_LPARAM(lParam) * 1000 / zoom, GET_Y_LPARAM(lParam) * 1000 / zoom, fgColor,
00546                              bgColor);
00547                 SendMessage(hImageArea, WM_PAINT, 0, 0);
00548                 if (activeTool == TOOL_COLOR)
00549                 {
00550                     int tempColor =
00551                         GetPixel(hDrawingDC, GET_X_LPARAM(lParam) * 1000 / zoom, GET_Y_LPARAM(lParam) * 1000 / zoom);
00552                     if (tempColor != CLR_INVALID)
00553                         bgColor = tempColor;
00554                     SendMessage(hPalWin, WM_PAINT, 0, 0);
00555                 }
00556                 SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) "");
00557             }
00558             break;
00559 
00560         case WM_KEYDOWN:
00561             if (wParam == VK_ESCAPE)
00562             {
00563                 if (!drawing)
00564                 {
00565                     /* Deselect */
00566                     if ((activeTool == TOOL_RECTSEL) || (activeTool == TOOL_FREESEL))
00567                     {
00568                         startPaintingL(hDrawingDC, 0, 0, fgColor, bgColor);
00569                         whilePaintingL(hDrawingDC, 0, 0, fgColor, bgColor);
00570                         endPaintingL(hDrawingDC, 0, 0, fgColor, bgColor);
00571                         ShowWindow(hSelection, SW_HIDE);
00572                     }
00573                 }
00574                 /* FIXME: also cancel current drawing underway */
00575             }
00576             break;
00577 
00578         case WM_MOUSEMOVE:
00579             if (hwnd == hImageArea)
00580             {
00581                 LONG xNow = GET_X_LPARAM(lParam) * 1000 / zoom;
00582                 LONG yNow = GET_Y_LPARAM(lParam) * 1000 / zoom;
00583                 if ((!drawing) || (activeTool <= TOOL_AIRBRUSH))
00584                 {
00585                     TRACKMOUSEEVENT tme;
00586 
00587                     if (activeTool == TOOL_ZOOM)
00588                     {
00589                         SendMessage(hImageArea, WM_PAINT, 0, 0);
00590                         drawZoomFrame(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
00591                     }
00592 
00593                     tme.cbSize = sizeof(TRACKMOUSEEVENT);
00594                     tme.dwFlags = TME_LEAVE;
00595                     tme.hwndTrack = hImageArea;
00596                     tme.dwHoverTime = 0;
00597                     TrackMouseEvent(&tme);
00598 
00599                     if (!drawing)
00600                     {
00601                         TCHAR coordStr[100];
00602                         _stprintf(coordStr, _T("%d, %d"), xNow, yNow);
00603                         SendMessage(hStatusBar, SB_SETTEXT, 1, (LPARAM) coordStr);
00604                     }
00605                 }
00606                 if (drawing)
00607                 {
00608                     /* values displayed in statusbar */
00609                     LONG xRel = xNow - startX;
00610                     LONG yRel = yNow - startY;
00611                     /* freesel, rectsel and text tools always show numbers limited to fit into image area */
00612                     if ((activeTool == TOOL_FREESEL) || (activeTool == TOOL_RECTSEL) || (activeTool == TOOL_TEXT))
00613                     {
00614                         if (xRel < 0)
00615                             xRel = (xNow < 0) ? -startX : xRel;
00616                         else if (xNow > imgXRes)
00617                             xRel = imgXRes-startX;
00618                         if (yRel < 0)
00619                             yRel = (yNow < 0) ? -startY : yRel;
00620                         else if (yNow > imgYRes)
00621                              yRel = imgYRes-startY;
00622                     }
00623                     /* rectsel and shape tools always show non-negative numbers when drawing */
00624                     if ((activeTool == TOOL_RECTSEL) || (activeTool == TOOL_SHAPE))
00625                     {
00626                         if (xRel < 0)
00627                             xRel = -xRel;
00628                         if (yRel < 0)
00629                             yRel =  -yRel;
00630                     }
00631                     /* while drawing, update cursor coordinates only for tools 3, 7, 8, 9, 14 */
00632                     switch(activeTool)
00633                     {
00634                         case TOOL_RUBBER:
00635                         case TOOL_PEN:
00636                         case TOOL_BRUSH:
00637                         case TOOL_AIRBRUSH:
00638                         case TOOL_SHAPE:
00639                         {
00640                             TCHAR coordStr[100];
00641                             _stprintf(coordStr, _T("%d, %d"), xNow, yNow);
00642                             SendMessage(hStatusBar, SB_SETTEXT, 1, (LPARAM) coordStr);
00643                             break;
00644                         }
00645                     }
00646                     if ((wParam & MK_LBUTTON) != 0)
00647                     {
00648                         whilePaintingL(hDrawingDC, xNow, yNow, fgColor, bgColor);
00649                         SendMessage(hImageArea, WM_PAINT, 0, 0);
00650                         if ((activeTool >= TOOL_TEXT) || (activeTool == TOOL_RECTSEL) || (activeTool == TOOL_FREESEL))
00651                         {
00652                             TCHAR sizeStr[100];
00653                             if ((activeTool >= TOOL_LINE) && (GetAsyncKeyState(VK_SHIFT) < 0))
00654                                 yRel = xRel;
00655                             _stprintf(sizeStr, _T("%d x %d"), xRel, yRel);
00656                             SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) sizeStr);
00657                         }
00658                     }
00659                     if ((wParam & MK_RBUTTON) != 0)
00660                     {
00661                         whilePaintingR(hDrawingDC, xNow, yNow, fgColor, bgColor);
00662                         SendMessage(hImageArea, WM_PAINT, 0, 0);
00663                         if (activeTool >= TOOL_TEXT)
00664                         {
00665                             TCHAR sizeStr[100];
00666                             if ((activeTool >= TOOL_LINE) && (GetAsyncKeyState(VK_SHIFT) < 0))
00667                                 yRel = xRel;
00668                             _stprintf(sizeStr, _T("%d x %d"), xRel, yRel);
00669                             SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) sizeStr);
00670                         }
00671                     }
00672                 }
00673             }
00674             break;
00675 
00676         case WM_MOUSELEAVE:
00677             SendMessage(hStatusBar, SB_SETTEXT, 1, (LPARAM) _T(""));
00678             if (activeTool == TOOL_ZOOM)
00679                 SendMessage(hImageArea, WM_PAINT, 0, 0);
00680             break;
00681 
00682         // menu and button events
00683 
00684         case WM_SYSCOLORCHANGE:
00685         {
00686             /* Redirect message to common controls */
00687             HWND hToolbar = FindWindowEx(hToolBoxContainer, NULL, TOOLBARCLASSNAME, NULL);
00688             SendMessage(hToolbar, WM_SYSCOLORCHANGE, 0, 0);
00689             break;
00690         }
00691 
00692         case WM_COMMAND:
00693             switch (LOWORD(wParam))
00694             {
00695                 case IDM_HELPINFO:
00696                 {
00697                     HICON paintIcon = LoadIcon(hProgInstance, MAKEINTRESOURCE(IDI_APPICON));
00698                     TCHAR infotitle[100];
00699                     TCHAR infotext[200];
00700                     LoadString(hProgInstance, IDS_INFOTITLE, infotitle, SIZEOF(infotitle));
00701                     LoadString(hProgInstance, IDS_INFOTEXT, infotext, SIZEOF(infotext));
00702                     ShellAbout(hMainWnd, infotitle, infotext, paintIcon);
00703                     DeleteObject(paintIcon);
00704                     break;
00705                 }
00706                 case IDM_HELPHELPTOPICS:
00707                     //HtmlHelp(hMainWnd, "help\\Paint.chm", 0, 0);
00708                     break;
00709                 case IDM_FILEEXIT:
00710                     SendMessage(hwnd, WM_CLOSE, wParam, lParam);
00711                     break;
00712                 case IDM_FILENEW:
00713                     ShowWindow(hSelection, SW_HIDE);
00714                     clearHistory();
00715 
00716                     Rectangle(hDrawingDC, 0 - 1, 0 - 1, imgXRes + 1, imgYRes + 1);
00717                     SendMessage(hImageArea, WM_PAINT, 0, 0);
00718                     break;
00719                 case IDM_FILEOPEN:
00720                     if (GetOpenFileName(&ofn) != 0)
00721                     {
00722                         HBITMAP bmNew = NULL;
00723                         LoadDIBFromFile(&bmNew, ofn.lpstrFile, &fileTime, &fileSize, &fileHPPM, &fileVPPM);
00724                         if (bmNew != NULL)
00725                         {
00726                             TCHAR tempstr[1000];
00727                             TCHAR resstr[100];
00728                             insertReversible(bmNew);
00729                             updateCanvasAndScrollbars();
00730                             CopyMemory(filename, ofn.lpstrFileTitle, sizeof(filename));
00731                             CopyMemory(filepathname, ofn.lpstrFileTitle, sizeof(filepathname));
00732                             LoadString(hProgInstance, IDS_WINDOWTITLE, resstr, SIZEOF(resstr));
00733                             _stprintf(tempstr, resstr, filename);
00734                             SetWindowText(hMainWnd, tempstr);
00735                             clearHistory();
00736                             isAFile = TRUE;
00737                         }
00738                     }
00739                     break;
00740                 case IDM_FILESAVE:
00741                     if (isAFile)
00742                     {
00743                         SaveDIBToFile(hBms[currInd], filepathname, hDrawingDC, &fileTime, &fileSize, fileHPPM,
00744                                       fileVPPM);
00745                         imageSaved = TRUE;
00746                     }
00747                     else
00748                         SendMessage(hwnd, WM_COMMAND, IDM_FILESAVEAS, 0);
00749                     break;
00750                 case IDM_FILESAVEAS:
00751                     if (GetSaveFileName(&sfn) != 0)
00752                     {
00753                         TCHAR tempstr[1000];
00754                         TCHAR resstr[100];
00755                         SaveDIBToFile(hBms[currInd], sfn.lpstrFile, hDrawingDC, &fileTime, &fileSize,
00756                                       fileHPPM, fileVPPM);
00757                         CopyMemory(filename, sfn.lpstrFileTitle, sizeof(filename));
00758                         CopyMemory(filepathname, sfn.lpstrFile, sizeof(filepathname));
00759                         LoadString(hProgInstance, IDS_WINDOWTITLE, resstr, SIZEOF(resstr));
00760                         _stprintf(tempstr, resstr, filename);
00761                         SetWindowText(hMainWnd, tempstr);
00762                         isAFile = TRUE;
00763                         imageSaved = TRUE;
00764                     }
00765                     break;
00766                 case IDM_FILEASWALLPAPERPLANE:
00767                     SetWallpaper(filepathname, 1, 1);
00768                     break;
00769                 case IDM_FILEASWALLPAPERCENTERED:
00770                     SetWallpaper(filepathname, 1, 0);
00771                     break;
00772                 case IDM_FILEASWALLPAPERSTRETCHED:
00773                     SetWallpaper(filepathname, 2, 0);
00774                     break;
00775                 case IDM_EDITUNDO:
00776                     undo();
00777                     SendMessage(hImageArea, WM_PAINT, 0, 0);
00778                     break;
00779                 case IDM_EDITREDO:
00780                     redo();
00781                     SendMessage(hImageArea, WM_PAINT, 0, 0);
00782                     break;
00783                 case IDM_EDITCOPY:
00784                     OpenClipboard(hMainWnd);
00785                     EmptyClipboard();
00786                     SetClipboardData(CF_BITMAP, CopyImage(hSelBm, IMAGE_BITMAP, 0, 0, LR_COPYRETURNORG));
00787                     CloseClipboard();
00788                     break;
00789                 case IDM_EDITCUT:
00790                     /* Copy */
00791                     SendMessage(hwnd, WM_COMMAND, IDM_EDITCOPY, 0);
00792                     /* Delete selection */
00793                     SendMessage(hwnd, WM_COMMAND, IDM_EDITDELETESELECTION, 0);
00794                     break;
00795                 case IDM_EDITPASTE:
00796                     OpenClipboard(hMainWnd);
00797                     if (GetClipboardData(CF_BITMAP) != NULL)
00798                     {
00799                         HWND hToolbar = FindWindowEx(hToolBoxContainer, NULL, TOOLBARCLASSNAME, NULL);
00800                         SendMessage(hToolbar, TB_CHECKBUTTON, ID_RECTSEL, MAKELONG(TRUE, 0));
00801                         SendMessage(hwnd, WM_COMMAND, ID_RECTSEL, 0);
00802 
00803                         DeleteObject(SelectObject(hSelDC, hSelBm = CopyImage(GetClipboardData(CF_BITMAP),
00804                                                                              IMAGE_BITMAP, 0, 0,
00805                                                                              LR_COPYRETURNORG)));
00806                         newReversible();
00807                         rectSel_src[0] = rectSel_src[1] = rectSel_src[2] = rectSel_src[3] = 0;
00808                         rectSel_dest[0] = rectSel_dest[1] = 0;
00809                         rectSel_dest[2] = GetDIBWidth(hSelBm);
00810                         rectSel_dest[3] = GetDIBHeight(hSelBm);
00811                         BitBlt(hDrawingDC, rectSel_dest[0], rectSel_dest[1], rectSel_dest[2], rectSel_dest[3],
00812                                hSelDC, 0, 0, SRCCOPY);
00813                         placeSelWin();
00814                         ShowWindow(hSelection, SW_SHOW);
00815                     }
00816                     CloseClipboard();
00817                     break;
00818                 case IDM_EDITDELETESELECTION:
00819                 {
00820                     /* remove selection window and already painted content using undo(),
00821                     paint Rect for rectangular selections and Poly for freeform selections */
00822                     undo();
00823                     if (activeTool == TOOL_RECTSEL)
00824                     {
00825                         newReversible();
00826                         Rect(hDrawingDC, rectSel_dest[0], rectSel_dest[1], rectSel_dest[2] + rectSel_dest[0],
00827                              rectSel_dest[3] + rectSel_dest[1], bgColor, bgColor, 0, TRUE);
00828                     }
00829                     if (activeTool == TOOL_FREESEL)
00830                     {
00831                         newReversible();
00832                         Poly(hDrawingDC, ptStack, ptSP + 1, 0, 0, 2, 0, FALSE);
00833                     }
00834                     break;
00835                 }
00836                 case IDM_EDITSELECTALL:
00837                 {
00838                     HWND hToolbar = FindWindowEx(hToolBoxContainer, NULL, TOOLBARCLASSNAME, NULL);
00839                     SendMessage(hToolbar, TB_CHECKBUTTON, ID_RECTSEL, MAKELONG(TRUE, 0));
00840                     SendMessage(hwnd, WM_COMMAND, ID_RECTSEL, 0);
00841                     startPaintingL(hDrawingDC, 0, 0, fgColor, bgColor);
00842                     whilePaintingL(hDrawingDC, imgXRes, imgYRes, fgColor, bgColor);
00843                     endPaintingL(hDrawingDC, imgXRes, imgYRes, fgColor, bgColor);
00844                     break;
00845                 }
00846                 case IDM_EDITCOPYTO:
00847                     if (GetSaveFileName(&ofn) != 0)
00848                         SaveDIBToFile(hSelBm, ofn.lpstrFile, hDrawingDC, NULL, NULL, fileHPPM, fileVPPM);
00849                     break;
00850                 case IDM_COLORSEDITPALETTE:
00851                     if (ChooseColor(&choosecolor))
00852                     {
00853                         fgColor = choosecolor.rgbResult;
00854                         SendMessage(hPalWin, WM_PAINT, 0, 0);
00855                     }
00856                     break;
00857                 case IDM_IMAGEINVERTCOLORS:
00858                 {
00859                     RECT tempRect;
00860                     newReversible();
00861                     SetRect(&tempRect, 0, 0, imgXRes, imgYRes);
00862                     InvertRect(hDrawingDC, &tempRect);
00863                     SendMessage(hImageArea, WM_PAINT, 0, 0);
00864                     break;
00865                 }
00866                 case IDM_IMAGEDELETEIMAGE:
00867                     newReversible();
00868                     Rect(hDrawingDC, 0, 0, imgXRes, imgYRes, bgColor, bgColor, 0, TRUE);
00869                     SendMessage(hImageArea, WM_PAINT, 0, 0);
00870                     break;
00871                 case IDM_IMAGEROTATEMIRROR:
00872                     switch (mirrorRotateDlg())
00873                     {
00874                         case 1: /* flip horizontally */
00875                             if (IsWindowVisible(hSelection))
00876                             {
00877                                 SelectObject(hSelDC, hSelMask);
00878                                 StretchBlt(hSelDC, rectSel_dest[2] - 1, 0, -rectSel_dest[2], rectSel_dest[3], hSelDC,
00879                                            0, 0, rectSel_dest[2], rectSel_dest[3], SRCCOPY);
00880                                 SelectObject(hSelDC, hSelBm);
00881                                 StretchBlt(hSelDC, rectSel_dest[2] - 1, 0, -rectSel_dest[2], rectSel_dest[3], hSelDC,
00882                                            0, 0, rectSel_dest[2], rectSel_dest[3], SRCCOPY);
00883                                 /* force refresh of selection contents, used also in case 2 and case 4 */
00884                                 SendMessage(hSelection, WM_LBUTTONDOWN, 0, 0);
00885                                 SendMessage(hSelection, WM_MOUSEMOVE, 0, 0);
00886                                 SendMessage(hSelection, WM_LBUTTONUP, 0, 0);
00887                             }
00888                             else
00889                             {
00890                                 newReversible();
00891                                 StretchBlt(hDrawingDC, imgXRes - 1, 0, -imgXRes, imgYRes, hDrawingDC, 0, 0,
00892                                            imgXRes, imgYRes, SRCCOPY);
00893                                 SendMessage(hImageArea, WM_PAINT, 0, 0);
00894                             }
00895                             break;
00896                         case 2: /* flip vertically */
00897                             if (IsWindowVisible(hSelection))
00898                             {
00899                                 SelectObject(hSelDC, hSelMask);
00900                                 StretchBlt(hSelDC, 0, rectSel_dest[3] - 1, rectSel_dest[2], -rectSel_dest[3], hSelDC,
00901                                            0, 0, rectSel_dest[2], rectSel_dest[3], SRCCOPY);
00902                                 SelectObject(hSelDC, hSelBm);
00903                                 StretchBlt(hSelDC, 0, rectSel_dest[3] - 1, rectSel_dest[2], -rectSel_dest[3], hSelDC,
00904                                            0, 0, rectSel_dest[2], rectSel_dest[3], SRCCOPY);
00905                                 SendMessage(hSelection, WM_LBUTTONDOWN, 0, 0);
00906                                 SendMessage(hSelection, WM_MOUSEMOVE, 0, 0);
00907                                 SendMessage(hSelection, WM_LBUTTONUP, 0, 0);
00908                             }
00909                             else
00910                             {
00911                                 newReversible();
00912                                 StretchBlt(hDrawingDC, 0, imgYRes - 1, imgXRes, -imgYRes, hDrawingDC, 0, 0,
00913                                            imgXRes, imgYRes, SRCCOPY);
00914                                 SendMessage(hImageArea, WM_PAINT, 0, 0);
00915                             }
00916                             break;
00917                         case 3: /* rotate 90 degrees */
00918                             break;
00919                         case 4: /* rotate 180 degrees */
00920                             if (IsWindowVisible(hSelection))
00921                             {
00922                                 SelectObject(hSelDC, hSelMask);
00923                                 StretchBlt(hSelDC, rectSel_dest[2] - 1, rectSel_dest[3] - 1, -rectSel_dest[2], -rectSel_dest[3], hSelDC,
00924                                            0, 0, rectSel_dest[2], rectSel_dest[3], SRCCOPY);
00925                                 SelectObject(hSelDC, hSelBm);
00926                                 StretchBlt(hSelDC, rectSel_dest[2] - 1, rectSel_dest[3] - 1, -rectSel_dest[2], -rectSel_dest[3], hSelDC,
00927                                            0, 0, rectSel_dest[2], rectSel_dest[3], SRCCOPY);
00928                                 SendMessage(hSelection, WM_LBUTTONDOWN, 0, 0);
00929                                 SendMessage(hSelection, WM_MOUSEMOVE, 0, 0);
00930                                 SendMessage(hSelection, WM_LBUTTONUP, 0, 0);
00931                             }
00932                             else
00933                             {
00934                                 newReversible();
00935                                 StretchBlt(hDrawingDC, imgXRes - 1, imgYRes - 1, -imgXRes, -imgYRes, hDrawingDC,
00936                                            0, 0, imgXRes, imgYRes, SRCCOPY);
00937                                 SendMessage(hImageArea, WM_PAINT, 0, 0);
00938                             }
00939                             break;
00940                         case 5: /* rotate 270 degrees */
00941                             break;
00942                     }
00943                     break;
00944                 case IDM_IMAGEATTRIBUTES:
00945                 {
00946                     int retVal = attributesDlg();
00947                     if ((LOWORD(retVal) != 0) && (HIWORD(retVal) != 0))
00948                     {
00949                         cropReversible(LOWORD(retVal), HIWORD(retVal), 0, 0);
00950                         updateCanvasAndScrollbars();
00951                     }
00952                     break;
00953                 }
00954                 case IDM_IMAGECHANGESIZE:
00955                 {
00956                     int retVal = changeSizeDlg();
00957                     if ((LOWORD(retVal) != 0) && (HIWORD(retVal) != 0))
00958                     {
00959                         insertReversible(CopyImage(hBms[currInd], IMAGE_BITMAP,
00960                                                    imgXRes * LOWORD(retVal) / 100,
00961                                                    imgYRes * HIWORD(retVal) / 100, 0));
00962                         updateCanvasAndScrollbars();
00963                     }
00964                     break;
00965                 }
00966                 case IDM_IMAGEDRAWOPAQUE:
00967                     transpBg = 1 - transpBg;
00968                     SendMessage(hToolSettings, WM_PAINT, 0, 0);
00969                     break;
00970                 case IDM_IMAGECROP:
00971                     insertReversible(CopyImage(hSelBm, IMAGE_BITMAP, 0, 0, LR_COPYRETURNORG));
00972                     updateCanvasAndScrollbars();
00973                     break;
00974 
00975                 case IDM_VIEWTOOLBOX:
00976                     ShowWindow(hToolBoxContainer, IsWindowVisible(hToolBoxContainer) ? SW_HIDE : SW_SHOW);
00977                     alignChildrenToMainWindow();
00978                     break;
00979                 case IDM_VIEWCOLORPALETTE:
00980                     ShowWindow(hPalWin, IsWindowVisible(hPalWin) ? SW_HIDE : SW_SHOW);
00981                     alignChildrenToMainWindow();
00982                     break;
00983                 case IDM_VIEWSTATUSBAR:
00984                     ShowWindow(hStatusBar, IsWindowVisible(hStatusBar) ? SW_HIDE : SW_SHOW);
00985                     alignChildrenToMainWindow();
00986                     break;
00987 
00988                 case IDM_VIEWSHOWGRID:
00989                     showGrid = !showGrid;
00990                     SendMessage(hImageArea, WM_PAINT, 0, 0);
00991                     break;
00992                 case IDM_VIEWSHOWMINIATURE:
00993                     showMiniature = !showMiniature;
00994                     ShowWindow(hwndMiniature, showMiniature ? SW_SHOW : SW_HIDE);
00995                     break;
00996 
00997                 case IDM_VIEWZOOM125:
00998                     zoomTo(125, 0, 0);
00999                     break;
01000                 case IDM_VIEWZOOM25:
01001                     zoomTo(250, 0, 0);
01002                     break;
01003                 case IDM_VIEWZOOM50:
01004                     zoomTo(500, 0, 0);
01005                     break;
01006                 case IDM_VIEWZOOM100:
01007                     zoomTo(1000, 0, 0);
01008                     break;
01009                 case IDM_VIEWZOOM200:
01010                     zoomTo(2000, 0, 0);
01011                     break;
01012                 case IDM_VIEWZOOM400:
01013                     zoomTo(4000, 0, 0);
01014                     break;
01015                 case IDM_VIEWZOOM800:
01016                     zoomTo(8000, 0, 0);
01017                     break;
01018                 case ID_FREESEL:
01019                     selectTool(1);
01020                     break;
01021                 case ID_RECTSEL:
01022                     selectTool(2);
01023                     break;
01024                 case ID_RUBBER:
01025                     selectTool(3);
01026                     break;
01027                 case ID_FILL:
01028                     selectTool(4);
01029                     break;
01030                 case ID_COLOR:
01031                     selectTool(5);
01032                     break;
01033                 case ID_ZOOM:
01034                     selectTool(6);
01035                     break;
01036                 case ID_PEN:
01037                     selectTool(7);
01038                     break;
01039                 case ID_BRUSH:
01040                     selectTool(8);
01041                     break;
01042                 case ID_AIRBRUSH:
01043                     selectTool(9);
01044                     break;
01045                 case ID_TEXT:
01046                     selectTool(10);
01047                     break;
01048                 case ID_LINE:
01049                     selectTool(11);
01050                     break;
01051                 case ID_BEZIER:
01052                     selectTool(12);
01053                     break;
01054                 case ID_RECT:
01055                     selectTool(13);
01056                     break;
01057                 case ID_SHAPE:
01058                     selectTool(14);
01059                     break;
01060                 case ID_ELLIPSE:
01061                     selectTool(15);
01062                     break;
01063                 case ID_RRECT:
01064                     selectTool(16);
01065                     break;
01066             }
01067             break;
01068         default:
01069             return DefWindowProc(hwnd, message, wParam, lParam);
01070     }
01071 
01072     return 0;
01073 }

Generated on Sun May 27 2012 04:17:09 for ReactOS by doxygen 1.7.6.1

ReactOS is a registered trademark or a trademark of ReactOS Foundation in the United States and other countries.