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