src/TortoiseIDiff/PicWindow.cpp

   1 // TortoiseIDiff - an image diff viewer in TortoiseSVN
   2
   3 // Copyright (C) 2006-2011 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "StdAfx.h"
  20 #include "shellapi.h"
  21 #include "commctrl.h"
  22 #include "PicWindow.h"
  23 #include "math.h"
  24 #include "SysInfo.h"
  25
  26 #pragma comment(lib, "Msimg32.lib")
  27 #pragma comment(lib, "shell32.lib")
  28
  29 bool CPicWindow::RegisterAndCreateWindow(HWND hParent)
  30 {
  31     WNDCLASSEX wcx;
  32
  33     // Fill in the window class structure with default parameters
  34     wcx.cbSize = sizeof(WNDCLASSEX);
  35     wcx.style = CS_HREDRAW | CS_VREDRAW;
  36     wcx.lpfnWndProc = CWindow::stWinMsgHandler;
  37     wcx.cbClsExtra = 0;
  38     wcx.cbWndExtra = 0;
  39     wcx.hInstance = hResource;
  40     wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
  41     wcx.lpszClassName = _T("TortoiseIDiffPicWindow");
  42     wcx.hIcon = LoadIcon(hResource, MAKEINTRESOURCE(IDI_TORTOISEIDIFF));
  43     wcx.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  44     wcx.lpszMenuName = MAKEINTRESOURCE(IDC_TORTOISEIDIFF);
  45     wcx.hIconSm = LoadIcon(wcx.hInstance, MAKEINTRESOURCE(IDI_TORTOISEIDIFF));
  46     RegisterWindow(&wcx);
  47     if (CreateEx(WS_EX_ACCEPTFILES | WS_EX_CLIENTEDGE, WS_CHILD | WS_HSCROLL | WS_VSCROLL | WS_VISIBLE, hParent))
  48     {
  49         ShowWindow(m_hwnd, SW_SHOW);
  50         UpdateWindow(m_hwnd);
  51         CreateButtons();
  52         return true;
  53     }
  54     return false;
  55 }
  56
  57 void CPicWindow::PositionTrackBar()
  58 {
  59     RECT rc;
  60     GetClientRect(&rc);
  61     HWND slider = m_AlphaSlider.GetWindow();
  62     if ((pSecondPic)&&(m_blend == BLEND_ALPHA))
  63     {
  64         MoveWindow(slider, 0, rc.top-4+SLIDER_WIDTH, SLIDER_WIDTH, rc.bottom-rc.top-SLIDER_WIDTH+8, true);
  65         ShowWindow(slider, SW_SHOW);
  66         MoveWindow(hwndAlphaToggleBtn, 0, rc.top-4, SLIDER_WIDTH, SLIDER_WIDTH, true);
  67         ShowWindow(hwndAlphaToggleBtn, SW_SHOW);
  68     }
  69     else
  70     {
  71         ShowWindow(slider, SW_HIDE);
  72         ShowWindow(hwndAlphaToggleBtn, SW_HIDE);
  73     }
  74 }
  75
  76 LRESULT CALLBACK CPicWindow::WinMsgHandler(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  77 {
  78     TRACKMOUSEEVENT mevt;
  79     switch (uMsg)
  80     {
  81     case WM_CREATE:
  82         {
  83             // create a slider control
  84             CreateTrackbar(hwnd);
  85             ShowWindow(m_AlphaSlider.GetWindow(), SW_HIDE);
  86             //Create the tooltips
  87             TOOLINFO ti;
  88             RECT rect;                  // for client area coordinates
  89
  90             hwndTT = CreateWindowEx(WS_EX_TOPMOST,
  91                 TOOLTIPS_CLASS,
  92                 NULL,
  93                 WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
  94                 CW_USEDEFAULT,
  95                 CW_USEDEFAULT,
  96                 CW_USEDEFAULT,
  97                 CW_USEDEFAULT,
  98                 hwnd,
  99                 NULL,
 100                 hResource,
 101                 NULL
 102                 );
 103
 104             SetWindowPos(hwndTT,
 105                 HWND_TOPMOST,
 106                 0,
 107                 0,
 108                 0,
 109                 0,
 110                 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 111
 112             ::GetClientRect(hwnd, &rect);
 113
 114             ti.cbSize = sizeof(TOOLINFO);
 115             ti.uFlags = TTF_TRACK | TTF_ABSOLUTE;
 116             ti.hwnd = hwnd;
 117             ti.hinst = hResource;
 118             ti.uId = 0;
 119             ti.lpszText = LPSTR_TEXTCALLBACK;
 120             // ToolTip control will cover the whole window
 121             ti.rect.left = rect.left;
 122             ti.rect.top = rect.top;
 123             ti.rect.right = rect.right;
 124             ti.rect.bottom = rect.bottom;
 125
 126             SendMessage(hwndTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
 127             SendMessage(hwndTT, TTM_SETMAXTIPWIDTH, 0, 600);
 128             nHSecondScrollPos = 0;
 129             nVSecondScrollPos = 0;
 130         }
 131         break;
 132     case WM_SETFOCUS:
 133     case WM_KILLFOCUS:
 134         InvalidateRect(*this, NULL, FALSE);
 135         break;
 136     case WM_ERASEBKGND:
 137         return 1;
 138         break;
 139     case WM_PAINT:
 140         Paint(hwnd);
 141         break;
 142     case WM_SIZE:
 143         PositionTrackBar();
 144         SetupScrollBars();
 145         break;
 146     case WM_VSCROLL:
 147         if ((pSecondPic)&&((HWND)lParam == m_AlphaSlider.GetWindow()))
 148         {
 149             if (LOWORD(wParam) == TB_THUMBTRACK)
 150             {
 151                 // while tracking, only redraw after 50 milliseconds
 152                 ::SetTimer(*this, TIMER_ALPHASLIDER, 50, NULL);
 153             }
 154             else
 155                 SetBlendAlpha(m_blend, SendMessage(m_AlphaSlider.GetWindow(), TBM_GETPOS, 0, 0) / 16.0f);
 156         }
 157         else
 158         {
 159             UINT nPos = HIWORD(wParam);
 160             bool bForceUpdate = false;
 161             if (LOWORD(wParam) == SB_THUMBTRACK || LOWORD(wParam) == SB_THUMBPOSITION)
 162             {
 163                 // Get true 32-bit scroll position
 164                 SCROLLINFO si;
 165                 si.cbSize = sizeof(SCROLLINFO);
 166                 si.fMask = SIF_TRACKPOS;
 167                 GetScrollInfo(*this, SB_VERT, &si);
 168                 nPos = si.nTrackPos;
 169                 bForceUpdate = true;
 170             }
 171
 172             OnVScroll(LOWORD(wParam), nPos);
 173             if (bLinkedPositions)
 174             {
 175                 pTheOtherPic->OnVScroll(LOWORD(wParam), nPos);
 176                 if (bForceUpdate)
 177                     ::UpdateWindow(*pTheOtherPic);
 178             }
 179         }
 180         break;
 181     case WM_HSCROLL:
 182         {
 183             UINT nPos = HIWORD(wParam);
 184             bool bForceUpdate = false;
 185             if (LOWORD(wParam) == SB_THUMBTRACK || LOWORD(wParam) == SB_THUMBPOSITION)
 186             {
 187                 // Get true 32-bit scroll position
 188                 SCROLLINFO si;
 189                 si.cbSize = sizeof(SCROLLINFO);
 190                 si.fMask = SIF_TRACKPOS;
 191                 GetScrollInfo(*this, SB_VERT, &si);
 192                 nPos = si.nTrackPos;
 193                 bForceUpdate = true;
 194             }
 195
 196             OnHScroll(LOWORD(wParam), nPos);
 197             if (bLinkedPositions)
 198             {
 199                 pTheOtherPic->OnHScroll(LOWORD(wParam), nPos);
 200                 if (bForceUpdate)
 201                     ::UpdateWindow(*pTheOtherPic);
 202             }
 203         }
 204         break;
 205     case WM_MOUSEWHEEL:
 206         {
 207             OnMouseWheel(GET_KEYSTATE_WPARAM(wParam), GET_WHEEL_DELTA_WPARAM(wParam));
 208             if (bFitSizes)
 209                 pTheOtherPic->OnMouseWheel(GET_KEYSTATE_WPARAM(wParam), GET_WHEEL_DELTA_WPARAM(wParam));
 210         }
 211         break;
 212     case WM_MOUSEHWHEEL:
 213         {
 214             OnMouseWheel(GET_KEYSTATE_WPARAM(wParam)|MK_SHIFT, GET_WHEEL_DELTA_WPARAM(wParam));
 215             if (bFitSizes)
 216                 pTheOtherPic->OnMouseWheel(GET_KEYSTATE_WPARAM(wParam)|MK_SHIFT, GET_WHEEL_DELTA_WPARAM(wParam));
 217         }
 218         break;
 219     case WM_LBUTTONDOWN:
 220         SetFocus(*this);
 221         ptPanStart.x = GET_X_LPARAM(lParam);
 222         ptPanStart.y = GET_Y_LPARAM(lParam);
 223         startVScrollPos = nVScrollPos;
 224         startHScrollPos = nHScrollPos;
 225         startVSecondScrollPos = nVSecondScrollPos;
 226         startHSecondScrollPos = nHSecondScrollPos;
 227         SetCapture(*this);
 228         break;
 229     case WM_LBUTTONUP:
 230         ReleaseCapture();
 231         break;
 232     case WM_MOUSELEAVE:
 233         m_lastTTPos.x = 0;
 234         m_lastTTPos.y = 0;
 235         SendMessage(hwndTT, TTM_TRACKACTIVATE, FALSE, 0);
 236         break;
 237     case WM_MOUSEMOVE:
 238         {
 239             mevt.cbSize = sizeof(TRACKMOUSEEVENT);
 240             mevt.dwFlags = TME_LEAVE;
 241             mevt.dwHoverTime = HOVER_DEFAULT;
 242             mevt.hwndTrack = *this;
 243             ::TrackMouseEvent(&mevt);
 244             POINT pt = {((int)(short)LOWORD(lParam)), ((int)(short)HIWORD(lParam))};
 245             if (pt.y < HEADER_HEIGHT)
 246             {
 247                 ClientToScreen(*this, &pt);
 248                 if ((abs(m_lastTTPos.x - pt.x) > 20)||(abs(m_lastTTPos.y - pt.y) > 10))
 249                 {
 250                     m_lastTTPos = pt;
 251                     pt.x += 15;
 252                     pt.y += 15;
 253                     SendMessage(hwndTT, TTM_TRACKPOSITION, 0, MAKELONG(pt.x, pt.y));
 254                     TOOLINFO ti = {0};
 255                     ti.cbSize = sizeof(TOOLINFO);
 256                     ti.hwnd = *this;
 257                     ti.uId = 0;
 258                     SendMessage(hwndTT, TTM_TRACKACTIVATE, TRUE, (LPARAM)&ti);
 259                 }
 260             }
 261             else
 262             {
 263                 SendMessage(hwndTT, TTM_TRACKACTIVATE, FALSE, 0);
 264                 m_lastTTPos.x = 0;
 265                 m_lastTTPos.y = 0;
 266             }
 267             if (wParam & MK_LBUTTON)
 268             {
 269                 // pan the image
 270                 int xPos = GET_X_LPARAM(lParam);
 271                 int yPos = GET_Y_LPARAM(lParam);
 272
 273                 if (wParam & MK_CONTROL)
 274                 {
 275                     nHSecondScrollPos = startHSecondScrollPos + (ptPanStart.x - xPos);
 276                     nVSecondScrollPos = startVSecondScrollPos + (ptPanStart.y - yPos);
 277                 }
 278                 else if (wParam & MK_SHIFT)
 279                 {
 280                     nHScrollPos = startHScrollPos + (ptPanStart.x - xPos);
 281                     nVScrollPos = startVScrollPos + (ptPanStart.y - yPos);
 282                 }
 283                 else
 284                 {
 285                     nHSecondScrollPos = startHSecondScrollPos + (ptPanStart.x - xPos);
 286                     nVSecondScrollPos = startVSecondScrollPos + (ptPanStart.y - yPos);
 287                     nHScrollPos = startHScrollPos + (ptPanStart.x - xPos);
 288                     nVScrollPos = startVScrollPos + (ptPanStart.y - yPos);
 289                 }
 290                 SetupScrollBars();
 291                 InvalidateRect(*this, NULL, TRUE);
 292                 UpdateWindow(*this);
 293                 if ((bLinkedPositions)&&((wParam & MK_SHIFT)==0))
 294                 {
 295                     pTheOtherPic->nHScrollPos = nHScrollPos;
 296                     pTheOtherPic->nVScrollPos = nVScrollPos;
 297                     pTheOtherPic->SetupScrollBars();
 298                     InvalidateRect(*pTheOtherPic, NULL, TRUE);
 299                     UpdateWindow(*pTheOtherPic);
 300                 }
 301             }
 302         }
 303         break;
 304     case WM_SETCURSOR:
 305         {
 306             // we show a hand cursor if the image can be dragged,
 307             // and a hand-down cursor if the image is currently dragged
 308             if ((*this == (HWND)wParam)&&(LOWORD(lParam)==HTCLIENT))
 309             {
 310                 RECT rect;
 311                 GetClientRect(&rect);
 312                 LONG width = picture.m_Width;
 313                 LONG height = picture.m_Height;
 314                 if (pSecondPic)
 315                 {
 316                     width = max(width, pSecondPic->m_Width);
 317                     height = max(height, pSecondPic->m_Height);
 318                 }
 319
 320                 if ((GetKeyState(VK_LBUTTON)&0x8000)||(HIWORD(lParam) == WM_LBUTTONDOWN))
 321                 {
 322                     SetCursor(curHandDown);
 323                 }
 324                 else
 325                 {
 326                     SetCursor(curHand);
 327                 }
 328                 return TRUE;
 329             }
 330             return DefWindowProc(hwnd, uMsg, wParam, lParam);
 331         }
 332         break;
 333     case WM_DROPFILES:
 334         {
 335             HDROP hDrop = (HDROP)wParam;
 336             TCHAR szFileName[MAX_PATH];
 337             // we only use the first file dropped (if multiple files are dropped)
 338             if (DragQueryFile(hDrop, 0, szFileName, _countof(szFileName)))
 339             {
 340                 SetPic(szFileName, _T(""), bMainPic);
 341                 FitImageInWindow();
 342                 InvalidateRect(*this, NULL, TRUE);
 343             }
 344         }
 345         break;
 346     case WM_COMMAND:
 347         {
 348             switch (LOWORD(wParam))
 349             {
 350             case LEFTBUTTON_ID:
 351                 {
 352                     PrevImage();
 353                     if (bLinkedPositions)
 354                         pTheOtherPic->PrevImage();
 355                     return 0;
 356                 }
 357                 break;
 358             case RIGHTBUTTON_ID:
 359                 {
 360                     NextImage();
 361                     if (bLinkedPositions)
 362                         pTheOtherPic->NextImage();
 363                     return 0;
 364                 }
 365                 break;
 366             case PLAYBUTTON_ID:
 367                 {
 368                     bPlaying = !bPlaying;
 369                     Animate(bPlaying);
 370                     if (bLinkedPositions)
 371                         pTheOtherPic->Animate(bPlaying);
 372                     return 0;
 373                 }
 374                 break;
 375             case ALPHATOGGLEBUTTON_ID:
 376                 {
 377                     WORD msg = HIWORD(wParam);
 378                     switch (msg)
 379                     {
 380                     case BN_DOUBLECLICKED:
 381                         {
 382                             SendMessage(hwndAlphaToggleBtn, BM_SETSTATE, 1, 0);
 383                             SetTimer(*this, ID_ALPHATOGGLETIMER, 1000, NULL);
 384                         }
 385                         break;
 386                     case BN_CLICKED:
 387                         KillTimer(*this, ID_ALPHATOGGLETIMER);
 388                         ToggleAlpha();
 389                         break;
 390                     }
 391                     return 0;
 392                 }
 393                 break;
 394             case BLENDALPHA_ID:
 395                 {
 396                     m_blend = BLEND_ALPHA;
 397                     PositionTrackBar();
 398                     InvalidateRect(*this, NULL, TRUE);
 399                 }
 400                 break;
 401             case BLENDXOR_ID:
 402                 {
 403                     m_blend = BLEND_XOR;
 404                     PositionTrackBar();
 405                     InvalidateRect(*this, NULL, TRUE);
 406                 }
 407                 break;
 408             }
 409         }
 410         break;
 411     case WM_TIMER:
 412         {
 413             switch (wParam)
 414             {
 415             case ID_ANIMATIONTIMER:
 416                 {
 417                     nCurrentFrame++;
 418                     if (nCurrentFrame > picture.GetNumberOfFrames(0))
 419                         nCurrentFrame = 1;
 420                     long delay = picture.SetActiveFrame(nCurrentFrame);
 421                     delay = max(100, delay);
 422                     SetTimer(*this, ID_ANIMATIONTIMER, delay, NULL);
 423                     InvalidateRect(*this, NULL, FALSE);
 424                 }
 425                 break;
 426             case TIMER_ALPHASLIDER:
 427                 {
 428                     SetBlendAlpha(m_blend, SendMessage(m_AlphaSlider.GetWindow(), TBM_GETPOS, 0, 0)/16.0f);
 429                     KillTimer(*this, TIMER_ALPHASLIDER);
 430                 }
 431                 break;
 432             case ID_ALPHATOGGLETIMER:
 433                 {
 434                     ToggleAlpha();
 435                 }
 436                 break;
 437             }
 438         }
 439         break;
 440     case WM_NOTIFY:
 441         {
 442             LPNMHDR pNMHDR = (LPNMHDR)lParam;
 443             if (pNMHDR->code == TTN_GETDISPINFO)
 444             {
 445                 if (pNMHDR->hwndFrom == m_AlphaSlider.GetWindow())
 446                 {
 447                     LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT) lParam;
 448                     lpttt->hinst = hResource;
 449                     TCHAR stringbuf[MAX_PATH] = {0};
 450                     _stprintf_s(stringbuf, _T("%i%% alpha"), (int)(SendMessage(m_AlphaSlider.GetWindow(),TBM_GETPOS,0,0)/16.0f*100.0f));
 451                     _tcscpy_s(lpttt->lpszText, 80, stringbuf);
 452                 }
 453                 else if (pNMHDR->idFrom == (UINT_PTR)hwndAlphaToggleBtn)
 454                 {
 455                     _stprintf_s(m_wszTip, (TCHAR const *)ResString(hResource, IDS_ALPHABUTTONTT), (int)(SendMessage(m_AlphaSlider.GetWindow(),TBM_GETPOS,0,0)/16.0f*100.0f));
 456                     if (pNMHDR->code == TTN_NEEDTEXTW)
 457                     {
 458                         NMTTDISPINFOW* pTTTW = (NMTTDISPINFOW*)pNMHDR;
 459                         pTTTW->lpszText = m_wszTip;
 460                     }
 461                     else
 462                     {
 463                         NMTTDISPINFOA* pTTTA = (NMTTDISPINFOA*)pNMHDR;
 464                         pTTTA->lpszText = m_szTip;
 465                         ::WideCharToMultiByte(CP_ACP, 0, m_wszTip, -1, m_szTip, 8192, NULL, NULL);
 466                     }
 467                 }
 468                 else
 469                 {
 470                     BuildInfoString(m_wszTip, _countof(m_wszTip), true);
 471                     if (pNMHDR->code == TTN_NEEDTEXTW)
 472                     {
 473                         NMTTDISPINFOW* pTTTW = (NMTTDISPINFOW*)pNMHDR;
 474                         pTTTW->lpszText = m_wszTip;
 475                     }
 476                     else
 477                     {
 478                         NMTTDISPINFOA* pTTTA = (NMTTDISPINFOA*)pNMHDR;
 479                         pTTTA->lpszText = m_szTip;
 480                         ::WideCharToMultiByte(CP_ACP, 0, m_wszTip, -1, m_szTip, 8192, NULL, NULL);
 481                     }
 482                 }
 483             }
 484         }
 485         break;
 486     case WM_DESTROY:
 487         DestroyIcon(hLeft);
 488         DestroyIcon(hRight);
 489         DestroyIcon(hPlay);
 490         DestroyIcon(hStop);
 491         bWindowClosed = TRUE;
 492         break;
 493     default:
 494         return DefWindowProc(hwnd, uMsg, wParam, lParam);
 495     }
 496
 497     return 0;
 498 };
 499
 500 void CPicWindow::NextImage()
 501 {
 502     nCurrentDimension++;
 503     if (nCurrentDimension > picture.GetNumberOfDimensions())
 504         nCurrentDimension = picture.GetNumberOfDimensions();
 505     nCurrentFrame++;
 506     if (nCurrentFrame > picture.GetNumberOfFrames(0))
 507         nCurrentFrame = picture.GetNumberOfFrames(0);
 508     picture.SetActiveFrame(nCurrentFrame >= nCurrentDimension ? nCurrentFrame : nCurrentDimension);
 509     InvalidateRect(*this, NULL, FALSE);
 510     PositionChildren();
 511 }
 512
 513 void CPicWindow::PrevImage()
 514 {
 515     nCurrentDimension--;
 516     if (nCurrentDimension < 1)
 517         nCurrentDimension = 1;
 518     nCurrentFrame--;
 519     if (nCurrentFrame < 1)
 520         nCurrentFrame = 1;
 521     picture.SetActiveFrame(nCurrentFrame >= nCurrentDimension ? nCurrentFrame : nCurrentDimension);
 522     InvalidateRect(*this, NULL, FALSE);
 523     PositionChildren();
 524 }
 525
 526 void CPicWindow::Animate(bool bStart)
 527 {
 528     if (bStart)
 529     {
 530         SendMessage(hwndPlayBtn, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hStop);
 531         SetTimer(*this, ID_ANIMATIONTIMER, 0, NULL);
 532     }
 533     else
 534     {
 535         SendMessage(hwndPlayBtn, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hPlay);
 536         KillTimer(*this, ID_ANIMATIONTIMER);
 537     }
 538 }
 539
 540 void CPicWindow::SetPic(tstring path, tstring title, bool bFirst)
 541 {
 542     bMainPic = bFirst;
 543     picpath=path;pictitle=title;
 544     picture.SetInterpolationMode(InterpolationModeHighQualityBicubic);
 545     bValid = picture.Load(picpath);
 546     nDimensions = picture.GetNumberOfDimensions();
 547     if (nDimensions)
 548         nFrames = picture.GetNumberOfFrames(0);
 549     if (bValid)
 550     {
 551         picscale = 1.0;
 552         PositionChildren();
 553         InvalidateRect(*this, NULL, FALSE);
 554     }
 555 }
 556
 557 void CPicWindow::DrawViewTitle(HDC hDC, RECT * rect)
 558 {
 559     HFONT hFont = NULL;
 560     hFont = CreateFont(-MulDiv(pSecondPic ? 8 : 10, GetDeviceCaps(hDC, LOGPIXELSY), 72), 0, 0, 0, FW_DONTCARE, false, false, false, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, DEFAULT_PITCH, _T("MS Shell Dlg"));
 561     HFONT hFontOld = (HFONT)SelectObject(hDC, (HGDIOBJ)hFont);
 562
 563     RECT textrect;
 564     textrect.left = rect->left;
 565     textrect.top = rect->top;
 566     textrect.right = rect->right;
 567     textrect.bottom = rect->top + HEADER_HEIGHT;
 568     if (HasMultipleImages())
 569         textrect.bottom += HEADER_HEIGHT;
 570
 571     COLORREF crBk, crFg;
 572     crBk = ::GetSysColor(COLOR_SCROLLBAR);
 573     crFg = ::GetSysColor(COLOR_WINDOWTEXT);
 574     SetBkColor(hDC, crBk);
 575     ::ExtTextOut(hDC, 0, 0, ETO_OPAQUE, &textrect, NULL, 0, NULL);
 576
 577     if (GetFocus() == *this)
 578         DrawEdge(hDC, &textrect, EDGE_BUMP, BF_RECT);
 579     else
 580         DrawEdge(hDC, &textrect, EDGE_ETCHED, BF_RECT);
 581
 582     SetTextColor(hDC, crFg);
 583
 584     // use the path if no title is set.
 585     tstring * title = pictitle.empty() ? &picpath : &pictitle;
 586
 587     tstring realtitle = *title;
 588     tstring imgnumstring;
 589
 590     if (HasMultipleImages())
 591     {
 592         TCHAR buf[MAX_PATH];
 593         if (nFrames > 1)
 594             _stprintf_s(buf, (const TCHAR *)ResString(hResource, IDS_DIMENSIONSANDFRAMES), nCurrentFrame, nFrames);
 595         else
 596             _stprintf_s(buf, (const TCHAR *)ResString(hResource, IDS_DIMENSIONSANDFRAMES), nCurrentDimension, nDimensions);
 597         imgnumstring = buf;
 598     }
 599
 600     SIZE stringsize;
 601     if (GetTextExtentPoint32(hDC, realtitle.c_str(), (int)realtitle.size(), &stringsize))
 602     {
 603         int nStringLength = stringsize.cx;
 604         int texttop = pSecondPic ? textrect.top + (HEADER_HEIGHT/2) - stringsize.cy : textrect.top + (HEADER_HEIGHT/2) - stringsize.cy/2;
 605         ExtTextOut(hDC,
 606             max(textrect.left + ((textrect.right-textrect.left)-nStringLength)/2, 1),
 607             texttop,
 608             ETO_CLIPPED,
 609             &textrect,
 610             realtitle.c_str(),
 611             (UINT)realtitle.size(),
 612             NULL);
 613         if (pSecondPic)
 614         {
 615             realtitle = (pictitle2.empty() ? picpath2 : pictitle2);
 616             ExtTextOut(hDC,
 617                 max(textrect.left + ((textrect.right-textrect.left)-nStringLength)/2, 1),
 618                 texttop + stringsize.cy,
 619                 ETO_CLIPPED,
 620                 &textrect,
 621                 realtitle.c_str(),
 622                 (UINT)realtitle.size(),
 623                 NULL);
 624         }
 625     }
 626     if (HasMultipleImages())
 627     {
 628         if (GetTextExtentPoint32(hDC, imgnumstring.c_str(), (int)imgnumstring.size(), &stringsize))
 629         {
 630             int nStringLength = stringsize.cx;
 631
 632             ExtTextOut(hDC,
 633                 max(textrect.left + ((textrect.right-textrect.left)-nStringLength)/2, 1),
 634                 textrect.top + HEADER_HEIGHT + (HEADER_HEIGHT/2) - stringsize.cy/2,
 635                 ETO_CLIPPED,
 636                 &textrect,
 637                 imgnumstring.c_str(),
 638                 (UINT)imgnumstring.size(),
 639                 NULL);
 640         }
 641     }
 642     SelectObject(hDC, (HGDIOBJ)hFontOld);
 643     DeleteObject(hFont);
 644 }
 645
 646 void CPicWindow::SetupScrollBars()
 647 {
 648     RECT rect;
 649     GetClientRect(&rect);
 650
 651     SCROLLINFO si = {sizeof(si)};
 652
 653     si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE | SIF_DISABLENOSCROLL;
 654
 655     double width = double(picture.m_Width)*picscale;
 656     double height = double(picture.m_Height)*picscale;
 657     if (pSecondPic)
 658     {
 659         width = max(width, double(pSecondPic->m_Width)*pTheOtherPic->GetZoom());
 660         height = max(height, double(pSecondPic->m_Height)*pTheOtherPic->GetZoom());
 661     }
 662
 663     bool bShowHScrollBar = (nHScrollPos > 0); // left of pic is left of window
 664     bShowHScrollBar      = bShowHScrollBar || (width-nHScrollPos > rect.right); // right of pic is outside right of window
 665     bShowHScrollBar      = bShowHScrollBar || (width+nHScrollPos > rect.right); // right of pic is outside right of window
 666     bool bShowVScrollBar = (nVScrollPos > 0); // top of pic is above window
 667     bShowVScrollBar      = bShowVScrollBar || (height-nVScrollPos+rect.top > rect.bottom); // bottom of pic is below window
 668     bShowVScrollBar      = bShowVScrollBar || (height+nVScrollPos+rect.top > rect.bottom); // bottom of pic is below window
 669
 670     // if the image is smaller than the window, we don't need the scrollbars
 671     ShowScrollBar(*this, SB_HORZ, bShowHScrollBar);
 672     ShowScrollBar(*this, SB_VERT, bShowVScrollBar);
 673
 674     if (bShowVScrollBar)
 675     {
 676         si.nPos  = nVScrollPos;
 677         si.nPage = rect.bottom-rect.top;
 678         if (height < rect.bottom-rect.top)
 679         {
 680             if (nVScrollPos > 0)
 681             {
 682                 si.nMin  = 0;
 683                 si.nMax  = rect.bottom+nVScrollPos-rect.top;
 684             }
 685             else
 686             {
 687                 si.nMin  = nVScrollPos;
 688                 si.nMax  = int(height);
 689             }
 690         }
 691         else
 692         {
 693             if (nVScrollPos > 0)
 694             {
 695                 si.nMin  = 0;
 696                 si.nMax  = int(max(height, rect.bottom+nVScrollPos-rect.top));
 697             }
 698             else
 699             {
 700                 si.nMin  = 0;
 701                 si.nMax  = int(height-nVScrollPos);
 702             }
 703         }
 704         SetScrollInfo(*this, SB_VERT, &si, TRUE);
 705     }
 706
 707     if (bShowHScrollBar)
 708     {
 709         si.nPos  = nHScrollPos;
 710         si.nPage = rect.right-rect.left;
 711         if (width < rect.right-rect.left)
 712         {
 713             if (nHScrollPos > 0)
 714             {
 715                 si.nMin  = 0;
 716                 si.nMax  = rect.right+nHScrollPos-rect.left;
 717             }
 718             else
 719             {
 720                 si.nMin  = nHScrollPos;
 721                 si.nMax  = int(width);
 722             }
 723         }
 724         else
 725         {
 726             if (nHScrollPos > 0)
 727             {
 728                 si.nMin  = 0;
 729                 si.nMax  = int(max(width, rect.right+nHScrollPos-rect.left));
 730             }
 731             else
 732             {
 733                 si.nMin  = 0;
 734                 si.nMax  = int(width-nHScrollPos);
 735             }
 736         }
 737         SetScrollInfo(*this, SB_HORZ, &si, TRUE);
 738     }
 739
 740     PositionChildren();
 741 }
 742
 743 void CPicWindow::OnVScroll(UINT nSBCode, UINT nPos)
 744 {
 745     RECT rect;
 746     GetClientRect(&rect);
 747
 748     switch (nSBCode)
 749     {
 750     case SB_BOTTOM:
 751         nVScrollPos = LONG(double(picture.GetHeight())*picscale);
 752         break;
 753     case SB_TOP:
 754         nVScrollPos = 0;
 755         break;
 756     case SB_LINEDOWN:
 757         nVScrollPos++;
 758         break;
 759     case SB_LINEUP:
 760         nVScrollPos--;
 761         break;
 762     case SB_PAGEDOWN:
 763         nVScrollPos += (rect.bottom-rect.top);
 764         break;
 765     case SB_PAGEUP:
 766         nVScrollPos -= (rect.bottom-rect.top);
 767         break;
 768     case SB_THUMBPOSITION:
 769         nVScrollPos = nPos;
 770         break;
 771     case SB_THUMBTRACK:
 772         nVScrollPos = nPos;
 773         break;
 774     default:
 775         return;
 776     }
 777     LONG height = LONG(double(picture.GetHeight())*picscale);
 778     if (pSecondPic)
 779     {
 780         height = max(height, LONG(double(pSecondPic->GetHeight())*picscale));
 781     }
 782     SetupScrollBars();
 783     PositionChildren();
 784     InvalidateRect(*this, NULL, TRUE);
 785 }
 786
 787 void CPicWindow::OnHScroll(UINT nSBCode, UINT nPos)
 788 {
 789     RECT rect;
 790     GetClientRect(&rect);
 791
 792     switch (nSBCode)
 793     {
 794     case SB_RIGHT:
 795         nHScrollPos = LONG(double(picture.GetWidth())*picscale);
 796         break;
 797     case SB_LEFT:
 798         nHScrollPos = 0;
 799         break;
 800     case SB_LINERIGHT:
 801         nHScrollPos++;
 802         break;
 803     case SB_LINELEFT:
 804         nHScrollPos--;
 805         break;
 806     case SB_PAGERIGHT:
 807         nHScrollPos += (rect.right-rect.left);
 808         break;
 809     case SB_PAGELEFT:
 810         nHScrollPos -= (rect.right-rect.left);
 811         break;
 812     case SB_THUMBPOSITION:
 813         nHScrollPos = nPos;
 814         break;
 815     case SB_THUMBTRACK:
 816         nHScrollPos = nPos;
 817         break;
 818     default:
 819         return;
 820     }
 821     LONG width = LONG(double(picture.GetWidth())*picscale);
 822     if (pSecondPic)
 823     {
 824         width = max(width, LONG(double(pSecondPic->GetWidth())*picscale));
 825     }
 826     SetupScrollBars();
 827     PositionChildren();
 828     InvalidateRect(*this, NULL, TRUE);
 829 }
 830
 831 void CPicWindow::OnMouseWheel(short fwKeys, short zDelta)
 832 {
 833     RECT rect;
 834     GetClientRect(&rect);
 835     LONG width = long(double(picture.m_Width)*picscale);
 836     LONG height = long(double(picture.m_Height)*picscale);
 837     if (pSecondPic)
 838     {
 839         width = max(width, long(double(pSecondPic->m_Width)*picscale));
 840         height = max(height, long(double(pSecondPic->m_Height)*picscale));
 841     }
 842     if ((fwKeys & MK_SHIFT)&&(fwKeys & MK_CONTROL)&&(pSecondPic))
 843     {
 844         // ctrl+shift+wheel: change the alpha channel
 845         float a = blendAlpha;
 846         a -= float(zDelta)/120.0f/4.0f;
 847         if (a < 0.0f)
 848             a = 0.0f;
 849         else if (a > 1.0f)
 850             a = 1.0f;
 851         SetBlendAlpha(m_blend, a);
 852     }
 853     else if (fwKeys & MK_SHIFT)
 854     {
 855         // shift means scrolling sideways
 856         OnHScroll(SB_THUMBPOSITION, GetHPos()-zDelta);
 857         if ((bLinkedPositions)&&(pTheOtherPic))
 858         {
 859             pTheOtherPic->OnHScroll(SB_THUMBPOSITION, pTheOtherPic->GetHPos()-zDelta);
 860         }
 861     }
 862     else if (fwKeys & MK_CONTROL)
 863     {
 864         // control means adjusting the scale factor
 865         Zoom(zDelta>0, true);
 866         if ((!bFitSizes)&&(pTheOtherPic)&&(!bOverlap))
 867             pTheOtherPic->Zoom(zDelta>0, true);
 868         PositionChildren();
 869         InvalidateRect(*this, NULL, FALSE);
 870         SetWindowPos(*this, NULL, 0, 0, 0, 0, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOREPOSITION|SWP_NOMOVE);
 871     }
 872     else
 873     {
 874         OnVScroll(SB_THUMBPOSITION, GetVPos()-zDelta);
 875         if ((bLinkedPositions)&&(pTheOtherPic))
 876         {
 877             pTheOtherPic->OnVScroll(SB_THUMBPOSITION, pTheOtherPic->GetVPos()-zDelta);
 878         }
 879     }
 880 }
 881
 882 void CPicWindow::GetClientRect(RECT * pRect)
 883 {
 884     ::GetClientRect(*this, pRect);
 885     pRect->top += HEADER_HEIGHT;
 886     if (HasMultipleImages())
 887     {
 888         pRect->top += HEADER_HEIGHT;
 889     }
 890     if (pSecondPic)
 891         pRect->left += SLIDER_WIDTH;
 892 }
 893
 894 void CPicWindow::GetClientRectWithScrollbars(RECT * pRect)
 895 {
 896     GetClientRect(pRect);
 897     ::GetWindowRect(*this, pRect);
 898     pRect->right = pRect->right-pRect->left;
 899     pRect->bottom = pRect->bottom-pRect->top;
 900     pRect->top = 0;
 901     pRect->left = 0;
 902     pRect->top += HEADER_HEIGHT;
 903     if (HasMultipleImages())
 904     {
 905         pRect->top += HEADER_HEIGHT;
 906     }
 907     if (pSecondPic)
 908         pRect->left += SLIDER_WIDTH;
 909 };
 910
 911
 912 void CPicWindow::SetZoom(double dZoom, bool centermouse)
 913 {
 914     // Set the interpolation mode depending on zoom
 915     double oldPicscale = picscale;
 916     double oldOtherPicscale = picscale;
 917     if (dZoom < 1.0)
 918     {   // Zoomed out, use high quality bicubic
 919         picture.SetInterpolationMode(InterpolationModeHighQualityBicubic);
 920         if (pSecondPic)
 921             pSecondPic->SetInterpolationMode(InterpolationModeHighQualityBicubic);
 922     }
 923     else if (!((int)(dZoom*100.0)%100))
 924     {   // "Even" zoom sizes should be shown w-o any interpolation
 925         picture.SetInterpolationMode(InterpolationModeNearestNeighbor);
 926         if (pSecondPic)
 927             pSecondPic->SetInterpolationMode(InterpolationModeNearestNeighbor);
 928     }
 929     else
 930     {   // Arbitrary zoomed in, use bilinear that is semi-smoothed
 931         picture.SetInterpolationMode(InterpolationModeBilinear);
 932         if (pSecondPic)
 933             pSecondPic->SetInterpolationMode(InterpolationModeBilinear);
 934     }
 935     picscale = dZoom;
 936
 937     if ((bFitSizes)&&(bMainPic))
 938     {
 939         double width, height;
 940         double zoomWidth, zoomHeight;
 941         width = double(picture.m_Width)*dZoom;
 942         height = double(picture.m_Height)*dZoom;
 943         zoomWidth = width/double(pTheOtherPic->GetPic()->m_Width);
 944         zoomHeight = height/double(pTheOtherPic->GetPic()->m_Height);
 945         oldOtherPicscale = pTheOtherPic->GetZoom();
 946         pTheOtherPic->SetZoom(min(zoomWidth, zoomHeight), false);
 947     }
 948
 949     // adjust the scrollbar positions according to the new zoom and the
 950     // mouse position: if possible, keep the pixel where the mouse pointer
 951     // is at the same position after the zoom
 952     POINT cpos;
 953     DWORD ptW = GetMessagePos();
 954     cpos.x = GET_X_LPARAM(ptW);
 955     cpos.y = GET_Y_LPARAM(ptW);
 956     ScreenToClient(*this, &cpos);
 957     RECT clientrect;
 958     GetClientRect(&clientrect);
 959     if ((PtInRect(&clientrect, cpos))&&(centermouse))
 960     {
 961         // the mouse pointer is over our window
 962         nHScrollPos = int(double(nHScrollPos + cpos.x)*(dZoom/oldPicscale))-cpos.x;
 963         nVScrollPos = int(double(nVScrollPos + cpos.y)*(dZoom/oldPicscale))-cpos.y;
 964         if (pTheOtherPic && bMainPic)
 965         {
 966             double otherzoom = pTheOtherPic->GetZoom();
 967             nHSecondScrollPos = int(double(nHSecondScrollPos + cpos.x)*(otherzoom/oldOtherPicscale))-cpos.x;
 968             nVSecondScrollPos = int(double(nVSecondScrollPos + cpos.y)*(otherzoom/oldOtherPicscale))-cpos.y;
 969         }
 970     }
 971     else
 972     {
 973         nHScrollPos = int(double(nHScrollPos + ((clientrect.right-clientrect.left)/2))*(dZoom/oldPicscale))-((clientrect.right-clientrect.left)/2);
 974         nVScrollPos = int(double(nVScrollPos + ((clientrect.bottom-clientrect.top)/2))*(dZoom/oldPicscale))-((clientrect.bottom-clientrect.top)/2);
 975         if (pTheOtherPic && bMainPic)
 976         {
 977             double otherzoom = pTheOtherPic->GetZoom();
 978             nHSecondScrollPos = int(double(nHSecondScrollPos + ((clientrect.right-clientrect.left)/2))*(otherzoom/oldOtherPicscale))-((clientrect.right-clientrect.left)/2);
 979             nVSecondScrollPos = int(double(nVSecondScrollPos + ((clientrect.bottom-clientrect.top)/2))*(otherzoom/oldOtherPicscale))-((clientrect.bottom-clientrect.top)/2);
 980         }
 981     }
 982
 983     SetupScrollBars();
 984     PositionChildren();
 985     InvalidateRect(*this, NULL, TRUE);
 986 }
 987
 988 void CPicWindow::Zoom(bool in, bool centermouse)
 989 {
 990     double zoomFactor;
 991
 992     // Find correct zoom factor and quantize picscale
 993     if (!in && picscale <= 0.2)
 994     {
 995         picscale = 0.1;
 996         zoomFactor = 0;
 997     }
 998     else if ((in && picscale < 1.0) || (!in && picscale <= 1.0))
 999     {
1000         picscale = 0.1 * RoundDouble(picscale/0.1, 0);  // Quantize to 0.1
1001         zoomFactor = 0.1;
1002     }
1003     else if ((in && picscale < 2.0) || (!in && picscale <= 2.0))
1004     {
1005         picscale = 0.25 * RoundDouble(picscale/0.25, 0);    // Quantize to 0.25
1006         zoomFactor = 0.25;
1007     }
1008     else
1009     {
1010         picscale = RoundDouble(picscale,0);
1011         zoomFactor = 1;
1012     }
1013
1014     // Set zoom
1015     if (in)
1016     {
1017         if ((pSecondPic)&&(!bFitSizes))
1018             pTheOtherPic->SetZoom(pTheOtherPic->GetZoom()+zoomFactor, false);
1019         SetZoom(picscale+zoomFactor, centermouse);
1020     }
1021     else
1022     {
1023         if ((pSecondPic)&&(!bFitSizes))
1024             pTheOtherPic->SetZoom(pTheOtherPic->GetZoom()-zoomFactor, false);
1025         SetZoom(picscale-zoomFactor, centermouse);
1026     }
1027 }
1028
1029 double CPicWindow::RoundDouble(double doValue, int nPrecision)
1030 {
1031     static const double doBase = 10.0;
1032     double doComplete5, doComplete5i;
1033
1034     doComplete5 = doValue * pow(doBase, (double) (nPrecision + 1));
1035
1036     if (doValue < 0.0)
1037     {
1038         doComplete5 -= 5.0;
1039     }
1040     else
1041     {
1042         doComplete5 += 5.0;
1043     }
1044
1045     doComplete5 /= doBase;
1046     modf(doComplete5, &doComplete5i);
1047
1048     return doComplete5i / pow(doBase, (double) nPrecision);
1049 }
1050 void CPicWindow::FitImageInWindow()
1051 {
1052     RECT rect;
1053
1054     GetClientRectWithScrollbars(&rect);
1055
1056     if (rect.right-rect.left)
1057     {
1058         double dZoom = 1.0;
1059         if (((rect.right - rect.left) > picture.m_Width+2)&&((rect.bottom - rect.top)> picture.m_Height+2))
1060         {
1061             // image is smaller than the window
1062             dZoom = 1.0;
1063         }
1064         else
1065         {
1066             // image is bigger than the window
1067             double xscale = double(rect.right-rect.left-2)/double(picture.m_Width);
1068             double yscale = double(rect.bottom-rect.top-2)/double(picture.m_Height);
1069             dZoom = min(yscale, xscale);
1070         }
1071         if (pSecondPic)
1072         {
1073             if (((rect.right - rect.left) > pSecondPic->m_Width+2)&&((rect.bottom - rect.top)> pSecondPic->m_Height+2))
1074             {
1075                 // image is smaller than the window
1076                 pTheOtherPic->SetZoom(min(1.0, dZoom), false);
1077             }
1078             else
1079             {
1080                 // image is bigger than the window
1081                 double xscale = double(rect.right-rect.left-2)/double(pSecondPic->m_Width);
1082                 double yscale = double(rect.bottom-rect.top-2)/double(pSecondPic->m_Height);
1083                 pTheOtherPic->SetZoom(min(yscale, xscale), false);
1084             }
1085             nHSecondScrollPos = 0;
1086             nVSecondScrollPos = 0;
1087         }
1088         SetZoom(dZoom, false);
1089     }
1090     CenterImage();
1091     PositionChildren();
1092     InvalidateRect(*this, NULL, TRUE);
1093 }
1094
1095 void CPicWindow::CenterImage()
1096 {
1097     RECT rect;
1098     GetClientRectWithScrollbars(&rect);
1099     double width = (double(picture.m_Width)*picscale) + 2.0;
1100     double height = (double(picture.m_Height)*picscale) + 2.0;
1101     if (pSecondPic)
1102     {
1103         width = max(width, (double(pSecondPic->m_Width)*pTheOtherPic->GetZoom()) + 2.0);
1104         height = max(height, (double(pSecondPic->m_Height)*pTheOtherPic->GetZoom()) + 2.0);
1105     }
1106
1107     bool bPicWidthBigger = (int(width) > (rect.right-rect.left));
1108     bool bPicHeightBigger = (int(height) > (rect.bottom-rect.top));
1109     // set the scroll position so that the image is drawn centered in the window
1110     // if the window is bigger than the image
1111     if (!bPicWidthBigger)
1112     {
1113         nHScrollPos = -((rect.right-rect.left+4)-int(width))/2;
1114     }
1115     if (!bPicHeightBigger)
1116     {
1117         nVScrollPos = -((rect.bottom-rect.top+4)-int(height))/2;
1118     }
1119     SetupScrollBars();
1120 }
1121
1122 void CPicWindow::FitSizes(bool bFit)
1123 {
1124     bFitSizes = bFit;
1125
1126     SetZoom(GetZoom(), false);
1127 }
1128
1129 void CPicWindow::ShowPicWithBorder(HDC hdc, const RECT &bounds, CPicture &pic, double scale)
1130 {
1131     ::SetBkColor(hdc, transparentColor);
1132     ::ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &bounds, NULL, 0, NULL);
1133
1134     RECT picrect;
1135     picrect.left =  bounds.left - nHScrollPos;
1136     picrect.top = bounds.top - nVScrollPos;
1137     if ((!bLinkedPositions || bOverlap) && (pTheOtherPic) && (&pic != &picture))
1138     {
1139         picrect.left = bounds.left - nHSecondScrollPos;
1140         picrect.top  = bounds.top - nVSecondScrollPos;
1141     }
1142     picrect.right = (picrect.left + LONG(double(pic.m_Width) * scale));
1143     picrect.bottom = (picrect.top + LONG(double(pic.m_Height) * scale));
1144
1145     pic.Show(hdc, picrect);
1146
1147     RECT border;
1148     border.left = picrect.left-1;
1149     border.top = picrect.top-1;
1150     border.right = picrect.right+1;
1151     border.bottom = picrect.bottom+1;
1152
1153     HPEN hPen = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW));
1154     HPEN hOldPen = (HPEN)SelectObject(hdc, hPen);
1155     MoveToEx(hdc, border.left, border.top, NULL);
1156     LineTo(hdc, border.left, border.bottom);
1157     LineTo(hdc, border.right, border.bottom);
1158     LineTo(hdc, border.right, border.top);
1159     LineTo(hdc, border.left, border.top);
1160     SelectObject(hdc, hOldPen);
1161     DeleteObject(hPen);
1162 }
1163
1164 void CPicWindow::Paint(HWND hwnd)
1165 {
1166     PAINTSTRUCT ps;
1167     HDC hdc;
1168     RECT rect, fullrect;
1169
1170     GetUpdateRect(hwnd, &rect, FALSE);
1171     if (IsRectEmpty(&rect))
1172         return;
1173
1174     ::GetClientRect(*this, &fullrect);
1175     hdc = BeginPaint(hwnd, &ps);
1176     {
1177         // Exclude the alpha control and button
1178         if ((pSecondPic)&&(m_blend == BLEND_ALPHA))
1179             ExcludeClipRect(hdc, 0, m_inforect.top-4, SLIDER_WIDTH, m_inforect.bottom+4);
1180
1181         CMyMemDC memDC(hdc);
1182         if ((pSecondPic)&&(m_blend != BLEND_ALPHA))
1183         {
1184             // erase the place where the alpha slider would be
1185             ::SetBkColor(memDC, transparentColor);
1186             RECT bounds = {0, m_inforect.top-4, SLIDER_WIDTH, m_inforect.bottom+4};
1187             ::ExtTextOut(memDC, 0, 0, ETO_OPAQUE, &bounds, NULL, 0, NULL);
1188         }
1189
1190         GetClientRect(&rect);
1191         if (bValid)
1192         {
1193             ShowPicWithBorder(memDC, rect, picture, picscale);
1194             if (pSecondPic)
1195             {
1196                 HDC secondhdc = CreateCompatibleDC(hdc);
1197                 HBITMAP hBitmap = CreateCompatibleBitmap(hdc, rect.right - rect.left, rect.bottom - rect.top);
1198                 HBITMAP hOldBitmap = (HBITMAP)SelectObject(secondhdc, hBitmap);
1199                 SetWindowOrgEx(secondhdc, rect.left, rect.top, NULL);
1200
1201                 if ((pSecondPic)&&(m_blend != BLEND_ALPHA))
1202                 {
1203                     // erase the place where the alpha slider would be
1204                     ::SetBkColor(secondhdc, transparentColor);
1205                     RECT bounds = {0, m_inforect.top-4, SLIDER_WIDTH, m_inforect.bottom+4};
1206                     ::ExtTextOut(secondhdc, 0, 0, ETO_OPAQUE, &bounds, NULL, 0, NULL);
1207                 }
1208                 ShowPicWithBorder(secondhdc, rect, *pSecondPic, pTheOtherPic->GetZoom());
1209
1210                 if (m_blend == BLEND_ALPHA)
1211                 {
1212                     BLENDFUNCTION blender;
1213                     blender.AlphaFormat = 0;
1214                     blender.BlendFlags = 0;
1215                     blender.BlendOp = AC_SRC_OVER;
1216                     blender.SourceConstantAlpha = (BYTE)(blendAlpha*255);
1217                     AlphaBlend(memDC,
1218                         rect.left,
1219                         rect.top,
1220                         rect.right-rect.left,
1221                         rect.bottom-rect.top,
1222                         secondhdc,
1223                         rect.left,
1224                         rect.top,
1225                         rect.right-rect.left,
1226                         rect.bottom-rect.top,
1227                         blender);
1228                 }
1229                 else if (m_blend == BLEND_XOR)
1230                 {
1231                     BitBlt(memDC,
1232                         rect.left,
1233                         rect.top,
1234                         rect.right-rect.left,
1235                         rect.bottom-rect.top,
1236                         secondhdc,
1237                         rect.left,
1238                         rect.top,
1239                         //rect.right-rect.left,
1240                         //rect.bottom-rect.top,
1241                         SRCINVERT);
1242                     InvertRect(memDC, &rect);
1243                 }
1244                 SelectObject(secondhdc, hOldBitmap);
1245                 DeleteObject(hBitmap);
1246                 DeleteDC(secondhdc);
1247             }
1248             int sliderwidth = 0;
1249             if ((pSecondPic)&&(m_blend == BLEND_ALPHA))
1250                 sliderwidth = SLIDER_WIDTH;
1251             m_inforect.left = rect.left+4+sliderwidth;
1252             m_inforect.top = rect.top;
1253             m_inforect.right = rect.right+sliderwidth;
1254             m_inforect.bottom = rect.bottom;
1255
1256             SetBkColor(memDC, transparentColor);
1257             if (bShowInfo)
1258             {
1259                 TCHAR infostring[8192];
1260                 BuildInfoString(infostring, _countof(infostring), false);
1261                 // set the font
1262                 NONCLIENTMETRICS metrics = {0};
1263                 metrics.cbSize = sizeof(NONCLIENTMETRICS);
1264
1265             #if (WINVER >= 0x600)
1266                 if (!SysInfo::Instance().IsVistaOrLater())
1267                 {
1268                     metrics.cbSize -= sizeof(int);  // subtract the size of the iPaddedBorderWidth member which is not available on XP
1269                 }
1270             #endif
1271
1272                 SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &metrics, FALSE);
1273                 HFONT hFont = CreateFontIndirect(&metrics.lfStatusFont);
1274                 HFONT hFontOld = (HFONT)SelectObject(memDC, (HGDIOBJ)hFont);
1275                 // find out how big the rectangle for the text has to be
1276                 DrawText(memDC, infostring, -1, &m_inforect, DT_EDITCONTROL | DT_EXPANDTABS | DT_LEFT | DT_VCENTER | DT_CALCRECT);
1277
1278                 // the text should be drawn with a four pixel offset to the window borders
1279                 m_inforect.top = rect.bottom - (m_inforect.bottom-m_inforect.top) - 4;
1280                 m_inforect.bottom = rect.bottom-4;
1281
1282                 // first draw an edge rectangle
1283                 RECT edgerect;
1284                 edgerect.left = m_inforect.left-4;
1285                 edgerect.top = m_inforect.top-4;
1286                 edgerect.right = m_inforect.right+4;
1287                 edgerect.bottom = m_inforect.bottom+4;
1288                 ::ExtTextOut(memDC, 0, 0, ETO_OPAQUE, &edgerect, NULL, 0, NULL);
1289                 DrawEdge(memDC, &edgerect, EDGE_BUMP, BF_RECT | BF_SOFT);
1290
1291                 SetTextColor(memDC, GetSysColor(COLOR_WINDOWTEXT));
1292                 DrawText(memDC, infostring, -1, &m_inforect, DT_EDITCONTROL | DT_EXPANDTABS | DT_LEFT | DT_VCENTER);
1293                 SelectObject(memDC, (HGDIOBJ)hFontOld);
1294                 DeleteObject(hFont);
1295             }
1296         }
1297         else
1298         {
1299             SetBkColor(memDC, ::GetSysColor(COLOR_WINDOW));
1300             ::ExtTextOut(memDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
1301             SIZE stringsize;
1302             ResString str = ResString(hResource, IDS_INVALIDIMAGEINFO);
1303             if (GetTextExtentPoint32(memDC, str, (int)_tcslen(str), &stringsize))
1304             {
1305                 int nStringLength = stringsize.cx;
1306
1307                 ExtTextOut(memDC,
1308                     max(rect.left + ((rect.right-rect.left)-nStringLength)/2, 1),
1309                     rect.top + ((rect.bottom-rect.top) - stringsize.cy)/2,
1310                     ETO_CLIPPED,
1311                     &rect,
1312                     str,
1313                     (UINT)_tcslen(str),
1314                     NULL);
1315             }
1316         }
1317         DrawViewTitle(memDC, &fullrect);
1318     }
1319     EndPaint(hwnd, &ps);
1320 }
1321
1322 bool CPicWindow::CreateButtons()
1323 {
1324     // Ensure that the common control DLL is loaded.
1325     INITCOMMONCONTROLSEX icex;
1326     icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
1327     icex.dwICC  = ICC_BAR_CLASSES | ICC_WIN95_CLASSES;
1328     InitCommonControlsEx(&icex);
1329
1330     hwndLeftBtn = CreateWindowEx(0,
1331                                 _T("BUTTON"),
1332                                 (LPCTSTR)NULL,
1333                                 WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_ICON | BS_FLAT,
1334                                 0, 0, 0, 0,
1335                                 (HWND)*this,
1336                                 (HMENU)LEFTBUTTON_ID,
1337                                 hResource,
1338                                 NULL);
1339     if (hwndLeftBtn == INVALID_HANDLE_VALUE)
1340         return false;
1341     hLeft = (HICON)LoadImage(hResource, MAKEINTRESOURCE(IDI_BACKWARD), IMAGE_ICON, 16, 16, LR_LOADTRANSPARENT);
1342     SendMessage(hwndLeftBtn, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hLeft);
1343     hwndRightBtn = CreateWindowEx(0,
1344                                 _T("BUTTON"),
1345                                 (LPCTSTR)NULL,
1346                                 WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_ICON | BS_FLAT,
1347                                 0, 0, 0, 0,
1348                                 *this,
1349                                 (HMENU)RIGHTBUTTON_ID,
1350                                 hResource,
1351                                 NULL);
1352     if (hwndRightBtn == INVALID_HANDLE_VALUE)
1353         return false;
1354     hRight = (HICON)LoadImage(hResource, MAKEINTRESOURCE(IDI_FORWARD), IMAGE_ICON, 16, 16, LR_LOADTRANSPARENT);
1355     SendMessage(hwndRightBtn, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hRight);
1356     hwndPlayBtn = CreateWindowEx(0,
1357                                 _T("BUTTON"),
1358                                 (LPCTSTR)NULL,
1359                                 WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_ICON | BS_FLAT,
1360                                 0, 0, 0, 0,
1361                                 *this,
1362                                 (HMENU)PLAYBUTTON_ID,
1363                                 hResource,
1364                                 NULL);
1365     if (hwndPlayBtn == INVALID_HANDLE_VALUE)
1366         return false;
1367     hPlay = (HICON)LoadImage(hResource, MAKEINTRESOURCE(IDI_START), IMAGE_ICON, 16, 16, LR_LOADTRANSPARENT);
1368     hStop = (HICON)LoadImage(hResource, MAKEINTRESOURCE(IDI_STOP), IMAGE_ICON, 16, 16, LR_LOADTRANSPARENT);
1369     SendMessage(hwndPlayBtn, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hPlay);
1370     hwndAlphaToggleBtn = CreateWindowEx(0,
1371                                 _T("BUTTON"),
1372                                 (LPCTSTR)NULL,
1373                                 WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_ICON | BS_FLAT | BS_NOTIFY | BS_PUSHLIKE,
1374                                 0, 0, 0, 0,
1375                                 (HWND)*this,
1376                                 (HMENU)ALPHATOGGLEBUTTON_ID,
1377                                 hResource,
1378                                 NULL);
1379     if (hwndAlphaToggleBtn == INVALID_HANDLE_VALUE)
1380         return false;
1381     hAlphaToggle = (HICON)LoadImage(hResource, MAKEINTRESOURCE(IDI_ALPHATOGGLE), IMAGE_ICON, 16, 16, LR_LOADTRANSPARENT);
1382     SendMessage(hwndAlphaToggleBtn, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hAlphaToggle);
1383
1384     TOOLINFO ti = {0};
1385     ti.cbSize = sizeof(TOOLINFO);
1386     ti.uFlags = TTF_IDISHWND|TTF_SUBCLASS;
1387     ti.hwnd = *this;
1388     ti.hinst = hResource;
1389     ti.uId = (UINT_PTR)hwndAlphaToggleBtn;
1390     ti.lpszText = LPSTR_TEXTCALLBACK;
1391     // ToolTip control will cover the whole window
1392     ti.rect.left = 0;
1393     ti.rect.top = 0;
1394     ti.rect.right = 0;
1395     ti.rect.bottom = 0;
1396     SendMessage(hwndTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
1397
1398     return true;
1399 }
1400
1401 void CPicWindow::PositionChildren()
1402 {
1403     RECT rect;
1404     ::GetClientRect(*this, &rect);
1405     if (HasMultipleImages())
1406     {
1407         SetWindowPos(hwndLeftBtn, HWND_TOP, rect.left+3, rect.top + HEADER_HEIGHT + (HEADER_HEIGHT-16)/2, 16, 16, SWP_FRAMECHANGED|SWP_SHOWWINDOW);
1408         SetWindowPos(hwndRightBtn, HWND_TOP, rect.left+23, rect.top + HEADER_HEIGHT + (HEADER_HEIGHT-16)/2, 16, 16, SWP_FRAMECHANGED|SWP_SHOWWINDOW);
1409         if (nFrames > 1)
1410             SetWindowPos(hwndPlayBtn, HWND_TOP, rect.left+43, rect.top + HEADER_HEIGHT + (HEADER_HEIGHT-16)/2, 16, 16, SWP_FRAMECHANGED|SWP_SHOWWINDOW);
1411         else
1412             ShowWindow(hwndPlayBtn, SW_HIDE);
1413     }
1414     else
1415     {
1416         ShowWindow(hwndLeftBtn, SW_HIDE);
1417         ShowWindow(hwndRightBtn, SW_HIDE);
1418         ShowWindow(hwndPlayBtn, SW_HIDE);
1419     }
1420     PositionTrackBar();
1421 }
1422
1423 bool CPicWindow::HasMultipleImages()
1424 {
1425     return (((nDimensions > 1)||(nFrames > 1))&&(pSecondPic == NULL));
1426 }
1427
1428 void CPicWindow::CreateTrackbar(HWND hwndParent)
1429 {
1430     HWND hwndTrack = CreateWindowEx(
1431         0,                                  // no extended styles
1432         TRACKBAR_CLASS,                     // class name
1433         _T("Trackbar Control"),             // title (caption)
1434         WS_CHILD | WS_VISIBLE | TBS_VERT | TBS_TOOLTIPS | TBS_AUTOTICKS,                // style
1435         10, 10,                             // position
1436         200, 30,                            // size
1437         hwndParent,                         // parent window
1438         (HMENU)TRACKBAR_ID,                 // control identifier
1439         hInst,                              // instance
1440         NULL                                // no WM_CREATE parameter
1441         );
1442
1443     SendMessage(hwndTrack, TBM_SETRANGE,
1444         (WPARAM) TRUE,                  // redraw flag
1445         (LPARAM) MAKELONG(0, 16));      // min. & max. positions
1446     SendMessage(hwndTrack, TBM_SETTIPSIDE,
1447         (WPARAM) TBTS_TOP,
1448         (LPARAM) 0);
1449
1450     m_AlphaSlider.ConvertTrackbarToNice(hwndTrack);
1451 }
1452
1453 void CPicWindow::BuildInfoString(TCHAR * buf, int size, bool bTooltip)
1454 {
1455     // Unfortunately, we need two different strings for the tooltip
1456     // and the info box. Because the tooltips use a different tab size
1457     // than ExtTextOut(), and to keep the output aligned we therefore
1458     // need two different strings.
1459     // Note: some translations could end up with two identical strings, but
1460     // in English we need two - even if we wouldn't need two in English, some
1461     // translation might then need two again.
1462     if (pSecondPic)
1463     {
1464         _stprintf_s(buf, size,
1465             (TCHAR const *)ResString(hResource, bTooltip ? IDS_DUALIMAGEINFOTT : IDS_DUALIMAGEINFO),
1466             picture.GetFileSizeAsText().c_str(), picture.GetFileSizeAsText(false).c_str(),
1467             picture.m_Width, picture.m_Height,
1468             picture.GetHorizontalResolution(), picture.GetVerticalResolution(),
1469             picture.m_ColorDepth,
1470             (UINT)(GetZoom()*100.0),
1471             pSecondPic->GetFileSizeAsText().c_str(), pSecondPic->GetFileSizeAsText(false).c_str(),
1472             pSecondPic->m_Width, pSecondPic->m_Height,
1473             pSecondPic->GetHorizontalResolution(), pSecondPic->GetVerticalResolution(),
1474             pSecondPic->m_ColorDepth,
1475             (UINT)(pTheOtherPic->GetZoom()*100.0));
1476     }
1477     else
1478     {
1479         _stprintf_s(buf, size,
1480             (TCHAR const *)ResString(hResource, bTooltip ? IDS_IMAGEINFOTT : IDS_IMAGEINFO),
1481             picture.GetFileSizeAsText().c_str(), picture.GetFileSizeAsText(false).c_str(),
1482             picture.m_Width, picture.m_Height,
1483             picture.GetHorizontalResolution(), picture.GetVerticalResolution(),
1484             picture.m_ColorDepth,
1485             (UINT)(GetZoom()*100.0));
1486     }
1487 }