开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
misc.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：32k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

misc.cxx：源码内容
  1. /*
  2.  * misc.cxx
  3.  *
  4.  * Miscellaneous GUI class implementation.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: misc.cxx,v $
  30.  * Revision 1.66  2000/03/17 20:32:22  robertj
  31.  * Fixed race conditions in mult-threaded windows (dialogs in particular)
  32.  *
  33.  * Revision 1.65  2000/03/04 07:50:05  robertj
  34.  * Fixed problem with window not appearing when assert on GUI based win32 apps.
  35.  *
  36.  * Revision 1.64  1999/11/06 05:13:47  robertj
  37.  * Fixed reporting of memory leak that isn't for debug/trace stream.
  38.  *
  39.  * Revision 1.63  1999/10/24 11:52:05  robertj
  40.  * Fixed problems with creating/deleting dialogs from background threads.
  41.  *
  42.  * Revision 1.62  1999/08/17 03:46:42  robertj
  43.  * Fixed usage of inlines in optimised version.
  44.  *
  45.  * Revision 1.61  1999/08/07 07:13:23  robertj
  46.  * Fixed problems with "balloon help" text popup.
  47.  *
  48.  * Revision 1.60  1999/06/14 07:59:39  robertj
  49.  * Enhanced tracing again to add options to trace output (timestamps etc).
  50.  *
  51.  * Revision 1.59  1999/02/22 10:11:06  robertj
  52.  * Added trace stream output to debug output stream.
  53.  *
  54.  * Revision 1.58  1998/12/12 00:45:44  robertj
  55.  * new directory structure
  56.  *
  57.  * Revision 1.57  1998/11/30 04:49:50  robertj
  58.  * New directory structure
  59.  *
  60.  * Revision 1.56  1998/10/13 14:14:41  robertj
  61.  * Complete rewrite of memory leak detection code.
  62.  *
  63.  * Revision 1.55  1998/09/24 03:42:53  robertj
  64.  * Added open software license.
  65.  *
  66.  * Revision 1.54  1998/04/07 13:31:34  robertj
  67.  * Changed startup code to support PApplication class.
  68.  *
  69.  * Revision 1.53  1998/03/09 01:34:53  robertj
  70.  * Changed "system" font to not be the system font, WIn95 weirdness.
  71.  *
  72.  * Revision 1.52  1997/07/08 12:56:31  robertj
  73.  * DLL support
  74.  *
  75.  * Revision 1.51  1997/04/27 05:50:34  robertj
  76.  * DLL support.
  77.  *
  78.  * Revision 1.50  1996/10/31 12:39:57  robertj
  79.  * Added RCS keywords.
  80.  *
  81.  */
  83. #include <pwlib.h>
  84. #include <ptlibdebstrm.h>
  86. #if !P_USE_INLINES
  87. #include <pwlibpwlib.inl>
  88. #endif
  90. #define new PNEW
  92. //
  93. // If we are building with Win95/NT4 headers, we need to declare
  94. // the multimonitor-related metrics ourselves.
  95. //
  96. #ifndef SM_CMONITORS
  97. #define SM_XVIRTUALSCREEN       76
  98. #define SM_YVIRTUALSCREEN       77
  99. #define SM_CXVIRTUALSCREEN      78
  100. #define SM_CYVIRTUALSCREEN      79
  101. #define SM_CMONITORS            80
  102. #define SM_SAMEDISPLAYFORMAT    81
  103. #endif
  106. ///////////////////////////////////////////////////////////////////////////////
  107. // PKeyCode
  109. PKeyCode::PKeyCode(BOOL mouseMessage, WPARAM wParam, int other)
  110. {
  111.   if (mouseMessage) {
  112.     value = (Value)other;
  113.     modifiers = NoModifier;
  114.     if ((wParam&MK_CONTROL) != 0)
  115.       modifiers = (Modifiers)(modifiers|Control);
  116.     if ((wParam&MK_SHIFT) != 0)
  117.       modifiers = (Modifiers)(modifiers|Shift);
  118.     if ((wParam&MK_LBUTTON) != 0)
  119.       modifiers = (Modifiers)(modifiers|LeftMouseButton);
  120.     if ((wParam&MK_RBUTTON) != 0)
  121.       modifiers = (Modifiers)(modifiers|RightMouseButton);
  122.   }
  123.   else {
  124.     static Value fromVK[] = { 
  125.       NullValue, LeftButton, RightButton, Cancel, MiddleButton, NullValue,
  126.       NullValue, NullValue, BackSpace, Tab, NullValue, NullValue, Clear,
  127.       Return, NullValue, NullValue, ShiftKey, ControlKey, Altkey, Oem1,
  128.       CapsLockKey, NullValue, NullValue, NullValue, NullValue, NullValue,
  129.       NullValue, Escape, NullValue, NullValue, NullValue, NullValue, Space,
  130.       PageUp, PageDown, End, Home, Left, Up, Right, Down, Oem2, Oem3,
  131.       Oem4, Oem5, Insert, Delete, Help, KB0, KB1, KB2, KB3, KB4,
  132.       KB5, KB6, KB7, KB8, KB9, NullValue, NullValue, NullValue, NullValue,
  133.       NullValue, NullValue, NullValue, A, B, C, D, E, F, G, H, I, J, K, L, M,
  134.       N, O, P, Q, R, S, T, U, V, W, X, Y, Z, NullValue, NullValue, NullValue,
  135.       NullValue, NullValue, KP0, KP1, KP2, KP3, KP4, KP5, KP6, KP7, KP8, KP9,
  136.       Multiply, Add, Separator, Subtract, Decimal, Divide, F1, F2, F3, F4,
  137.       F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19,
  138.       F20, F21, F22, F23, F24, NullValue, NullValue, NullValue, NullValue,
  139.       NullValue, NullValue, NullValue, NullValue, Oem6, Oem7,
  140.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //97
  141.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //9E
  142.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //A5
  143.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //AB
  144.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //B1
  145.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //B8
  146.       NullValue, Oem8, Oem10, Oem11, Oem12, Oem13, Oem14, Oem15,
  147.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //C6
  148.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //CC
  149.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //D2
  150.       NullValue, NullValue, NullValue, NullValue, NullValue, NullValue, //D8
  151.       NullValue, NullValue, Oem16, Oem17, Oem18, Oem19, Oem20, Oem21, //E0
  152.       Oem22, Oem23, Oem24, Oem25, NullValue, Oem26, NullValue, //E7
  153.       NullValue, Oem27, Oem28, Oem29, Oem30, Oem31, Oem32, Oem33, Oem34, //F0
  154.       Oem35, Oem36, Oem37, Oem38, Oem39
  155.     };
  156.     value = wParam < PARRAYSIZE(fromVK) ? fromVK[wParam] : NullValue;
  157.     modifiers = NoModifier;
  158.   }
  159. }
  162. WORD PKeyCode::VKCode()
  163. {
  164.   static WORD toVK[LastCode] = { 
  165.     0, VK_LBUTTON, VK_RBUTTON, VK_MBUTTON,
  166.     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
  167.     'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
  168.     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  169.     VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3, VK_NUMPAD4,
  170.     VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7, VK_NUMPAD8, VK_NUMPAD9,
  171.     VK_ADD, VK_SUBTRACT, VK_MULTIPLY, VK_DIVIDE, VK_SEPARATOR, VK_DECIMAL,    
  172.     VK_F1, VK_F2, VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8,
  173.     VK_F9, VK_F10, VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16,
  174.     VK_F17, VK_F18, VK_F19, VK_F20, VK_F21, VK_F22, VK_F23, VK_F24, 
  175.     VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT, VK_PRIOR, VK_NEXT, VK_HOME, VK_END,
  176.     VK_INSERT, VK_DELETE, VK_F20, VK_F21, VK_F22, VK_F23,
  177.     VK_CLEAR, VK_CANCEL, VK_HELP, VK_F24,
  178.     VK_BACK, VK_TAB, VK_RETURN, VK_ESCAPE, VK_SPACE,
  179.     VK_CAPITAL, VK_SHIFT, VK_CONTROL, VK_MENU, VK_CONTROL, VK_MENU, VK_MENU,
  180.     VK_PAUSE, VK_SELECT, 0x2a, VK_EXECUTE, VK_SNAPSHOT, VK_NUMLOCK, VK_SCROLL,
  181.     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
  182.     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe6, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee,
  183.     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5
  184.   };
  185.   PAssert(value < LastCode, "Bad key code");
  186.   return toVK[value];
  187. }
  190. WORD PKeyCode::MouseModifiers()
  191. {
  192.   WORD mm = 0;
  193.   if (IsModifier(Control))
  194.     mm |= MK_CONTROL;
  195.   if (IsModifier(Shift))
  196.     mm |= MK_SHIFT;
  197.   if (IsModifier(LeftMouseButton))
  198.     mm |= MK_LBUTTON;
  199.   if (IsModifier(RightMouseButton))
  200.     mm |= MK_RBUTTON;
  201.   return mm;
  202. }
  206. ///////////////////////////////////////////////////////////////////////////////
  207. // PResourceData
  209. PResourceData::PResourceData(const PString & resType, PRESOURCE_ID resID)
  210. {
  211.   HINSTANCE hInst = PApplication::Current().GetInstance();
  212.   HRSRC hRes = FindResource(hInst, MAKEINTRESOURCE(resID), resType);
  213.   hResource = LoadResource(hInst, PAssertNULL(hRes));
  214.   lpResource = (LPSTR)LockResource(PAssertNULL(hResource));
  215.   reference->size = 0; //(PINDEX)GlobalSize(hResource);
  216. }
  219. void PResourceData::CopyContents(const PResourceData & res)
  220. {
  221.   hResource = res.hResource;
  222.   lpResource = res.lpResource;
  223. }
  226. PObject::Comparison PResourceData::Compare(const PObject & obj) const
  227. {
  228.   PAssert(obj.IsDescendant(PResourceData::Class()), PInvalidCast);
  229.   return hResource == ((const PResourceData &)obj).hResource
  230.                                                       ? EqualTo : GreaterThan;
  231. }
  234. BOOL PResourceData::SetSize(PINDEX)
  235. {
  236.   return TRUE;
  237. }
  240. void PResourceData::DestroyContents()
  241. {
  242.   if (hResource != NULL) {
  243.     UnlockResource(hResource);
  244.     FreeResource(hResource);
  245.     hResource = NULL;
  246.   }
  247. }
  250. ///////////////////////////////////////////////////////////////////////////////
  251. // PResourceString
  253. void PResourceString::Construct(PRESOURCE_ID resID)
  254. {
  255.   PINDEX sz = 100;
  256.   do {
  257.     sz *= 2;
  258.   } while (LoadString(PApplication::Current().GetInstance(),
  259.                                            resID, GetPointer(sz+1), sz) >= sz);
  260.   MakeMinimumSize();
  261. }
  264. ///////////////////////////////////////////////////////////////////////////////
  265. // PCursor
  267. PCursor::PCursor(PRESOURCE_ID resID)
  268. {
  269.   deleteCursor = FALSE;
  270.   switch ((unsigned)resID) {
  271.     case PSTD_ID_CURSOR_ARROW :
  272.       hCursor = LoadCursor(NULL, IDC_ARROW);
  273.       break;
  275.     case PSTD_ID_CURSOR_IBEAM :
  276.       hCursor = LoadCursor(NULL, IDC_IBEAM);
  277.       break;
  279.     case PSTD_ID_CURSOR_WAIT :
  280.       hCursor = LoadCursor(NULL, IDC_WAIT);
  281.       break;
  283.     case PSTD_ID_CURSOR_CROSS :
  284.       hCursor = LoadCursor(NULL, IDC_CROSS);
  285.       break;
  287.     case PSTD_ID_CURSOR_MOVELEFT :
  288.     case PSTD_ID_CURSOR_MOVERIGHT :
  289.     case PSTD_ID_CURSOR_LEFTRIGHT :
  290.       hCursor = LoadCursor(NULL, IDC_SIZEWE);
  291.       break;
  293.     case PSTD_ID_CURSOR_MOVETOP :
  294.     case PSTD_ID_CURSOR_MOVEBOTTOM :
  295.     case PSTD_ID_CURSOR_UPDOWN :
  296.       hCursor = LoadCursor(NULL, IDC_SIZENS);
  297.       break;
  299.     case PSTD_ID_CURSOR_MOVETOPRIGHT :
  300.     case PSTD_ID_CURSOR_MOVEBOTLEFT :
  301.       hCursor = LoadCursor(NULL, IDC_SIZENESW);
  302.       break;
  304.     case PSTD_ID_CURSOR_MOVETOPLEFT :
  305.     case PSTD_ID_CURSOR_MOVEBOTRIGHT :
  306.       hCursor = LoadCursor(NULL, IDC_SIZENWSE);
  307.       break;
  309.     default :
  310.       hCursor = LoadCursor(PApplication::Current().GetInstance(),
  311.                                                       MAKEINTRESOURCE(resID));
  312.       deleteCursor = TRUE;
  313.   }
  314.   PAssertOS(hCursor != NULL);
  315. }
  318. PObject::Comparison PCursor::Compare(const PObject & obj) const
  319. {
  320.   PAssert(obj.IsDescendant(PCursor::Class()), PInvalidCast);
  321.   return hCursor == ((const PCursor &)obj).hCursor ? EqualTo : GreaterThan;
  322. }
  325. static char * GetMaskBits(const PPixelImage & mask)
  326. {
  327.   HBITMAP hMask = mask->GetHBITMAP(NULL);
  328.   BITMAP bm;
  329.   GetObject(hMask, sizeof(bm), (LPSTR)&bm);
  330.   int bufSize = bm.bmHeight*bm.bmWidthBytes;
  331.   char * bits = new char[bufSize];
  332.   GetBitmapBits(hMask, bufSize, bits);
  333.   DeleteObject(hMask);
  334.   return bits;
  335. }
  337. PCursor::PCursor(const PPixelImage & andMask,
  338.                           const PPixelImage & xorMask, const PPoint & hotSpot)
  339. {
  340.   PApplication & owner = PApplication::Current();
  341.   PAssert(andMask->GetDepth() == 1 &&
  342.           andMask->GetDimensions() == owner.GetCursorSize() &&
  343.           xorMask->GetDepth() == 1 &&
  344.           xorMask->GetDimensions() == owner.GetCursorSize(),
  345.                                             "Incompatible images for cursor");
  346.   PAssert((PDIMENSION)hotSpot.X() < andMask->Width() &&
  347.           (PDIMENSION)hotSpot.Y() < andMask->Height(),
  348.           "Bad hot spot for cursor");
  349.   char * andMaskBits = GetMaskBits(andMask);
  350.   char * xorMaskBits = GetMaskBits(xorMask);
  351.   hCursor = CreateCursor(owner.GetInstance(),
  352.                          hotSpot.X(), hotSpot.Y(),
  353.                          andMask->Width(), andMask->Height(),
  354.                          andMaskBits, xorMaskBits);
  355.   delete [] andMaskBits;
  356.   delete [] xorMaskBits;
  357.   deleteCursor = TRUE;
  358.   PAssertOS(hCursor != NULL);
  359. }
  362. void PCursor::DestroyContents()
  363. {
  364.   if (deleteCursor && hCursor != NULL) {
  365.     PAssertOS(SetCursor(LoadCursor(NULL, IDC_ARROW)) != NULL);
  366.     PAssertOS(DestroyCursor(hCursor));
  367.     hCursor = NULL;
  368.   }
  369. }
  372. void PCursor::CopyContents(const PCursor & curs)
  373. {
  374.   hCursor = curs.hCursor;
  375.   deleteCursor = curs.deleteCursor;
  376. }
  379. //////////////////////////////////////////////////////////////////////////////
  380. // PCaret
  382. void PCaret::DestroyContents()
  383. {
  384.   Deactivate(activeWindow);
  385. }
  388. void PCaret::CopyContents(const PCaret & c)
  389. {
  390.   caretSize = c.caretSize;
  391.   activeWindow = c.activeWindow;
  392. }
  395. #if defined(_WIN32)
  396. #define PCaretAssertOS PAssertOS
  397. #else
  398. #define PCaretAssertOS
  399. #endif
  401. void PCaret::Activate(PInteractor * activator, BOOL display)
  402. {
  403.   Deactivate(activeWindow);
  405.   if (caretSize.Width() > 0 && caretSize.Height() > 0) {
  406.     activeWindow = activator;
  408.     PCaretAssertOS(CreateCaret(activator->GetHWND(),
  409.                                  NULL, caretSize.Width(), caretSize.Height()));
  410.     SetPosition(activator);
  411.     if (display)
  412.       Show(activator);
  413.   }
  414. }
  417. void PCaret::Deactivate(PInteractor * activator)
  418. {
  419.   if (activeWindow != NULL && activeWindow == activator) {
  420.     PCaretAssertOS(DestroyCaret());
  421.     activeWindow = NULL;
  422.   }
  423. }
  426. void PCaret::Show(PInteractor * activator)
  427. {
  428.   if (activeWindow != NULL && activeWindow == activator)
  429.     PCaretAssertOS(ShowCaret(activator->GetHWND()));
  430. }
  433. void PCaret::Hide(PInteractor * activator)
  434. {
  435.   if (activeWindow != NULL && activeWindow == activator)
  436.     PCaretAssertOS(HideCaret(activator->GetHWND()));
  437. }
  440. void PCaret::SetPosition(PInteractor * activator)
  441. {
  442.   if (activeWindow != NULL && activeWindow == activator) {
  443.     PPoint pos = activator->GetCaretPos(PInteractor::PixelCoords);
  444.     PCaretAssertOS(SetCaretPos(pos.X(), pos.Y()));
  445.   }
  446. }
  449. void PCaret::SetDimensions(PDIMENSION dx, PDIMENSION dy)
  450. {
  451.   caretSize.SetWidth(dx);
  452.   caretSize.SetHeight(dy);
  453.   if (activeWindow != NULL)
  454.     Activate(activeWindow, FALSE);
  455. }
  458. ///////////////////////////////////////////////////////////////////////////////
  459. // PImgIcon
  461. PImgIcon::PImgIcon(PRESOURCE_ID resID)
  462. {
  463.   hBitmap = LoadBitmap(PApplication::Current().GetInstance(), MAKEINTRESOURCE(resID));
  464.   PAssert(hBitmap != NULL, "Could not load resource.");
  465. }
  468. PImgIcon::PImgIcon(PCanvas & canvas, const PPixelImage & pix)
  469. {
  470.   hBitmap = pix->GetHBITMAP(canvas.GetHDC());
  471.   PAssertOS(hBitmap != NULL);
  472. }
  475. PObject::Comparison PImgIcon::Compare(const PObject & obj) const
  476. {
  477.   PAssert(obj.IsDescendant(PImgIcon::Class()), PInvalidCast);
  478.   return hBitmap == ((const PImgIcon &)obj).hBitmap ? EqualTo : GreaterThan;
  479. }
  482. void PImgIcon::DestroyContents()
  483. {
  484.   if (hBitmap != NULL) {
  485.     PAssertOS(DeleteObject(hBitmap));
  486.     hBitmap = NULL;
  487.   }
  488. }
  491. PDim PImgIcon::GetDimensions() const
  492. {
  493.   BITMAP bm;
  494.   GetObject(hBitmap, sizeof(bm), (LPSTR)&bm);
  495.   return PDim((PDIMENSION)bm.bmWidth, (PDIMENSION)bm.bmHeight);
  496. }
  499. ///////////////////////////////////////////////////////////////////////////////
  500. // PIcon
  502. PIcon::PIcon(PRESOURCE_ID resID)
  503.   : PImgIcon((HBITMAP)NULL)
  504. {
  505.   deleteIcon = FALSE;
  506.   switch ((unsigned)resID) {
  507.     case PSTD_ID_ICON_INFORMATION :
  508.       hIcon = LoadIcon(NULL, IDI_ASTERISK);
  509.       break;
  511.     case PSTD_ID_ICON_QUESTION :
  512.       hIcon = LoadIcon(NULL, IDI_QUESTION);
  513.       break;
  515.     case PSTD_ID_ICON_EXCLAMATION :
  516.       hIcon = LoadIcon(NULL, IDI_EXCLAMATION);
  517.       break;
  519.     case PSTD_ID_ICON_STOPSIGN :
  520.       hIcon = LoadIcon(NULL, IDI_HAND);
  521.       break;
  523.     case PSTD_ID_ICON_WINDOW :
  524.       hIcon = LoadIcon(NULL, IDI_APPLICATION);
  525.       break;
  527.     default :
  528.       hIcon = LoadIcon(PApplication::Current().GetInstance(), MAKEINTRESOURCE(resID));
  529.       deleteIcon = TRUE;
  530.   }
  531.   PAssertNULL(hIcon);
  532. }
  535. PObject::Comparison PIcon::Compare(const PObject & obj) const
  536. {
  537.   PAssert(obj.IsDescendant(PIcon::Class()), PInvalidCast);
  538.   return hIcon == ((const PIcon &)obj).hIcon ? EqualTo : GreaterThan;
  539. }
  542. void PIcon::DestroyContents()
  543. {
  544.   if (deleteIcon && hIcon != NULL) {
  545.     DestroyIcon(hIcon);
  546.     hIcon = NULL;
  547.   }
  548. }
  551. void PIcon::CopyContents(const PIcon & icon)
  552. {
  553.   deleteIcon = icon.deleteIcon;
  554.   hIcon = icon.hIcon;
  555. }
  558. PDim PIcon::GetDimensions() const
  559. {
  560.   return PDim((PDIMENSION)GetSystemMetrics(SM_CXICON),
  561.               (PDIMENSION)GetSystemMetrics(SM_CYICON));
  562. }
  565. ///////////////////////////////////////////////////////////////////////////////
  566. // PClipboard
  568. PClipboard::PClipboard(const PInteractor * wnd)
  569.   : owner(PAssertNULL(wnd))
  570. {
  571.   opened = OpenClipboard(wnd->GetHWND());
  572.   emptied = FALSE;
  573. }
  576. PClipboard::~PClipboard()
  577. {
  578.   if (opened)
  579.     PAssertOS(CloseClipboard());
  580. }
  583. BOOL PClipboard::HasFormat(Format fmt)
  584. {
  585.   static const UINT PClipboardFormats[NumFormats] = {
  586.     CF_TEXT, CF_BITMAP, CF_METAFILEPICT
  587.   };
  588.   
  589.   return opened && IsClipboardFormatAvailable(PClipboardFormats[fmt]);
  590. }
  593. BOOL PClipboard::HasFormat(const PString & fmt)
  594. {
  595.   return opened && IsClipboardFormatAvailable(RegisterClipboardFormat(fmt));
  596. }
  599. DWORD PClipboard::GetSize(const PString & fmt)
  600. {
  601.   if (!opened)
  602.     return 0;
  604.   HANDLE h = GetClipboardData(RegisterClipboardFormat(fmt));
  605.   return h != NULL ? GlobalSize(h) : 0;
  606. }
  609. BOOL PClipboard::GetData(const PString & fmt, void * data, DWORD max)
  610. {
  611.   if (!opened)
  612.     return FALSE;
  614.   HANDLE h = GetClipboardData(RegisterClipboardFormat(fmt));
  615.   if (h == NULL)
  616.     return FALSE;
  618.   DWORD size = GlobalSize(h);
  619.   memcpy(data, GlobalLock(h), (size_t)min(max, size));
  620.   GlobalUnlock(h);
  621.   return size <= max;
  622. }
  624.     
  625. BOOL PClipboard::SetData(const PString & fmt, const void * data, DWORD len)
  626. {
  627.   if (!opened)
  628.     return FALSE;
  630.   if (!emptied) {
  631.     EmptyClipboard();
  632.     emptied = TRUE;
  633.   }
  634.   
  635. #if !defined(_WIN32)
  636.   PAssert(len < 65536, PInvalidParameter);
  637. #endif
  638.   HANDLE h = GlobalAlloc(GHND, len);
  639.   memcpy(GlobalLock(h), data, (size_t)len);
  640.   GlobalUnlock(h);
  641.   return SetClipboardData(RegisterClipboardFormat(fmt), h) != NULL;
  642. }
  645. PString PClipboard::GetText()
  646. {
  647.   PString str;
  649.   HANDLE h = GetClipboardData(CF_TEXT);
  650.   if (h != NULL) {
  651.     DWORD size = GlobalSize(h);
  652. #if !defined(_WIN32)
  653.     PAssert(size < 65536, PInvalidParameter);
  654. #endif
  655.     lstrcpy(str.GetPointer((PINDEX)size), (LPSTR)GlobalLock(h));
  656.     GlobalUnlock(h);
  657.   }
  658.   return str;
  659. }
  662. BOOL PClipboard::SetText(const PString & str)
  663. {
  664.   if (!opened)
  665.     return FALSE;
  667.   if (!emptied) {
  668.     EmptyClipboard();
  669.     emptied = TRUE;
  670.   }
  671.   
  672.   PString winstr = PMakeOEMText(str);
  673.   HANDLE h = GlobalAlloc(GHND, winstr.GetLength()+1);
  674.   lstrcpy((LPSTR)GlobalLock(h), winstr);
  675.   GlobalUnlock(h);
  676.   SetClipboardData(CF_TEXT, h);
  677.   return TRUE;
  678. }
  681. PPixelImage PClipboard::GetPixels()
  682. {
  683.   HANDLE h = GetClipboardData(CF_BITMAP);
  684.   if (h != NULL)
  685.     return PPixelBase::CreateBitmap((HBITMAP)h);
  687.   return PPixelImage();
  688. }
  691. BOOL PClipboard::SetPixels(const PPixelImage & pix)
  692. {
  693.   if (!opened)
  694.     return FALSE;
  696.   if (!emptied) {
  697.     EmptyClipboard();
  698.     emptied = TRUE;
  699.   }
  700.   
  701.   PAssertOS(SetClipboardData(CF_BITMAP, pix->GetHBITMAP(NULL)) != NULL);
  702.   return TRUE;
  703. }
  706. PPictImage PClipboard::GetPict()
  707. {
  708.   PPictImage dwg;
  710. #if defined(_WIN32)
  711.   HENHMETAFILE h = (HENHMETAFILE)GetClipboardData(CF_ENHMETAFILE);
  712.   if (h != NULL)
  713.     dwg = PPictImage(new PPictBase(h));
  714. #else
  715.   HANDLE h = GetClipboardData(CF_METAFILEPICT);
  716.   if (h != NULL) {
  717.     LPMETAFILEPICT m = (LPMETAFILEPICT)GlobalLock(h);
  718.     dwg = PPictImage(new PPictBase(m->hMF));
  719.     GlobalUnlock(h);
  720.   }
  721. #endif
  723.   return dwg;
  724. }
  727. BOOL PClipboard::SetPict(const PPictImage & pic)
  728. {
  729.   if (!opened)
  730.     return FALSE;
  732.   if (!emptied) {
  733.     EmptyClipboard();
  734.     emptied = TRUE;
  735.   }
  736.   
  737. #if defined(_WIN32)
  738.   return SetClipboardData(CF_ENHMETAFILE, pic->GetMETAFILE()) != NULL;
  739. #else
  740.   HANDLE h = GlobalAlloc(GHND, sizeof(METAFILEPICT));
  741.   if (h == NULL)
  742.     return FALSE;
  744.   LPMETAFILEPICT m = (LPMETAFILEPICT)GlobalLock(h);
  745.   m->hMF = pic->GetMETAFILE();
  746.   GlobalUnlock(h);
  747.   SetClipboardData(CF_METAFILEPICT, h);
  748.   return TRUE;
  749. #endif
  750. }
  753. ///////////////////////////////////////////////////////////////////////////////
  754. // PApplication
  756. PApplication::PApplication(const char * manuf, const char * name,
  757.                            WORD major, WORD minor, CodeStatus stat, WORD build)
  758.   : PProcess(manuf, name, major, minor, stat, build),
  759.     systemFont("System", 12),
  760.     balloonFont("MS Sans Serif", 8)
  761. {
  762. }
  765. BOOL PApplication::IsGUIProcess() const
  766. {
  767.   return TRUE;
  768. }
  771. static PApplication * PApplicationInstance;
  773. LRESULT PEXPORTED WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  774. {
  775.   return PApplicationInstance->WndProc(hWnd,msg,wParam,lParam);
  776. }
  779. BOOL PEXPORTED DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  780. {
  781.   return PApplicationInstance->DlgProc(hWnd,msg,wParam,lParam);
  782. }
  785. BOOL PEXPORTED FileDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  786. {
  787.   return PApplicationInstance->FileDlgProc(hWnd,msg,wParam,lParam);
  788. }
  791. BOOL PEXPORTED PrintDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  792. {
  793.   return PApplicationInstance->PrintDlgProc(hWnd, msg, wParam, lParam);
  794. }
  797. BOOL PEXPORTED FontDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  798. {
  799.   return PApplicationInstance->FontDlgProc(hWnd,msg,wParam,lParam);
  800. }
  803. BOOL PEXPORTED ColourDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  804. {
  805.   return PApplicationInstance->ColourDlgProc(hWnd, msg, wParam, lParam);
  806. }
  809. #define SET_DLG_PROC(proc) 
  810.                wndProcPtr[PApplication::proc##ProcType] = (WNDPROC)::proc##Proc
  812. int PApplication::_main(void * arg)
  813. {
  814.   PApplicationInstance = this;
  815.   hInstance = (HINSTANCE)arg;
  817.   SET_DLG_PROC(Wnd);
  818.   SET_DLG_PROC(Dlg);
  819.   SET_DLG_PROC(FileDlg);
  820.   SET_DLG_PROC(PrintDlg);
  821.   SET_DLG_PROC(FontDlg);
  822.   SET_DLG_PROC(ColourDlg);
  824.   Construct();
  826. #if PMEMORY_CHECK
  827.   PMemoryHeap::SetIgnoreAllocations(TRUE);
  828. #endif
  829.   ostream * debugStream = new PDebugStream;
  830.   PSetErrorStream(debugStream);  // Use OutputDebugString() stream
  831.   PTrace::SetStream(debugStream);
  832. #if PMEMORY_CHECK
  833.   PMemoryHeap::SetIgnoreAllocations(FALSE);
  834. #endif
  836.   blowUpTimeout = 1000;
  837.   doubleClick = 250;
  838.   mainWindow = NULL;
  839.   receivedQuitMessage = FALSE;
  840.   hAccelerator = NULL;
  841.   mdiClient = NULL;
  843.   defaultHelpFile = GetFile();
  844.   defaultHelpFile.SetType(".hlp");
  846.   HDC hDC = CreateCompatibleDC(NULL);
  848.   primaryScreenSize.SetWidth(GetSystemMetrics(SM_CXSCREEN));
  849.   primaryScreenSize.SetHeight(GetSystemMetrics(SM_CYSCREEN));
  850.   screenRect.SetX(GetSystemMetrics(SM_XVIRTUALSCREEN));
  851.   screenRect.SetY(GetSystemMetrics(SM_YVIRTUALSCREEN));
  852.   screenRect.SetWidth(GetSystemMetrics(SM_CXVIRTUALSCREEN));
  853.   screenRect.SetHeight(GetSystemMetrics(SM_CYVIRTUALSCREEN));
  854.   if (screenRect.Width() == 0 || screenRect.Height() == 0)
  855.     screenRect = primaryScreenSize;
  856.   screenResImperial.SetWidth((PDIMENSION)GetDeviceCaps(hDC, LOGPIXELSX));
  857.   screenResImperial.SetHeight((PDIMENSION)GetDeviceCaps(hDC, LOGPIXELSY));
  858.   screenResMetric.SetWidth((PDIMENSION)(screenResImperial.Width()*394L/1000L));
  859.   screenResMetric.SetHeight((PDIMENSION)(screenResImperial.Height()*394L/1000L));
  860.   cursorSize.SetWidth((PDIMENSION)GetSystemMetrics(SM_CXCURSOR));
  861.   cursorSize.SetHeight((PDIMENSION)GetSystemMetrics(SM_CYCURSOR));
  862.   iconSize.SetWidth((PDIMENSION)GetSystemMetrics(SM_CXICON));
  863.   iconSize.SetHeight((PDIMENSION)GetSystemMetrics(SM_CYICON));
  864.   titledBorder.SetWidth((PDIMENSION)GetSystemMetrics(SM_CXFRAME));
  865.   titledBorder.SetHeight((PDIMENSION)GetSystemMetrics(SM_CYFRAME));
  866.   dlgBorder.SetWidth((PDIMENSION)GetSystemMetrics(SM_CXDLGFRAME));
  867.   dlgBorder.SetHeight((PDIMENSION)GetSystemMetrics(SM_CYDLGFRAME));
  868.   border.SetWidth((PDIMENSION)GetSystemMetrics(SM_CXBORDER));
  869.   border.SetHeight((PDIMENSION)GetSystemMetrics(SM_CYBORDER));
  870.   defMainWindow.SetWidth((PDIMENSION)CW_USEDEFAULT);
  871.   defMainWindow.SetHeight((PDIMENSION)CW_USEDEFAULT);
  872.   defTitledWindow.SetWidth((PDIMENSION)CW_USEDEFAULT);
  873.   defTitledWindow.SetHeight((PDIMENSION)CW_USEDEFAULT);
  874.   screenColours = GetDeviceCaps(hDC, NUMCOLORS);
  875.   screenDepth = (PDIMENSION)(GetDeviceCaps(hDC, BITSPIXEL)*GetDeviceCaps(hDC, PLANES));
  876.   heightTitle = (PDIMENSION)GetSystemMetrics(SM_CYCAPTION);
  877.   heightMenu = (PDIMENSION)GetSystemMetrics(SM_CYMENU);
  878.   heightHScroll = (PDIMENSION)GetSystemMetrics(SM_CYHSCROLL);
  879.   widthVScroll = (PDIMENSION)GetSystemMetrics(SM_CXVSCROLL);
  880.   dblClkRect.SetWidth((PDIMENSION)GetSystemMetrics(SM_CXDOUBLECLK));
  881.   dblClkRect.SetHeight((PDIMENSION)GetSystemMetrics(SM_CYDOUBLECLK));
  882.   dblClkRect.Offset(-GetSystemMetrics(SM_CXDOUBLECLK)/2,
  883.                     -GetSystemMetrics(SM_CYDOUBLECLK)/2);
  884.   windowFg.FromSYSCOLOR(COLOR_WINDOWTEXT);
  885.   windowBk.FromSYSCOLOR(COLOR_WINDOW);
  886.   highlightFg.FromSYSCOLOR(COLOR_HIGHLIGHTTEXT);
  887.   highlightBk.FromSYSCOLOR(COLOR_HIGHLIGHT);
  888.   menuFg.FromSYSCOLOR(COLOR_MENUTEXT);
  889.   menuBk.FromSYSCOLOR(COLOR_MENU);
  890.   balloonFg = menuFg;
  891.   balloonBk = menuBk;
  892.   grayText.FromSYSCOLOR(COLOR_GRAYTEXT);
  893.   buttonFg.FromSYSCOLOR(COLOR_BTNTEXT);
  894.   buttonBk.FromSYSCOLOR(COLOR_BTNFACE);
  895.   buttonLighting.FromSYSCOLOR(COLOR_BTNHIGHLIGHT);
  896.   buttonShadow.FromSYSCOLOR(COLOR_BTNSHADOW);
  897.   scrollBar.FromSYSCOLOR(COLOR_SCROLLBAR);
  898.   activeTitleFg.FromSYSCOLOR(COLOR_CAPTIONTEXT);
  899.   activeTitleBk.FromSYSCOLOR(COLOR_ACTIVECAPTION);
  900.   inactiveTitleFg.FromSYSCOLOR(COLOR_INACTIVECAPTIONTEXT);
  901.   inactiveTitleBk.FromSYSCOLOR(COLOR_INACTIVECAPTION);
  902.   activeBorder.FromSYSCOLOR(COLOR_ACTIVEBORDER);
  903.   inactiveBorder.FromSYSCOLOR(COLOR_INACTIVEBORDER);
  905.   DeleteDC(hDC);
  907.   systemFont = PRealFont((HFONT)GetStockObject(DEFAULT_GUI_FONT));
  909.   createdWindows.DisallowDeleteObjects();
  910.   nonModalDialogs.DisallowDeleteObjects();
  911.   delayedCreateInteractors.DisallowDeleteObjects();
  913. #ifndef P_PLATFORM_HAS_THREADS
  914.   timerWnd = CreateWindow("STATIC", "",
  915.                             WS_POPUP, 0, 0, 0, 0, NULL, NULL, hInstance, NULL);
  916.   SetWindowLong(PAssertNULL(timerWnd),
  917.                                   GWL_WNDPROC, (DWORD)wndProcPtr[WndProcType]);
  918.   lastSetTimerTick = 1; // Needs to be non-zero
  919. #endif
  921.   Main();
  922.   return GetTerminationValue();
  923. }
  926. void PApplication::Main()
  927. {
  928.   while (ProcessMessage()) {
  929.     windowsMutex.Wait();
  930.     if (!delayedCreateInteractors.IsEmpty()) {
  931.       for (PINDEX i = 0; i < delayedCreateInteractors.GetSize(); i++)
  932.         delayedCreateInteractors[i].CreateHWND();
  933.       delayedCreateInteractors.RemoveAll();
  934.       delayedCreateInteractorsDone.Signal();
  935.     }
  936.     windowsMutex.Signal();
  937.     delayedCloseInteractors.RemoveAll();
  938.   }
  939. }
  940.   
  942. #ifndef P_PLATFORM_HAS_THREADS
  944. void PApplication::OperatingSystemYield()
  945. {
  946.   // Assure other MS-Windows tasks gets some time as well
  947.   MSG msg;
  948.   UINT id = 0x7fff;
  949.   while (PeekMessage(&msg, NULL, id, id, PM_NOREMOVE))
  950.     id--;
  951.   GetTimerList()->Process();
  952. }
  954. #endif
  957. BOOL PApplication::ProcessMessage()
  958. {
  959.   if (receivedQuitMessage)
  960.     return FALSE;
  962.   MSG msg;
  963.   receivedQuitMessage = GetMessage(&msg, NULL, 0, 0) == 0;
  964.   if (receivedQuitMessage)
  965.     return FALSE;
  967.   windowsMutex.Wait();
  968.   for (PINDEX i = 0; i < nonModalDialogs.GetSize(); i++) {
  969.     if (IsDialogMessage(nonModalDialogs[i].GetHWND(), &msg)) {
  970.       windowsMutex.Signal();
  971.       PassMainLoop();
  972.       return TRUE;
  973.     }
  974.   }
  975.   windowsMutex.Signal();
  977.   if (mdiClient != NULL && TranslateMDISysAccel(mdiClient, &msg)) {
  978.     PassMainLoop();
  979.     return TRUE;
  980.   }
  982.   if (hAccelerator != NULL &&
  983.              TranslateAccelerator(mainWindow->GetHWND(), hAccelerator, &msg)) {
  984.     PassMainLoop();
  985.     return TRUE;
  986.   }
  988.   TranslateMessage(&msg);
  989.   DispatchMessage(&msg);
  990.   PassMainLoop();
  991.   return TRUE;
  992. }
  995. LRESULT PApplication::WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
  996. {
  997.   LRESULT retval;
  999. #ifndef P_PLATFORM_HAS_THREADS
  1000.   if (hWnd == timerWnd)
  1001.     retval = DefWindowProc(hWnd, msg, wParam, lParam);
  1002.   else {
  1003. #endif
  1004.     PInteractor * window = (PInteractor *)createdWindows.GetAt(HWNDKey(hWnd));
  1005.     if (window == NULL)
  1006.       retval = DefWindowProc(hWnd, msg, wParam, lParam);
  1007.     else {
  1008.       PInteractor::_WindowsMessage message;
  1009.       message.event = msg;
  1010.       message.wParam = wParam;
  1011.       message.lParam = lParam;
  1012.       message.lResult = 0;
  1013.       message.processed = TRUE;
  1014.       PInteractor::_WindowsMessage * oldMessage = window->_msg;
  1015.       window->_msg = &message;
  1016.       window->WndProc();
  1017.       window->_msg = oldMessage;
  1018.       retval = message.lResult;
  1019.     }
  1020. #ifndef P_PLATFORM_HAS_THREADS
  1021.   }
  1023.   if (timerWnd != NULL &&
  1024.           lastSetTimerTick != 0 && lastSetTimerTick != (UINT)GetTickCount()) {
  1025.     lastSetTimerTick = 0; // Prevent recursive calls
  1027.     Yield(); // Do the multithreading
  1029.     long delay = GetTimerList()->Process().GetInterval();
  1030.     if (!IsOnlyThread())
  1031.       delay = PTimer::Resolution();
  1032.     else if (delay > 60000)
  1033.       delay = 60000;
  1035.     KillTimer(timerWnd, 1);
  1036.     PAssertOS(SetTimer(timerWnd, 1, (UINT)delay, NULL) != 0);
  1038.     // Not too often or it gets really slow
  1039.     lastSetTimerTick = (UINT)GetTickCount();
  1040.     if (lastSetTimerTick == 0)
  1041.       lastSetTimerTick++;
  1042.   }
  1043. #endif
  1045.   return retval;
  1046. }
  1049. void PApplication::AddDialog(PInteractorLayout * pWnd)
  1050. {
  1051.   windowsMutex.Wait();
  1052.   nonModalDialogs.Append(pWnd);
  1053.   windowsMutex.Signal();
  1054. }
  1057. void PApplication::RemoveDialog(PInteractorLayout * pWnd)
  1058. {
  1059.   windowsMutex.Wait();
  1060.   if (nonModalDialogs.GetObjectsIndex(pWnd) != P_MAX_INDEX)
  1061.     nonModalDialogs.Remove(pWnd);
  1062.   windowsMutex.Signal();
  1063. }
  1066. static void DoHelp(PTopLevelWindow * wnd,
  1067.                    const PFilePath & helpFile,
  1068.                    UINT fuCmd, DWORD dwData)
  1069. {
  1070.   PFilePath realHelpFile = helpFile;
  1071.   if (realHelpFile.GetType().IsEmpty())
  1072.     realHelpFile.SetType(".hlp");
  1073.   WinHelp(wnd->GetHWND(), realHelpFile, fuCmd, dwData);
  1074. }
  1077. void PApplication::Terminate()
  1078. {
  1079. #ifndef P_PLATFORM_HAS_THREADS
  1080.   KillTimer(timerWnd, 1);
  1081.   lastSetTimerTick = 0; // Prevent WndProc from doing anything with timers
  1082. #endif
  1084.   if (mainWindow != NULL) {
  1085.     DoHelp(mainWindow, defaultHelpFile, HELP_QUIT, 0);
  1086.     DelayedCloseInteractor(mainWindow);
  1087.     mainWindow = NULL;
  1088.   }
  1089.   PostQuitMessage(0);
  1090. }
  1093. void PApplication::DoContextHelp(const PString & context,
  1094.                                                         const PFilePath & file)
  1095. {
  1096.   DoHelp(mainWindow, file, HELP_KEY, (DWORD)(const char *)context);
  1097. }
  1100. void PApplication::DoContextHelp(PINDEX context, const PFilePath & file)
  1101. {
  1102.   switch ((unsigned)context) {
  1103.     case PSTD_ID_HELP_CONTENTS :
  1104.       DoHelp(mainWindow, file, HELP_CONTENTS, 0);
  1105.       break;
  1107.     case PSTD_ID_HELP_SEARCH :
  1108.       DoHelp(mainWindow, file, HELP_PARTIALKEY, (DWORD)"");
  1109.       break;
  1111.     case PSTD_ID_HELP_ON_HELP :
  1112.       DoHelp(mainWindow, file, HELP_HELPONHELP, 0);
  1113.       break;
  1115.     default :
  1116.       DoHelp(mainWindow, file, HELP_KEY, context);
  1117.   }
  1118. }
  1122. PString PMakeOEMText(const PString & txt)
  1123. {
  1124.   PString s;
  1125.   PINDEX lastPos = 0;
  1126.   PINDEX searchPos = 0;
  1127.   PINDEX pos;
  1128.   while ((pos = txt.FindOneOf("rn", searchPos)) != P_MAX_INDEX) {
  1129.     if (txt[pos] == 'r' && txt[pos+1] == 'n')
  1130.       searchPos = pos + 2;
  1131.     else {
  1132.       if (pos > 0)
  1133.         s += txt(lastPos, pos-1);
  1134.       s += "rn";
  1135.       lastPos = pos + 1;
  1136.       searchPos = lastPos;
  1137.     }
  1138.   }
  1140.   return s + txt(lastPos, pos);
  1141. }
  1144. // End Of File ///////////////////////////////////////////////////////////////