reactos/base/applications/paint/winproc.c

   1 /*
   2  * PROJECT:     PAINT for ReactOS
   3  * LICENSE:     LGPL
   4  * FILE:        winproc.c
   5  * PURPOSE:     Window procedure of the main window and all children apart from
   6  *              hPalWin, hToolSettings and hSelection
   7  * PROGRAMMERS: Benedikt Freisen
   8  */
   9
  10 /* INCLUDES *********************************************************/
  11
  12 #include <windows.h>
  13 #include <commctrl.h>
  14 //#include <htmlhelp.h>
  15 #include <stdio.h>
  16 #include <tchar.h>
  17 #include "definitions.h"
  18 #include "globalvar.h"
  19 #include "dialogs.h"
  20 #include "dib.h"
  21 #include "drawing.h"
  22 #include "history.h"
  23 #include "mouse.h"
  24 #include "registry.h"
  25
  26 /* FUNCTIONS ********************************************************/
  27
  28 void selectTool(int tool)
  29 {
  30     ShowWindow(hSelection, SW_HIDE);
  31     activeTool = tool;
  32     pointSP = 0; // resets the point-buffer of the polygon and bezier functions
  33     SendMessage(hToolSettings, WM_PAINT, 0, 0);
  34     if (tool==6)
  35         ShowWindow(hTrackbarZoom, SW_SHOW);
  36     else
  37         ShowWindow(hTrackbarZoom, SW_HIDE);
  38 }
  39
  40 void updateCanvasAndScrollbars()
  41 {
  42     ShowWindow(hSelection, SW_HIDE);
  43     MoveWindow(hImageArea, 3, 3, imgXRes*zoom/1000, imgYRes*zoom/1000, FALSE);
  44     InvalidateRect(hScrollbox, NULL, TRUE);
  45     InvalidateRect(hImageArea, NULL, FALSE);
  46
  47     SetScrollPos(hScrollbox, SB_HORZ, 0, TRUE);
  48     SetScrollPos(hScrollbox, SB_VERT, 0, TRUE);
  49 }
  50
  51 void ZoomTo(int newZoom)
  52 {
  53     zoom = newZoom;
  54     updateCanvasAndScrollbars();
  55     int tbPos = 0;
  56     int tempZoom = newZoom;
  57     while (tempZoom>125)
  58     {
  59         tbPos++;
  60         tempZoom = tempZoom>>1;
  61     }
  62     SendMessage(hTrackbarZoom, TBM_SETPOS, (WPARAM)TRUE, (LPARAM)tbPos);
  63 }
  64
  65 HDC hdc;
  66 BOOL drawing;
  67
  68 LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  69 {
  70     switch (message)                  /* handle the messages */
  71     {
  72         case WM_DESTROY:
  73             PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
  74             break;
  75         case WM_CLOSE:
  76             if (hwnd==hwndMiniature)
  77             {
  78                 ShowWindow(hwndMiniature, SW_HIDE);
  79                 showMiniature = FALSE;
  80                 break;
  81             }
  82             if (!imageSaved)
  83             {
  84                 TCHAR programname[20];
  85                 TCHAR saveprompttext[100];
  86                 TCHAR temptext[500];
  87                 LoadString(hProgInstance, IDS_PROGRAMNAME, programname, SIZEOF(programname));
  88                 LoadString(hProgInstance, IDS_SAVEPROMPTTEXT, saveprompttext, SIZEOF(saveprompttext));
  89                 _stprintf(temptext, saveprompttext, filename);
  90                 switch (MessageBox(hwnd, temptext, programname, MB_YESNOCANCEL | MB_ICONQUESTION))
  91                 {
  92                     case IDNO:
  93                         DestroyWindow(hwnd);
  94                         break;
  95                     case IDYES:
  96                         SendMessage(hwnd, WM_COMMAND, IDM_FILESAVEAS, 0);
  97                         DestroyWindow(hwnd);
  98                         break;
  99                 }
 100             }
 101             else
 102             {
 103                 DestroyWindow(hwnd);
 104             }
 105             break;
 106         case WM_INITMENUPOPUP:
 107             switch (lParam)
 108             {
 109                 case 0:
 110                     if (isAFile)
 111                     {
 112                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERPLANE, MF_ENABLED | MF_BYCOMMAND);
 113                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERCENTERED, MF_ENABLED | MF_BYCOMMAND);
 114                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERSTRETCHED, MF_ENABLED | MF_BYCOMMAND);
 115                     }
 116                     else
 117                     {
 118                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERPLANE, MF_GRAYED | MF_BYCOMMAND);
 119                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERCENTERED, MF_GRAYED | MF_BYCOMMAND);
 120                         EnableMenuItem(GetMenu(hMainWnd), IDM_FILEASWALLPAPERSTRETCHED, MF_GRAYED | MF_BYCOMMAND);
 121                     }
 122                     break;
 123                 case 1:
 124                     if (undoSteps>0)
 125                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITUNDO, MF_ENABLED | MF_BYCOMMAND);
 126                     else
 127                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITUNDO, MF_GRAYED | MF_BYCOMMAND);
 128                     if (redoSteps>0)
 129                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITREDO, MF_ENABLED | MF_BYCOMMAND);
 130                     else
 131                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITREDO, MF_GRAYED | MF_BYCOMMAND);
 132                     if (IsWindowVisible(hSelection))
 133                     {
 134                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCUT, MF_ENABLED | MF_BYCOMMAND);
 135                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCOPY, MF_ENABLED | MF_BYCOMMAND);
 136                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITDELETESELECTION, MF_ENABLED | MF_BYCOMMAND);
 137                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITINVERTSELECTION, MF_ENABLED | MF_BYCOMMAND);
 138                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCOPYTO, MF_ENABLED | MF_BYCOMMAND);
 139                     }
 140                     else
 141                     {
 142                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCUT, MF_GRAYED | MF_BYCOMMAND);
 143                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCOPY, MF_GRAYED | MF_BYCOMMAND);
 144                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITDELETESELECTION, MF_GRAYED | MF_BYCOMMAND);
 145                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITINVERTSELECTION, MF_GRAYED | MF_BYCOMMAND);
 146                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITCOPYTO, MF_GRAYED | MF_BYCOMMAND);
 147                     }
 148                     OpenClipboard(hMainWnd);
 149                     if (GetClipboardData(CF_BITMAP)!=NULL)
 150                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITPASTE, MF_ENABLED | MF_BYCOMMAND);
 151                     else
 152                         EnableMenuItem(GetMenu(hMainWnd), IDM_EDITPASTE, MF_GRAYED | MF_BYCOMMAND);
 153                     CloseClipboard();
 154                     break;
 155                 case 3:
 156                     if (IsWindowVisible(hSelection))
 157                         EnableMenuItem(GetMenu(hMainWnd), IDM_IMAGECROP, MF_ENABLED | MF_BYCOMMAND);
 158                     else
 159                         EnableMenuItem(GetMenu(hMainWnd), IDM_IMAGECROP, MF_GRAYED | MF_BYCOMMAND);
 160                     if (transpBg==0)
 161                         CheckMenuItem(GetMenu(hMainWnd), IDM_IMAGEDRAWOPAQUE, MF_CHECKED | MF_BYCOMMAND);
 162                     else
 163                         CheckMenuItem(GetMenu(hMainWnd), IDM_IMAGEDRAWOPAQUE, MF_UNCHECKED | MF_BYCOMMAND);
 164                     break;
 165             }
 166             if (showGrid)
 167                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWSHOWGRID, MF_CHECKED | MF_BYCOMMAND);
 168             else
 169                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWSHOWGRID, MF_UNCHECKED | MF_BYCOMMAND);
 170             if (showMiniature)
 171                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWSHOWMINIATURE, MF_CHECKED | MF_BYCOMMAND);
 172             else
 173                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWSHOWMINIATURE, MF_UNCHECKED | MF_BYCOMMAND);
 174
 175             if (zoom==125)
 176                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM125, MF_CHECKED | MF_BYCOMMAND);
 177             else
 178                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM125, MF_UNCHECKED | MF_BYCOMMAND);
 179             if (zoom==250)
 180                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM25, MF_CHECKED | MF_BYCOMMAND);
 181             else
 182                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM25, MF_UNCHECKED | MF_BYCOMMAND);
 183             if (zoom==500)
 184                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM50, MF_CHECKED | MF_BYCOMMAND);
 185             else
 186                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM50, MF_UNCHECKED | MF_BYCOMMAND);
 187             if (zoom==1000)
 188                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM100, MF_CHECKED | MF_BYCOMMAND);
 189             else
 190                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM100, MF_UNCHECKED | MF_BYCOMMAND);
 191             if (zoom==2000)
 192                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM200, MF_CHECKED | MF_BYCOMMAND);
 193             else
 194                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM200, MF_UNCHECKED | MF_BYCOMMAND);
 195             if (zoom==4000)
 196                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM400, MF_CHECKED | MF_BYCOMMAND);
 197             else
 198                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM400, MF_UNCHECKED | MF_BYCOMMAND);
 199             if (zoom==8000)
 200                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM800, MF_CHECKED | MF_BYCOMMAND);
 201             else
 202                 CheckMenuItem(GetMenu(hMainWnd), IDM_VIEWZOOM800, MF_UNCHECKED | MF_BYCOMMAND);
 203
 204             break;
 205         case WM_SIZE:
 206             if (hwnd==hMainWnd)
 207             {
 208                 int test[] = {LOWORD(lParam)-260, LOWORD(lParam)-140, LOWORD(lParam)-20};
 209                 SendMessage(hStatusBar, WM_SIZE, wParam, lParam);
 210                 SendMessage(hStatusBar, SB_SETPARTS, 3, (int)&test);
 211                 MoveWindow(hScrollbox, 56, 49,LOWORD(lParam)-56, HIWORD(lParam)-72, TRUE);
 212                 //InvalidateRect(hwnd, NULL, TRUE);
 213             }
 214             if (hwnd==hImageArea)
 215             {
 216                 MoveWindow(hSizeboxLeftTop,
 217                     0,
 218                     0, 3, 3, TRUE);
 219                 MoveWindow(hSizeboxCenterTop,
 220                     imgXRes*zoom/2000+3*3/4,
 221                     0, 3, 3, TRUE);
 222                 MoveWindow(hSizeboxRightTop,
 223                     imgXRes*zoom/1000+3,
 224                     0, 3, 3, TRUE);
 225                 MoveWindow(hSizeboxLeftCenter,
 226                     0,
 227                     imgYRes*zoom/2000+3*3/4, 3, 3, TRUE);
 228                 MoveWindow(hSizeboxRightCenter,
 229                     imgXRes*zoom/1000+3,
 230                     imgYRes*zoom/2000+3*3/4, 3, 3, TRUE);
 231                 MoveWindow(hSizeboxLeftBottom,
 232                     0,
 233                     imgYRes*zoom/1000+3, 3, 3, TRUE);
 234                 MoveWindow(hSizeboxCenterBottom,
 235                     imgXRes*zoom/2000+3*3/4,
 236                     imgYRes*zoom/1000+3, 3, 3, TRUE);
 237                 MoveWindow(hSizeboxRightBottom,
 238                     imgXRes*zoom/1000+3,
 239                     imgYRes*zoom/1000+3, 3, 3, TRUE);
 240             }
 241             if ((hwnd==hImageArea)||(hwnd==hScrollbox))
 242             {
 243                 long clientRectScrollbox[4];
 244                 long clientRectImageArea[4];
 245                 SCROLLINFO horzScroll;
 246                 SCROLLINFO vertScroll;
 247                 GetClientRect(hScrollbox, (LPRECT)&clientRectScrollbox);
 248                 GetClientRect(hImageArea, (LPRECT)&clientRectImageArea);
 249                 MoveWindow(hScrlClient, 0, 0, max(clientRectImageArea[2]+6, clientRectScrollbox[2]), max(clientRectImageArea[3]+6, clientRectScrollbox[3]), TRUE);
 250                 horzScroll.cbSize       = sizeof(SCROLLINFO);
 251                 horzScroll.fMask        = SIF_PAGE | SIF_RANGE;
 252                 horzScroll.nMax         = 10000;
 253                 horzScroll.nMin         = 0;
 254                 horzScroll.nPage        = clientRectScrollbox[2]*10000/(clientRectImageArea[2]+6);
 255                 horzScroll.nPos         = 0;
 256                 horzScroll.nTrackPos    = 0;
 257                 SetScrollInfo(hScrollbox, SB_HORZ, &horzScroll, TRUE);
 258                 GetClientRect(hScrollbox, (LPRECT)clientRectScrollbox);
 259                 vertScroll.cbSize       = sizeof(SCROLLINFO);
 260                 vertScroll.fMask        = SIF_PAGE | SIF_RANGE;
 261                 vertScroll.nMax         = 10000;
 262                 vertScroll.nMin         = 0;
 263                 vertScroll.nPage        = clientRectScrollbox[3]*10000/(clientRectImageArea[3]+6);
 264                 vertScroll.nPos         = 0;
 265                 vertScroll.nTrackPos    = 0;
 266                 SetScrollInfo(hScrollbox, SB_VERT, &vertScroll, TRUE);
 267             }
 268             break;
 269         case WM_HSCROLL:
 270             if (hwnd==hScrollbox)
 271             {
 272                 if ((LOWORD(wParam)==SB_THUMBPOSITION)||(LOWORD(wParam)==SB_THUMBTRACK))
 273                 {
 274                     SetScrollPos(hScrollbox, SB_HORZ, HIWORD(wParam), TRUE);
 275                     MoveWindow(hScrlClient, -(imgXRes*zoom/1000+6)*GetScrollPos(hScrollbox, SB_HORZ)/10000,
 276                         -(imgYRes*zoom/1000+6)*GetScrollPos(hScrollbox, SB_VERT)/10000, imgXRes*zoom/1000+6, imgYRes*zoom/1000+6, TRUE);
 277                 }
 278             }
 279             break;
 280         case WM_VSCROLL:
 281             if (hwnd==hScrollbox)
 282             {
 283                 if ((LOWORD(wParam)==SB_THUMBPOSITION)||(LOWORD(wParam)==SB_THUMBTRACK))
 284                 {
 285                     SetScrollPos(hScrollbox, SB_VERT, HIWORD(wParam), TRUE);
 286                     MoveWindow(hScrlClient, -(imgXRes*zoom/1000+6)*GetScrollPos(hScrollbox, SB_HORZ)/10000,
 287                         -(imgYRes*zoom/1000+6)*GetScrollPos(hScrollbox, SB_VERT)/10000, imgXRes*zoom/1000+6, imgYRes*zoom/1000+6, TRUE);
 288                 }
 289             }
 290             break;
 291         case WM_GETMINMAXINFO:
 292             if (hwnd==hMainWnd)
 293             {
 294                 MINMAXINFO *mm = (LPMINMAXINFO)lParam;
 295                 (*mm).ptMinTrackSize.x = 330;
 296                 (*mm).ptMinTrackSize.y = 430;
 297             }
 298             break;
 299         case WM_PAINT:
 300             DefWindowProc (hwnd, message, wParam, lParam);
 301             if (hwnd==hImageArea)
 302             {
 303                 HDC hdc = GetDC(hImageArea);
 304                 StretchBlt(hdc, 0, 0, imgXRes*zoom/1000, imgYRes*zoom/1000, hDrawingDC, 0, 0, imgXRes, imgYRes, SRCCOPY);
 305                 if (showGrid && (zoom>=4000))
 306                 {
 307                     HPEN oldPen = SelectObject(hdc, CreatePen(PS_SOLID, 1, 0x00a0a0a0));
 308                     int counter;
 309                     for (counter = 0; counter <= imgYRes; counter++)
 310                     {
 311                         MoveToEx(hdc, 0, counter*zoom/1000, NULL);
 312                         LineTo(hdc, imgXRes*zoom/1000, counter*zoom/1000);
 313                     }
 314                     for (counter = 0; counter <= imgXRes; counter++)
 315                     {
 316                         MoveToEx(hdc, counter*zoom/1000, 0, NULL);
 317                         LineTo(hdc, counter*zoom/1000, imgYRes*zoom/1000);
 318                     }
 319                     DeleteObject(SelectObject(hdc, oldPen));
 320                 }
 321                 ReleaseDC(hImageArea, hdc);
 322                 SendMessage(hSelection, WM_PAINT, 0, 0);
 323                 SendMessage(hwndMiniature, WM_PAINT, 0, 0);
 324             }else
 325             if (hwnd==hwndMiniature)
 326             {
 327                 long mclient[4];
 328                 HDC hdc;
 329                 GetClientRect(hwndMiniature, (LPRECT)&mclient);
 330                 hdc = GetDC(hwndMiniature);
 331                 BitBlt(hdc, -min(imgXRes*GetScrollPos(hScrollbox, SB_HORZ)/10000, imgXRes-mclient[2]),
 332                     -min(imgYRes*GetScrollPos(hScrollbox, SB_VERT)/10000, imgYRes-mclient[3]), imgXRes, imgYRes, hDrawingDC, 0, 0, SRCCOPY);
 333                 ReleaseDC(hwndMiniature, hdc);
 334             }
 335             break;
 336
 337         // mouse events used for drawing
 338
 339         case WM_SETCURSOR:
 340             if (hwnd==hImageArea)
 341             {
 342                 switch (activeTool)
 343                 {
 344                     case 4:
 345                         SetCursor(hCurFill);
 346                         break;
 347                     case 5:
 348                         SetCursor(hCurColor);
 349                         break;
 350                     case 6:
 351                         SetCursor(hCurZoom);
 352                         break;
 353                     case 7:
 354                         SetCursor(hCurPen);
 355                         break;
 356                     case 9:
 357                         SetCursor(hCurAirbrush);
 358                         break;
 359                     default:
 360                         SetCursor(LoadCursor(NULL, IDC_CROSS));
 361                 }
 362             } else DefWindowProc(hwnd, message, wParam, lParam);
 363             break;
 364         case WM_LBUTTONDOWN:
 365             if (hwnd==hImageArea)
 366             {
 367                 if ((!drawing)||(activeTool==5))
 368                 {
 369                     SetCapture(hImageArea);
 370                     drawing = TRUE;
 371                     startPaintingL(hDrawingDC, LOWORD(lParam)*1000/zoom, HIWORD(lParam)*1000/zoom, fgColor, bgColor);
 372                 }else
 373                 {
 374                     SendMessage(hwnd, WM_LBUTTONUP, wParam, lParam);
 375                     undo();
 376                 }
 377                 SendMessage(hImageArea, WM_PAINT, 0, 0);
 378                 if ((activeTool==6)&&(zoom<8000)) ZoomTo(zoom*2);
 379             }
 380             break;
 381         case WM_RBUTTONDOWN:
 382             if (hwnd==hImageArea)
 383             {
 384                 if ((!drawing)||(activeTool==5))
 385                 {
 386                     SetCapture(hImageArea);
 387                     drawing = TRUE;
 388                     startPaintingR(hDrawingDC, LOWORD(lParam)*1000/zoom, HIWORD(lParam)*1000/zoom, fgColor, bgColor);
 389                 }else
 390                 {
 391                     SendMessage(hwnd, WM_RBUTTONUP, wParam, lParam);
 392                     undo();
 393                 }
 394                 SendMessage(hImageArea, WM_PAINT, 0, 0);
 395                 if ((activeTool==6)&&(zoom>125)) ZoomTo(zoom/2);
 396             }
 397             break;
 398         case WM_LBUTTONUP:
 399             if ((hwnd==hImageArea)&&drawing)
 400             {
 401                 ReleaseCapture();
 402                 drawing = FALSE;
 403                 endPaintingL(hDrawingDC, LOWORD(lParam)*1000/zoom, HIWORD(lParam)*1000/zoom, fgColor, bgColor);
 404                 SendMessage(hImageArea, WM_PAINT, 0, 0);
 405                 if (activeTool==5)
 406                 {
 407                     int tempColor = GetPixel(hDrawingDC, LOWORD(lParam)*1000/zoom, HIWORD(lParam)*1000/zoom);
 408                     if (tempColor!=CLR_INVALID) fgColor = tempColor;
 409                     SendMessage(hPalWin, WM_PAINT, 0, 0);
 410                 }
 411                 SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM)"");
 412             }
 413             break;
 414         case WM_RBUTTONUP:
 415             if ((hwnd==hImageArea)&&drawing)
 416             {
 417                 ReleaseCapture();
 418                 drawing = FALSE;
 419                 endPaintingR(hDrawingDC, LOWORD(lParam)*1000/zoom, HIWORD(lParam)*1000/zoom, fgColor, bgColor);
 420                 SendMessage(hImageArea, WM_PAINT, 0, 0);
 421                 if (activeTool==5)
 422                 {
 423                     int tempColor = GetPixel(hDrawingDC, LOWORD(lParam)*1000/zoom, HIWORD(lParam)*1000/zoom);
 424                     if (tempColor!=CLR_INVALID) bgColor = tempColor;
 425                     SendMessage(hPalWin, WM_PAINT, 0, 0);
 426                 }
 427                 SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM)"");
 428             }
 429             break;
 430         case WM_MOUSEMOVE:
 431             if (hwnd==hImageArea)
 432             {
 433                 if ((!drawing)||(activeTool<=9))
 434                 {
 435                     TCHAR coordStr[100];
 436                     _stprintf(coordStr, _T("%d, %d"), (short)LOWORD(lParam)*1000/zoom, (short)HIWORD(lParam)*1000/zoom);
 437                     SendMessage(hStatusBar, SB_SETTEXT, 1, (LPARAM)coordStr);
 438                 }
 439                 if (drawing)
 440                 {
 441                     if ((wParam&MK_LBUTTON)!=0)
 442                     {
 443                         whilePaintingL(hDrawingDC, (short)LOWORD(lParam)*1000/zoom, (short)HIWORD(lParam)*1000/zoom, fgColor, bgColor);
 444                         SendMessage(hImageArea, WM_PAINT, 0, 0);
 445                         if ((activeTool>=10)||(activeTool==2))
 446                         {
 447                             TCHAR sizeStr[100];
 448                             _stprintf(sizeStr, _T("%d x %d"), (short)LOWORD(lParam)*1000/zoom-startX, (short)HIWORD(lParam)*1000/zoom-startY);
 449                             SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM)sizeStr);
 450                         }
 451                     }
 452                     if ((wParam&MK_RBUTTON)!=0)
 453                     {
 454                         whilePaintingR(hDrawingDC, (short)LOWORD(lParam)*1000/zoom, (short)HIWORD(lParam)*1000/zoom, fgColor, bgColor);
 455                         SendMessage(hImageArea, WM_PAINT, 0, 0);
 456                         if (activeTool>=10)
 457                         {
 458                             TCHAR sizeStr[100];
 459                             _stprintf(sizeStr, _T("%d x %d"), (short)LOWORD(lParam)*1000/zoom-startX, (short)HIWORD(lParam)*1000/zoom-startY);
 460                             SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM)sizeStr);
 461                         }
 462                     }
 463                 }
 464             } else
 465             {
 466                 SendMessage(hStatusBar, SB_SETTEXT, 1, (LPARAM)_T(""));
 467             }
 468             break;
 469
 470         // menu and button events
 471
 472         case WM_COMMAND:
 473             switch (LOWORD(wParam))
 474             {
 475                 case IDM_HELPINFO:
 476                     {
 477                         HICON paintIcon = LoadIcon(hProgInstance, MAKEINTRESOURCE(IDI_APPICON));
 478                         TCHAR infotitle[100];
 479                         TCHAR infotext[200];
 480                         LoadString(hProgInstance, IDS_INFOTITLE, infotitle, SIZEOF(infotitle));
 481                         LoadString(hProgInstance, IDS_INFOTEXT, infotext, SIZEOF(infotext));
 482                         ShellAbout(hMainWnd, infotitle, infotext, paintIcon);
 483                         DeleteObject(paintIcon);
 484                     }
 485                     break;
 486                 case IDM_HELPHELPTOPICS:
 487                     //HtmlHelp(hMainWnd, "help\\Paint.chm", 0, 0);
 488                     break;
 489                 case IDM_FILEEXIT:
 490                     SendMessage(hwnd, WM_CLOSE, wParam, lParam);
 491                     break;
 492                 case IDM_FILENEW:
 493                     Rectangle(hDrawingDC, 0-1, 0-1, imgXRes+1, imgYRes+1);
 494                     SendMessage(hImageArea, WM_PAINT, 0, 0);
 495                     break;
 496                 case IDM_FILEOPEN:
 497                     if (GetOpenFileName(&ofn)!=0)
 498                     {
 499                         HBITMAP bmNew = (HBITMAP)LoadDIBFromFile(ofn.lpstrFile);
 500                         if (bmNew!=NULL)
 501                         {
 502                             TCHAR tempstr[1000];
 503                             TCHAR resstr[100];
 504                             insertReversible(bmNew);
 505                             updateCanvasAndScrollbars();
 506                             CopyMemory(filename, ofn.lpstrFileTitle, sizeof(filename));
 507                             CopyMemory(filepathname, ofn.lpstrFileTitle, sizeof(filepathname));
 508                             LoadString(hProgInstance, IDS_WINDOWTITLE, resstr, SIZEOF(resstr));
 509                             _stprintf(tempstr, resstr, filename);
 510                             SetWindowText(hMainWnd, tempstr);
 511                             clearHistory();
 512                             isAFile = TRUE;
 513                         }
 514                     }
 515                     break;
 516                 case IDM_FILESAVE:
 517                     if (isAFile)
 518                     {
 519                         SaveDIBToFile(hBms[currInd], filepathname, hDrawingDC);
 520                         imageSaved = TRUE;
 521                     }
 522                     else
 523                         SendMessage(hwnd, WM_COMMAND, IDM_FILESAVEAS, 0);
 524                     break;
 525                 case IDM_FILESAVEAS:
 526                     if (GetSaveFileName(&sfn)!=0)
 527                     {
 528                         TCHAR tempstr[1000];
 529                         TCHAR resstr[100];
 530                         SaveDIBToFile(hBms[currInd], sfn.lpstrFile, hDrawingDC);
 531                         CopyMemory(filename, sfn.lpstrFileTitle, sizeof(filename));
 532                         CopyMemory(filepathname, sfn.lpstrFile, sizeof(filepathname));
 533                         LoadString(hProgInstance, IDS_WINDOWTITLE, resstr, SIZEOF(resstr));
 534                         _stprintf(tempstr, resstr, filename);
 535                         SetWindowText(hMainWnd, tempstr);
 536                         isAFile = TRUE;
 537                         imageSaved = TRUE;
 538                     }
 539                     break;
 540                 case IDM_FILEASWALLPAPERPLANE:
 541                     SetWallpaper(filepathname, 1, 1);
 542                     break;
 543                 case IDM_FILEASWALLPAPERCENTERED:
 544                     SetWallpaper(filepathname, 1, 0);
 545                     break;
 546                 case IDM_FILEASWALLPAPERSTRETCHED:
 547                     SetWallpaper(filepathname, 2, 0);
 548                     break;
 549                 case IDM_EDITUNDO:
 550                     undo();
 551                     SendMessage(hImageArea, WM_PAINT, 0, 0);
 552                     break;
 553                 case IDM_EDITREDO:
 554                     redo();
 555                     SendMessage(hImageArea, WM_PAINT, 0, 0);
 556                     break;
 557                 case IDM_EDITCOPY:
 558                     OpenClipboard(hMainWnd);
 559                     EmptyClipboard();
 560                     SetClipboardData(CF_BITMAP, CopyImage(hSelBm, IMAGE_BITMAP, 0, 0, LR_COPYRETURNORG));
 561                     CloseClipboard();
 562                     break;
 563                 case IDM_EDITPASTE:
 564                     OpenClipboard(hMainWnd);
 565                     if (GetClipboardData(CF_BITMAP)!=NULL)
 566                     {
 567                         DeleteObject(SelectObject(hSelDC, hSelBm = CopyImage(GetClipboardData(CF_BITMAP), IMAGE_BITMAP, 0, 0, LR_COPYRETURNORG)));
 568                         newReversible();
 569                         rectSel_src[0] = rectSel_src[1] = rectSel_src[2] = rectSel_src[3] = 0;
 570                         rectSel_dest[0] = rectSel_dest[1] = 0;
 571                         rectSel_dest[2] = GetDIBWidth(hSelBm);
 572                         rectSel_dest[3] = GetDIBHeight(hSelBm);
 573                         BitBlt(hDrawingDC, rectSel_dest[0], rectSel_dest[1], rectSel_dest[2], rectSel_dest[3], hSelDC, 0, 0, SRCCOPY);
 574                         placeSelWin();
 575                         ShowWindow(hSelection, SW_SHOW);
 576                     }
 577                     CloseClipboard();
 578                     break;
 579                 case IDM_EDITDELETESELECTION:
 580                     ShowWindow(hSelection, SW_HIDE);
 581                     break;
 582                 case IDM_EDITSELECTALL:
 583                     if (activeTool==2)
 584                     {
 585                         startPaintingL(hDrawingDC, 0, 0, fgColor, bgColor);
 586                         whilePaintingL(hDrawingDC, imgXRes, imgYRes, fgColor, bgColor);
 587                         endPaintingL(hDrawingDC, imgXRes, imgYRes, fgColor, bgColor);
 588                     }
 589                     break;
 590                 case IDM_EDITCOPYTO:
 591                     if (GetSaveFileName(&ofn)!=0) SaveDIBToFile(hSelBm, ofn.lpstrFile, hDrawingDC);
 592                     break;
 593                 case IDM_COLORSEDITPALETTE:
 594                     if (ChooseColor(&choosecolor))
 595                     {
 596                         fgColor = choosecolor.rgbResult;
 597                         SendMessage(hPalWin, WM_PAINT, 0, 0);
 598                     }
 599                     break;
 600                 case IDM_IMAGEINVERTCOLORS:
 601                     {
 602                         RECT tempRect;
 603                         newReversible();
 604                         SetRect(&tempRect, 0, 0, imgXRes, imgYRes);
 605                         InvertRect(hDrawingDC, &tempRect);
 606                         SendMessage(hImageArea, WM_PAINT, 0, 0);
 607                     }
 608                     break;
 609                 case IDM_IMAGEDELETEIMAGE:
 610                     newReversible();
 611                     Rect(hDrawingDC, 0, 0, imgXRes, imgYRes, bgColor, bgColor, 0, TRUE);
 612                     SendMessage(hImageArea, WM_PAINT, 0, 0);
 613                     break;
 614                 case IDM_IMAGEROTATEMIRROR:
 615                     switch (mirrorRotateDlg())
 616                     {
 617                         case 1:
 618                             newReversible();
 619                             StretchBlt(hDrawingDC, imgXRes-1, 0, -imgXRes, imgYRes, hDrawingDC, 0, 0, imgXRes, imgYRes, SRCCOPY);
 620                             SendMessage(hImageArea, WM_PAINT, 0, 0);
 621                             break;
 622                         case 2:
 623                             newReversible();
 624                             StretchBlt(hDrawingDC, 0, imgYRes-1, imgXRes, -imgYRes, hDrawingDC, 0, 0, imgXRes, imgYRes, SRCCOPY);
 625                             SendMessage(hImageArea, WM_PAINT, 0, 0);
 626                             break;
 627                         case 4:
 628                             newReversible();
 629                             StretchBlt(hDrawingDC, imgXRes-1, imgYRes-1, -imgXRes, -imgYRes, hDrawingDC, 0, 0, imgXRes, imgYRes, SRCCOPY);
 630                             SendMessage(hImageArea, WM_PAINT, 0, 0);
 631                             break;
 632                     }
 633                     break;
 634                 case IDM_IMAGEATTRIBUTES:
 635                     {
 636                         int retVal = attributesDlg();
 637                         if ((LOWORD(retVal)!=0)&&(HIWORD(retVal)!=0))
 638                         {
 639                             cropReversible(LOWORD(retVal), HIWORD(retVal), 0, 0);
 640                             updateCanvasAndScrollbars();
 641                         }
 642                     }
 643                     break;
 644                 case IDM_IMAGECHANGESIZE:
 645                     {
 646                         int retVal = changeSizeDlg();
 647                         if ((LOWORD(retVal)!=0)&&(HIWORD(retVal)!=0))
 648                         {
 649                             insertReversible(CopyImage(hBms[currInd], IMAGE_BITMAP, imgXRes*LOWORD(retVal)/100, imgYRes*HIWORD(retVal)/100, 0));
 650                             updateCanvasAndScrollbars();
 651                         }
 652                     }
 653                     break;
 654                 case IDM_IMAGEDRAWOPAQUE:
 655                     transpBg = 1-transpBg;
 656                     SendMessage(hToolSettings, WM_PAINT, 0, 0);
 657                     break;
 658                 case IDM_IMAGECROP:
 659                     insertReversible(CopyImage(hSelBm, IMAGE_BITMAP, 0, 0, LR_COPYRETURNORG));
 660                     updateCanvasAndScrollbars();
 661                     break;
 662
 663                 case IDM_VIEWSHOWGRID:
 664                     showGrid = !showGrid;
 665                     break;
 666                 case IDM_VIEWSHOWMINIATURE:
 667                     showMiniature = !showMiniature;
 668                     if (showMiniature)
 669                         ShowWindow(hwndMiniature, SW_SHOW);
 670                     else
 671                         ShowWindow(hwndMiniature, SW_HIDE);
 672                     break;
 673
 674                 case IDM_VIEWZOOM125:
 675                     ZoomTo(125);
 676                     break;
 677                 case IDM_VIEWZOOM25:
 678                     ZoomTo(250);
 679                     break;
 680                 case IDM_VIEWZOOM50:
 681                     ZoomTo(500);
 682                     break;
 683                 case IDM_VIEWZOOM100:
 684                     ZoomTo(1000);
 685                     break;
 686                 case IDM_VIEWZOOM200:
 687                     ZoomTo(2000);
 688                     break;
 689                 case IDM_VIEWZOOM400:
 690                     ZoomTo(4000);
 691                     break;
 692                 case IDM_VIEWZOOM800:
 693                     ZoomTo(8000);
 694                     break;
 695                 case ID_FREESEL:
 696                     selectTool(1);
 697                     break;
 698                 case ID_RECTSEL:
 699                     selectTool(2);
 700                     break;
 701                 case ID_RUBBER:
 702                     selectTool(3);
 703                     break;
 704                 case ID_FILL:
 705                     selectTool(4);
 706                     break;
 707                 case ID_COLOR:
 708                     selectTool(5);
 709                     break;
 710                 case ID_ZOOM:
 711                     selectTool(6);
 712                     break;
 713                 case ID_PEN:
 714                     selectTool(7);
 715                     break;
 716                 case ID_BRUSH:
 717                     selectTool(8);
 718                     break;
 719                 case ID_AIRBRUSH:
 720                     selectTool(9);
 721                     break;
 722                 case ID_TEXT:
 723                     selectTool(10);
 724                     break;
 725                 case ID_LINE:
 726                     selectTool(11);
 727                     break;
 728                 case ID_BEZIER:
 729                     selectTool(12);
 730                     break;
 731                 case ID_RECT:
 732                     selectTool(13);
 733                     break;
 734                 case ID_SHAPE:
 735                     selectTool(14);
 736                     break;
 737                 case ID_ELLIPSE:
 738                     selectTool(15);
 739                     break;
 740                 case ID_RRECT:
 741                     selectTool(16);
 742                     break;
 743             }
 744             break;
 745         default:
 746             return DefWindowProc (hwnd, message, wParam, lParam);
 747     }
 748
 749     return 0;
 750 }
 751