window.cc

   1 /*
   2  * Copyright (c) 2001, 2002, 2003 Gary R. Van Sickle.
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     A copy of the GNU General Public License can be found at
  10  *     http://www.gnu.org/
  11  *
  12  * Written by Gary R. Van Sickle <g.r.vansickle@worldnet.att.net>
  13  *
  14  */
  15
  16 // This is the implementation of the Window class.  It serves both as a window class
  17 // in its own right and as a base class for other window-like classes (e.g. PropertyPage,
  18 // PropSheet).
  19
  20 #include "win32.h"
  21 #include "window.h"
  22 #include "RECTWrapper.h"
  23 #include "msg.h"
  24 #include "resource.h"
  25
  26 ATOM Window::WindowClassAtom = 0;
  27 HINSTANCE Window::AppInstance = NULL;
  28
  29 Window::Window ()
  30 {
  31   WindowHandle = NULL;
  32   Parent = NULL;
  33   TooltipHandle = NULL;
  34   BusyCount = 0;
  35   BusyCursor = NULL;
  36
  37 }
  38
  39 Window::~Window ()
  40 {
  41   // Delete any fonts we created.
  42   for (unsigned int i = 0; i < Fonts.size (); i++)
  43     DeleteObject (Fonts[i]);
  44
  45   // shut down the tooltip control, if activated
  46   if (TooltipHandle)
  47     DestroyWindow (TooltipHandle);
  48
  49   // FIXME: Maybe do some reference counting and do this Unregister
  50   // when there are no more of us left.  Not real critical unless
  51   // we're in a DLL which we're not right now.
  52   //UnregisterClass(WindowClassAtom, InstanceHandle);
  53 }
  54
  55 LRESULT CALLBACK
  56 Window::FirstWindowProcReflector (HWND hwnd, UINT uMsg, WPARAM wParam,
  57                                   LPARAM lParam)
  58 {
  59   Window *wnd = NULL;
  60
  61   if(uMsg == WM_NCCREATE)
  62     {
  63       // This is the first message a window gets (so MSDN says anyway).
  64       // Take this opportunity to "link" the HWND to the 'this' ptr, steering
  65       // messages to the class instance's WindowProc().
  66       wnd = reinterpret_cast<Window *>(((LPCREATESTRUCT)lParam)->lpCreateParams);
  67
  68       // Set a backreference to this class instance in the HWND.
  69       SetWindowLongPtr (hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(wnd));
  70
  71       // Set a new WindowProc now that we have the peliminaries done.
  72       // We could instead simply do the contents of Window::WindowProcReflector
  73       // in the 'else' clause below, but this way we eliminate an unnecessary 'if/else' on
  74       // every message.  Yeah, it's probably not worth the trouble.
  75       SetWindowLongPtr (hwnd, GWLP_WNDPROC, (LONG_PTR) & Window::WindowProcReflector);
  76       // Finally, store the window handle in the class.
  77       wnd->WindowHandle = hwnd;
  78     }
  79   else
  80     {
  81       // Should never get here.
  82       Log (LOG_PLAIN) << "Warning: Unexpected windows message " << uMsg
  83                       << "received early in window initialization."
  84                       << endLog;
  85     }
  86
  87   return wnd->WindowProc (uMsg, wParam, lParam);
  88 }
  89
  90 LRESULT CALLBACK
  91 Window::WindowProcReflector (HWND hwnd, UINT uMsg, WPARAM wParam,
  92                              LPARAM lParam)
  93 {
  94   Window *This;
  95
  96   // Get our this pointer
  97   This = reinterpret_cast<Window *>(GetWindowLongPtr (hwnd, GWLP_USERDATA));
  98
  99   return This->WindowProc (uMsg, wParam, lParam);
 100 }
 101
 102 bool
 103 Window::Create (Window * parent, DWORD Style)
 104 {
 105   // First register the window class, if we haven't already
 106   if (registerWindowClass () == false)
 107     {
 108       // Registration failed
 109       return false;
 110     }
 111
 112   // Save our parent, we'll probably need it eventually.
 113   Parent = parent;
 114
 115   // Create the window instance
 116   WindowHandle = CreateWindowEx (
 117                    // Extended Style
 118                    0,
 119                    "MainWindowClass",   //MAKEINTATOM(WindowClassAtom),     // window class atom (name)
 120                                "Hello", // no title-bar string yet
 121                                // Style bits
 122                                Style,
 123                                // Default positions and size
 124                                CW_USEDEFAULT,
 125                                CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 126                                // Parent Window
 127                                parent ==
 128                                NULL ? (HWND) NULL : parent->GetHWND (),
 129                                // use class menu
 130                                (HMENU) NULL,
 131                                // The application instance
 132                                GetInstance (),
 133                                // The this ptr, which we'll use to set up the WindowProc reflection.
 134                                (LPVOID) this);
 135
 136   if (WindowHandle == NULL)
 137     {
 138       // Failed
 139       return false;
 140     }
 141
 142   return true;
 143 }
 144
 145 bool
 146 Window::registerWindowClass ()
 147 {
 148   if (WindowClassAtom == 0)
 149     {
 150       // We're not registered yet
 151       WNDCLASSEX
 152         wc;
 153
 154       wc.cbSize = sizeof (wc);
 155       // Some sensible style defaults
 156       wc.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
 157       // Our default window procedure.  This replaces itself
 158       // on the first call with the simpler Window::WindowProcReflector().
 159       wc.lpfnWndProc = Window::FirstWindowProcReflector;
 160       // No class bytes
 161       wc.cbClsExtra = 0;
 162       // One pointer to REFLECTION_INFO in the extra window instance bytes
 163       wc.cbWndExtra = 4;
 164       // The app instance
 165       wc.hInstance = GetInstance ();
 166       // Use a bunch of system defaults for the GUI elements
 167       wc.hIcon = NULL;
 168       wc.hIconSm = NULL;
 169       wc.hCursor = NULL;
 170       wc.hbrBackground = (HBRUSH) (COLOR_BACKGROUND + 1);
 171       // No menu
 172       wc.lpszMenuName = NULL;
 173       // We'll get a little crazy here with the class name
 174       wc.lpszClassName = "MainWindowClass";
 175
 176       // All set, try to register
 177       WindowClassAtom = RegisterClassEx (&wc);
 178
 179       if (WindowClassAtom == 0)
 180         {
 181           // Failed
 182           return false;
 183         }
 184     }
 185
 186   // We're registered, or already were before the call,
 187   // return success in either case.
 188   return true;
 189 }
 190
 191 void
 192 Window::Show (int State)
 193 {
 194   ::ShowWindow (WindowHandle, State);
 195 }
 196
 197 RECT
 198 Window::GetWindowRect() const
 199 {
 200   RECT retval;
 201   ::GetWindowRect(WindowHandle, &retval);
 202   return retval;
 203 }
 204
 205 RECT
 206 Window::GetClientRect() const
 207 {
 208   RECT retval;
 209   ::GetClientRect(WindowHandle, &retval);
 210   return retval;
 211 }
 212
 213 bool
 214 Window::MoveWindow(long x, long y, long w, long h, bool Repaint)
 215 {
 216   return ::MoveWindow (WindowHandle, x, y, w, h, Repaint);
 217 }
 218
 219 bool
 220 Window::MoveWindow(const RECTWrapper &r, bool Repaint)
 221 {
 222   return ::MoveWindow (WindowHandle, r.left, r.top, r.width(), r.height(), Repaint);
 223 }
 224
 225 void
 226 Window::CenterWindow ()
 227 {
 228   RECT WindowRect, ParentRect;
 229   int WindowWidth, WindowHeight;
 230   POINT p;
 231
 232   // Get the window rectangle
 233   WindowRect = GetWindowRect ();
 234
 235   if (GetParent () == NULL)
 236     {
 237       // Center on desktop window
 238       ::GetWindowRect (GetDesktopWindow (), &ParentRect);
 239     }
 240   else
 241     {
 242       // Center on client area of parent
 243       ::GetClientRect (GetParent ()->GetHWND (), &ParentRect);
 244     }
 245
 246   WindowWidth = WindowRect.right - WindowRect.left;
 247   WindowHeight = WindowRect.bottom - WindowRect.top;
 248
 249   // Find center of area we're centering on
 250   p.x = (ParentRect.right - ParentRect.left) / 2;
 251   p.y = (ParentRect.bottom - ParentRect.top) / 2;
 252
 253   // Convert that to screen coords
 254   if (GetParent () == NULL)
 255     {
 256       ClientToScreen (GetDesktopWindow (), &p);
 257     }
 258   else
 259     {
 260       ClientToScreen (GetParent ()->GetHWND (), &p);
 261     }
 262
 263   // Calculate new top left corner for window
 264   p.x -= WindowWidth / 2;
 265   p.y -= WindowHeight / 2;
 266
 267   // And finally move the window
 268   MoveWindow (p.x, p.y, WindowWidth, WindowHeight);
 269 }
 270
 271 LRESULT
 272 Window::WindowProc (UINT uMsg, WPARAM wParam, LPARAM lParam)
 273 {
 274   return DefWindowProc (WindowHandle, uMsg, wParam, lParam);
 275 }
 276
 277 bool
 278 Window::MessageLoop ()
 279 {
 280   MSG
 281     msg;
 282
 283   while (GetMessage (&msg, NULL, 0, 0) != 0
 284          && GetMessage (&msg, (HWND) NULL, 0, 0) != -1)
 285     {
 286       if (!IsWindow (WindowHandle) || !IsDialogMessage (WindowHandle, &msg))
 287         {
 288           TranslateMessage (&msg);
 289           DispatchMessage (&msg);
 290         }
 291     }
 292
 293   return true;
 294 }
 295
 296 void
 297 Window::PostMessageNow (UINT uMsg, WPARAM wParam, LPARAM lParam)
 298 {
 299   ::PostMessage (GetHWND (), uMsg, wParam, lParam);
 300 }
 301
 302 UINT
 303 Window::IsButtonChecked (int nIDButton) const
 304 {
 305   return ::IsDlgButtonChecked (GetHWND (), nIDButton);
 306 }
 307
 308 bool
 309 Window::SetDlgItemFont (int id, const TCHAR * fontname, int Pointsize,
 310                           int Weight, bool Italic, bool Underline,
 311                           bool Strikeout)
 312 {
 313   HWND ctrl;
 314
 315   ctrl = GetDlgItem (id);
 316   if (ctrl == NULL)
 317     {
 318       // Couldn't get that ID
 319       return false;
 320     }
 321
 322   // We need the DC for the point size calculation.
 323   HDC hdc = GetDC (ctrl);
 324
 325   // Create the font.  We have to keep it around until the dialog item
 326   // goes away - basically until we're destroyed.
 327   HFONT hfnt;
 328   hfnt =
 329     CreateFont (-MulDiv (Pointsize, GetDeviceCaps (hdc, LOGPIXELSY), 72), 0,
 330                 0, 0, Weight, Italic ? TRUE : FALSE,
 331                 Underline ? TRUE : FALSE, Strikeout ? TRUE : FALSE,
 332                 ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS,
 333                 PROOF_QUALITY, DEFAULT_PITCH | FF_DONTCARE, fontname);
 334   if (hfnt == NULL)
 335     {
 336       // Font creation failed
 337       return false;
 338     }
 339
 340   // Set the new font, and redraw any text which was already in the item.
 341   SendMessage (ctrl, WM_SETFONT, (WPARAM) hfnt, TRUE);
 342
 343   // Store the handle so that we can DeleteObject() it in dtor
 344   Fonts.push_back (hfnt);
 345
 346   return true;
 347 }
 348
 349 void
 350 Window::SetWindowText (const std::wstring& s)
 351 {
 352   ::SetWindowTextW (WindowHandle, s.c_str ());
 353 }
 354
 355 RECT
 356 Window::ScreenToClient(const RECT &r) const
 357 {
 358   POINT tl;
 359   POINT br;
 360
 361   tl.y = r.top;
 362   tl.x = r.left;
 363   ::ScreenToClient(GetHWND(), &tl);
 364   br.y = r.bottom;
 365   br.x = r.right;
 366   ::ScreenToClient(GetHWND(), &br);
 367
 368   RECT ret;
 369
 370   ret.top = tl.y;
 371   ret.left = tl.x;
 372   ret.bottom = br.y;
 373   ret.right = br.x;
 374
 375   return ret;
 376 }
 377
 378 void
 379 Window::ActivateTooltips ()
 380 // initialization of the tooltip capability
 381 {
 382   if (TooltipHandle != NULL)
 383     return;     // already initialized
 384
 385   // create a window for the tool tips - will be invisible most of the time
 386   if ((TooltipHandle = CreateWindowEx (0, (LPCTSTR) TOOLTIPS_CLASS, NULL,
 387         WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP, CW_USEDEFAULT,
 388         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, GetHWND (),
 389         (HMENU) 0, GetInstance (), (LPVOID) 0)) == (HWND) NULL)
 390     {
 391       Log (LOG_PLAIN) << "Warning: call to CreateWindowEx failed when "
 392               "initializing tooltips.  Error = %8.8x" << GetLastError ()
 393               << endLog;
 394       return;
 395     }
 396
 397   // must be topmost so that tooltips will display on top
 398   SetWindowPos (TooltipHandle, HWND_TOPMOST, 0, 0, 0, 0,
 399               SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 400
 401   // some of our tooltips are lengthy, and will disappear before they can be
 402   // read with the default windows delay, so we set a long (30s) delay here.
 403   SendMessage (TooltipHandle, TTM_SETDELAYTIME, TTDT_AUTOPOP,
 404               (LPARAM) MAKELONG (30000, 0));
 405 }
 406
 407 void
 408 Window::SetTooltipState (bool b)
 409 // enable/disable tooltips
 410 {
 411   SendMessage (TooltipHandle, (UINT)TTM_ACTIVATE, (WPARAM)(BOOL)b, 0);
 412 }
 413
 414 void
 415 Window::AddTooltip (HWND target, HWND win, const char *text)
 416 // adds a tooltip to element 'target' in window 'win'
 417 // note: text is limited to 80 chars (grumble)
 418 {
 419   if (!TooltipHandle)
 420     ActivateTooltips ();
 421
 422   TOOLINFO ti;
 423
 424   memset ((void *)&ti, 0, sizeof(ti));
 425   ti.cbSize = sizeof(ti);
 426
 427   ti.uFlags = TTF_IDISHWND    // add tool based on handle not ID
 428             | TTF_SUBCLASS;   // tool is to subclass the window in order
 429                               // to automatically get mouse events
 430   ti.hwnd = win;
 431   ti.uId = reinterpret_cast<UINT_PTR>(target);
 432   ti.lpszText = (LPTSTR)text; // pointer to text or string resource
 433
 434   SendMessage (TooltipHandle, (UINT)TTM_ADDTOOL, 0,
 435         (LPARAM)(LPTOOLINFO)&ti);
 436 }
 437
 438 void
 439 Window::AddTooltip (int id, const char *text)
 440 // adds a tooltip to a control identified by its ID
 441 {
 442   HWND target, parent;
 443
 444   if ((target = GetDlgItem (id)) != NULL &&
 445       (parent = ::GetParent (target)) != NULL)
 446     AddTooltip (target, parent, text);
 447 }
 448
 449 void
 450 Window::AddTooltip (int id, int string_resource)
 451 // adds a tooltip that's represented by a string resource
 452 // this also allows for tooltips greater than 80 characters
 453 // we do this by setting the lpszText to LPSTR_TEXTCALLBACK
 454 // and then responding to the TTN_GETDISPINFO notification
 455 // in order to do this we store a list of (control ID, string ID) pairs
 456 {
 457   AddTooltip (id, (const char *)LPSTR_TEXTCALLBACK);
 458   TooltipStrings[id] = string_resource;
 459 }
 460
 461 BOOL
 462 Window::TooltipNotificationHandler (LPARAM lParam)
 463 // this is the handler for TTN_GETDISPINFO notifications
 464 {
 465   NMTTDISPINFOW *dispinfo = (NMTTDISPINFOW *)lParam;
 466   int ctrlID;
 467   std::map<int, int>::iterator findID;
 468
 469   if ((dispinfo->uFlags & TTF_IDISHWND) &&
 470       ((ctrlID = GetDlgCtrlID ((HWND)dispinfo->hdr.idFrom)) != 0) &&
 471       ((findID = TooltipStrings.find (ctrlID)) != TooltipStrings.end ())) {
 472
 473     // enable multiple lines
 474     SendMessage(dispinfo->hdr.hwndFrom, TTM_SETMAXTIPWIDTH, 0, 450);
 475
 476     // this is quite ugly.  Apparently even when using string resources
 477     // the tooltip length still can't exceed 80 chars.  So, we fetch the
 478     // resource into our own buffer and use that
 479
 480     WCHAR buf[2048];
 481     LoadStringW (GetInstance (), findID->second, (LPWSTR)buf,
 482                  (sizeof (buf) / sizeof (WCHAR)));
 483
 484     dispinfo->lpszText = buf;
 485
 486     // set this flag so that the control will not ask for this again
 487     dispinfo->uFlags |= TTF_DI_SETITEM;
 488     dispinfo->hinst = NULL;
 489     return TRUE;
 490   }
 491
 492   return FALSE;
 493 }
 494
 495 void
 496 Window::SetBusy (void)
 497 {
 498   // The docs suggest that you can call SetCursor, and it won't do
 499   // anything if you've chosen the same cursor as is already set.
 500   // However it looked to me as if it was resetting the animation
 501   // frame every time when I tried it, hence this routine to make
 502   // sure we only call it once on the way into and once on the way
 503   // out of busy mode.
 504   if (BusyCount++ == 0)
 505     {
 506       if (BusyCursor == NULL)
 507         BusyCursor = LoadCursor (NULL, IDC_WAIT);
 508       OldCursor = SetCursor (BusyCursor);
 509     }
 510 }
 511
 512 void
 513 Window::ClearBusy (void)
 514 {
 515   if (BusyCount && (--BusyCount == 0))
 516     {
 517       SetCursor (OldCursor);
 518     }
 519 }
 520