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

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

IP电话/视频会议

开发平台：

Visual C++

interact.cxx：源码内容
  1. /*
  2.  * interact.cxx
  3.  *
  4.  * Interactor classes 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: interact.cxx,v $
  30.  * Revision 1.75  2000/04/13 23:18:43  robertj
  31.  * Fixed problems with sizing controls with scroll bars.
  32.  *
  33.  * Revision 1.74  2000/03/17 20:32:22  robertj
  34.  * Fixed race conditions in mult-threaded windows (dialogs in particular)
  35.  *
  36.  * Revision 1.73  1999/11/16 06:51:42  robertj
  37.  * Created PCustomListBox to allow motif native code PStringListBox implementation
  38.  *
  39.  * Revision 1.72  1999/10/24 11:41:34  robertj
  40.  * Fixed bug in SetDimensions() to allow for a window with a menu.
  41.  *
  42.  * Revision 1.71  1999/08/25 02:42:13  robertj
  43.  * Fixed problem with creating windows in background threads, not happening until have a message sent.
  44.  *
  45.  * Revision 1.70  1999/08/17 03:46:42  robertj
  46.  * Fixed usage of inlines in optimised version.
  47.  *
  48.  * Revision 1.69  1999/08/07 07:13:23  robertj
  49.  * Fixed problems with "balloon help" text popup.
  50.  *
  51.  * Revision 1.68  1999/03/29 03:39:55  robertj
  52.  * Changed semantics of PTitledWindow::OnClose() function.
  53.  *
  54.  * Revision 1.67  1999/02/16 08:08:07  robertj
  55.  * MSVC 6.0 compatibility changes.
  56.  *
  57.  * Revision 1.66  1998/09/24 03:42:44  robertj
  58.  * Added open software license.
  59.  *
  60.  * Revision 1.65  1998/09/24 01:55:53  robertj
  61.  * Fixed problems with resizing windows with built in scroll bars.
  62.  *
  63.  * Revision 1.64  1998/09/22 15:15:29  robertj
  64.  * Added more support for common control callbacks, can now set message result.
  65.  * Added correction for invisible scroll bars in resizing windows.
  66.  *
  67.  * Revision 1.63  1998/09/21 13:31:03  robertj
  68.  * Changes to support new PListView class. Different call back method.
  69.  *
  70.  * Revision 1.62  1998/09/14 13:17:22  robertj
  71.  * Fixed memory leak on delete of PStringList, not deleting all its contents.
  72.  * Fixed major memory (resource) leak in control painting.
  73.  *
  74.  * Revision 1.61  1998/09/04 07:03:22  robertj
  75.  * Fixed possible crash on focus change. Depends on timeing of messages.
  76.  * Fixed SetFont() really setting font. If target is not control font may not be set in this way.
  77.  *
  78.  * Revision 1.60  1998/01/26 00:19:53  robertj
  79.  * Fixed colour of static controls in windows and dialogs.
  80.  *
  81.  * Revision 1.59  1997/04/27 05:50:31  robertj
  82.  * DLL support.
  83.  *
  84.  * Revision 1.58  1996/10/31 12:39:57  robertj
  85.  * Added RCS keywords.
  86.  *
  87.  */
  89. #include <pwlib.h>
  91. #if !P_USE_INLINES
  92. #include <pwlib/pwmisc.inl>
  93. #endif
  96. void PInteractor::Construct(PInteractor * par, HWND hWnd, BOOL hiddenChild)
  97. {
  98.   parent = par;
  100.   if (parent != NULL) {
  101.     if (!hiddenChild)
  102.       parent->children.Append(this);
  103.     owner = parent->owner;
  104.     cursorMode = UseParentCursor;
  105.   }
  106.   else {
  107.     owner = &PApplication::Current();
  108.     cursorMode = UseCurrentCursor;
  109.   }
  111.   _hWnd = hWnd;
  112.   if (_hWnd != NULL) {
  113.     owner->AddWindowHandle(_hWnd, this);
  114.     HFONT hFont = (HFONT)(UINT)SendMessage(_hWnd, WM_GETFONT, 0, 0L);
  115.     if (hFont != NULL)
  116.       font = PRealFont(hFont);
  117.     else
  118.       SetFont(parent->GetFont(), TRUE);
  119.   }
  120.   else {
  121.     if (parent != NULL)
  122.       SetFont(parent->GetFont(), TRUE);
  123.   }
  125.   foregroundColour = owner->GetWindowFgColour();
  126.   backgroundColour = owner->GetWindowBkColour();
  128.   caretVisible = 1;
  130.   _in_WM_PAINT = FALSE;
  131.   mouseTrackInteractor = NULL;
  132.   mouseTrackCanvas = NULL;
  133.   hBackgroundBrush = NULL;
  134. }
  137. PInteractor::~PInteractor()
  138. {
  139.   if (hBackgroundBrush != NULL)
  140.     DeleteObject(hBackgroundBrush);
  142.   if (GetFocusInteractor() == this)
  143.     SetFocusInteractor(parent);
  145.   if (parent!=NULL && parent->children.GetObjectsIndex(this) != P_MAX_INDEX) {
  146.     parent->children.DisallowDeleteObjects();
  147.     parent->children.Remove(this);
  148.     parent->children.AllowDeleteObjects();
  149.   }
  151.   if (_hWnd != NULL && _hWnd != P_DEAD_WINDOW)
  152.     DestroyWindow(_hWnd);
  153. }
  156. PObject::Comparison PInteractor::Compare(const PObject & obj) const
  157. {
  158.   PAssert(obj.IsDescendant(PInteractor::Class()), PInvalidParameter);
  159.   return GetHWND() ==
  160.                 ((const PInteractor &)obj).GetHWND() ? EqualTo : GreaterThan;
  161. }
  164. void PInteractor::SetFont(const PFont & newFont, BOOL toChildren)
  165. {
  166.   font = PRealFont(newFont);
  168.   if (_hWnd != NULL)
  169.     SetWndFont();
  171.   if (toChildren) {
  172.     for (PINDEX i = 0; i < children.GetSize(); i++)
  173.       children[i].SetFont(font, TRUE);
  174.   }
  175. }
  178. void PInteractor::_SetPosition(PORDINATE x, PORDINATE y,
  179.                                PositionOrigin xOrigin, PositionOrigin yOrigin)
  180. {
  181.   PDim myDim = GetStructureBounds(ScreenCoords).Dimensions();
  182.   PDim scrDim = owner->GetPrimaryScreenSize();
  183.   PDim parDim = scrDim;
  184.   PPoint org;
  185.   PInteractor * p = this;
  186.   if (parent != NULL) {
  187.     p = parent;
  188.     parDim = p->GetStructureBounds(ScreenCoords).Dimensions();
  189.     ClientToScreen(p->GetHWND(), org);
  190.   }
  192.   switch (xOrigin) {
  193.     case TopLeftParent:
  194.     case CentreParent :
  195.     case BottomRightParent :
  196.       x = p->ToPixelsX(x) + org.X();
  197.       break;
  199.     case TopLeftPixels:
  200.     case CentrePixels :
  201.     case BottomRightPixels :
  202.       x = x + org.X();
  203.   }
  205.   switch (xOrigin) {
  206.     case CentreParent :
  207.     case CentrePixels :
  208.       x += ((PORDINATE)parDim.Width() - (PORDINATE)myDim.Width())/2;
  209.       break;
  211.     case BottomRightParent :
  212.     case BottomRightPixels :
  213.       x += (PORDINATE)parDim.Width() - (PORDINATE)myDim.Width();
  214.       break;
  216.     case CentreScreen :
  217.       x += ((PORDINATE)scrDim.Width() - (PORDINATE)myDim.Width())/2;
  218.       break;
  220.     case BottomRightScreen :
  221.       x = owner->GetScreenRect().Right() - (PORDINATE)myDim.Width();
  222.   }
  224.   switch (yOrigin) {
  225.     case TopLeftParent:
  226.     case CentreParent :
  227.     case BottomRightParent :
  228.       y = p->ToPixelsY(y) + org.Y();
  229.       break;
  231.     case TopLeftPixels:
  232.     case CentrePixels :
  233.     case BottomRightPixels :
  234.       y = y + org.Y();
  235.   }
  237.   switch (yOrigin) {
  238.     case CentreParent :
  239.     case CentrePixels :
  240.       y += ((PORDINATE)parDim.Height() - (PORDINATE)myDim.Height())/2;
  241.       break;
  243.     case BottomRightParent :
  244.     case BottomRightPixels :
  245.       y += (PORDINATE)parDim.Height() - (PORDINATE)myDim.Height();
  246.       break;
  248.     case CentreScreen :
  249.       y += ((PORDINATE)scrDim.Height() - (PORDINATE)myDim.Height())/2;
  250.       break;
  252.     case BottomRightScreen :
  253.       y = owner->GetScreenRect().Height() - (PORDINATE)myDim.Height();
  254.   }
  256.   if ((_styleBits&0xc0000000) == WS_CHILD) {
  257.     POINT pt;
  258.     pt.x = x;
  259.     pt.y = y;
  260.     ScreenToClient(p->GetHWND(), &pt);
  261.     x = (PORDINATE)pt.x;
  262.     y = (PORDINATE)pt.y;
  263.   }
  265.   SetWindowPos(GetHWND(), NULL, x, y, 0, 0, SWP_NOSIZE|SWP_NOZORDER);
  266. }
  269. PPoint PInteractor::GetPosition(CoordinateSystem coords) const
  270. {
  271.   RECT r;
  272.   GetWindowRect(GetHWND(), &r);
  273.   PPoint p((PORDINATE)r.left, (PORDINATE)r.top);
  275.   if (coords == ScreenCoords)
  276.     return p;
  278.   if (GetParent() != NULL)
  279.     ScreenToClient(GetParent()->GetHWND(), p);
  281.   if (coords == PixelCoords)
  282.     return p;
  284.   const PInteractor * par = parent != NULL ? parent : this;
  285.   return par->FromPixels(p);
  286. }
  289. PPoint PInteractor::ToScreen(const PPoint & pt, CoordinateSystem coords) const
  290. {
  291.   PPoint p;
  292.   switch (coords) {
  293.     case LocalCoords :
  294.       p = ToPixels(pt);
  295.       break;
  296.     case PixelCoords :
  297.       p = pt;
  298.       break;
  299.     case ScreenCoords :
  300.       return pt;
  301.   }
  302.   ClientToScreen(GetHWND(), p);
  303.   return p;
  304. }
  307. PPoint PInteractor::FromScreen(const PPoint & pt, CoordinateSystem coords) const
  308. {
  309.   if (coords == ScreenCoords)
  310.     return pt;
  312.   PPoint p = pt;
  313.   ScreenToClient(GetHWND(), p);
  314.   return coords == PixelCoords ? p : ToPixels(p);
  315. }
  318. void PInteractor::_SetDimensions(PDIMENSION width, PDIMENSION height,
  319.                                  CoordinateSystem coords)
  320. {
  321.   GetHWND();
  323.   if (coords == LocalCoords) {
  324.     width = ToPixelsDX(width);
  325.     height = ToPixelsDY(height);
  326.   }
  328.   switch (_styleBits&WS_CAPTION) {
  329.     case WS_CAPTION :
  330.       height += (PDIMENSION)GetSystemMetrics(SM_CYCAPTION);
  331.       break;
  332.     case WS_BORDER :
  333.       width += (PDIMENSION)GetSystemMetrics(SM_CXBORDER)*2;
  334.       height += (PDIMENSION)GetSystemMetrics(SM_CYBORDER)*2;
  335.       break;
  336.     case WS_DLGFRAME :
  337.       width += (PDIMENSION)GetSystemMetrics(SM_CXDLGFRAME)*2;
  338.       height += (PDIMENSION)GetSystemMetrics(SM_CYDLGFRAME)*2;
  339.       break;
  340.   }
  342.   if ((_styleBits&WS_VSCROLL) != 0 && AdjustDimensionForScrollBar(SB_VERT))
  343.     width += (PDIMENSION)GetSystemMetrics(SM_CXVSCROLL);
  345.   if ((_styleBits&WS_HSCROLL) != 0 && AdjustDimensionForScrollBar(SB_HORZ))
  346.     height += (PDIMENSION)GetSystemMetrics(SM_CYHSCROLL);
  348.   if ((_exStyleBits&WS_EX_DLGMODALFRAME) != 0) {
  349.     width += (PDIMENSION)GetSystemMetrics(SM_CXDLGFRAME)*2;
  350.     height += (PDIMENSION)GetSystemMetrics(SM_CYDLGFRAME)*2;
  351.   }
  352.   else if ((_styleBits&WS_THICKFRAME) != 0) {
  353.     width += (PDIMENSION)GetSystemMetrics(SM_CXFRAME)*2;
  354.     height += (PDIMENSION)GetSystemMetrics(SM_CYFRAME)*2;
  355.   }
  357.   if ((_styleBits&(WS_CHILD|WS_POPUP|WS_OVERLAPPED)) != WS_CHILD && GetMenu(_hWnd) != NULL)
  358.     height += (PDIMENSION)GetSystemMetrics(SM_CYMENU);
  360.   SetWindowPos(_hWnd, NULL, 0, 0, width, height, SWP_NOMOVE|SWP_NOZORDER);
  361. }
  364. BOOL PInteractor::AdjustDimensionForScrollBar(UINT bar) const
  365. {
  366.   SCROLLINFO inf;
  367.   inf.cbSize = sizeof(inf);
  368.   inf.fMask = SIF_RANGE|SIF_PAGE;
  369.   GetScrollInfo(_hWnd, bar, &inf);
  370.   return inf.nMin != inf.nMax && inf.nPage < (UINT)(inf.nMax - inf.nMin);
  371. }
  374. PDim PInteractor::GetDimensions(CoordinateSystem coords) const
  375. {
  376.   PRect r;
  377.   GetClientRect(GetHWND(), r);
  378.   if (coords != LocalCoords)
  379.     return r.Dimensions();
  380.   return FromPixels(r.Dimensions());
  381. }
  384. PRect PInteractor::GetStructureBounds(CoordinateSystem coords) const
  385. {
  386.   PRect r;
  387.   GetWindowRect(GetHWND(), r);
  389.   if (coords == ScreenCoords)
  390.     return r;
  392.   PPoint p1(r.Origin());
  393.   ScreenToClient(GetHWND(), p1);
  395.   PPoint p2(r.Corner());
  396.   ScreenToClient(GetHWND(), p2);
  398.   if (coords == PixelCoords)
  399.     return PRect(p1, p2);
  401.   return PRect(FromPixels(p1), FromPixels(p2));
  402. }
  405. void PInteractor::_Invalidate(PORDINATE x, PORDINATE y,
  406.                               PDIMENSION dx, PDIMENSION dy,
  407.                               CoordinateSystem coords)
  408. {
  409.   RECT cr;
  410.   GetClientRect(GetHWND(), &cr);
  412.   RECT r;
  413.   switch (coords) {
  414.     case LocalCoords :
  415.       r.left = ToPixelsX(x);
  416.       r.top = ToPixelsY(y);
  417.       r.right = ToPixelsX(x+dx);
  418.       r.bottom = ToPixelsY(y+dy);
  419.       break;
  421.     case PixelCoords :
  422.       r.left = x;
  423.       r.top = y;
  424.       r.right = x+dx;
  425.       r.bottom = y+dy;
  426.       break;
  428.     default : // ScreenCoords
  429.       RECT wr;
  430.       GetWindowRect(GetHWND(), &wr);
  431.       r.left = wr.left+x;
  432.       r.top = wr.top+y;
  433.       r.right = x+dx;
  434.       r.bottom = y+dy;
  435.   }
  437.   if (r.left < cr.left)
  438.     r.left = cr.left;
  439.   if (r.right > cr.right)
  440.     r.right = cr.right;
  441.   if (r.top < cr.top)
  442.     r.top = cr.top;
  443.   if (r.bottom > cr.bottom)
  444.     r.bottom = cr.bottom;
  446.   InvalidateRect(_hWnd, &r, FALSE);
  447. }
  450. void PInteractor::_Validate(PORDINATE x, PORDINATE y,
  451.                             PDIMENSION dx, PDIMENSION dy,
  452.                             CoordinateSystem coords)
  453. {
  454.   RECT cr;
  455.   GetClientRect(GetHWND(), &cr);
  457.   RECT r;
  458.   switch (coords) {
  459.     case LocalCoords :
  460.       r.left = ToPixelsX(x);
  461.       r.top = ToPixelsY(y);
  462.       r.right = ToPixelsX(x+dx);
  463.       r.bottom = ToPixelsY(y+dy);
  464.       break;
  466.     case PixelCoords :
  467.       r.left = x;
  468.       r.top = y;
  469.       r.right = x+dx;
  470.       r.bottom = y+dy;
  471.       break;
  473.     default : // ScreenCoords
  474.       RECT wr;
  475.       GetWindowRect(GetHWND(), &wr);
  476.       r.left = wr.left+x;
  477.       r.top = wr.top+y;
  478.       r.right = x+dx;
  479.       r.bottom = y+dy;
  480.   }
  482.   if (r.left < cr.left)
  483.     r.left = cr.left;
  484.   if (r.right > cr.right)
  485.     r.right = cr.right;
  486.   if (r.top < cr.top)
  487.     r.top = cr.top;
  488.   if (r.bottom > cr.bottom)
  489.     r.bottom = cr.bottom;
  491.   ValidateRect(GetHWND(), &r);
  492. }
  495. void PInteractor::ReleaseMouse()
  496. {
  497.   if (HasMouse())
  498.     ReleaseCapture();
  499. }
  502. void PInteractor::SetCursorToParent(BOOL useParent)
  503. {
  504.   if (cursorMode == UseParentCursor || cursorMode == UseCurrentCursor) {
  505.     cursorMode = useParent ? UseParentCursor : UseCurrentCursor;
  506.     parent->SetWndCursor();
  507.   }
  508. }
  511. void PInteractor::SetCursor(const PCursor & newCursor)
  512. {
  513.   if (cursorMode == UseParentCursor || cursorMode == UseCurrentCursor) {
  514.     cursorMode = UseCurrentCursor;
  515.     cursor = newCursor;
  516.     if (_hWnd != P_DEAD_WINDOW &&
  517.                     ContainsPoint(GetCursorPos(ScreenCoords), ScreenCoords))
  518.       SetWndCursor();
  519.   }
  520. }
  523. void PInteractor::SetWndCursor() const
  524. {
  525.   if (cursorMode == UseParentCursor && parent != NULL)
  526.     parent->SetWndCursor();
  527.   else
  528.     ::SetCursor(cursor.GetHCURSOR());
  529. }
  532. void PInteractor::_SetCursorPos(PORDINATE x, PORDINATE y,
  533.                                 CoordinateSystem coords)
  534. {
  535.   PPoint p(x, y);
  536.   switch (coords) {
  537.     case LocalCoords :
  538.       p = ToPixels(p);
  539.     case PixelCoords :
  540.       ClientToScreen(GetHWND(), p);
  541.       break;
  542.     case ScreenCoords :
  543.       break;
  544.   }
  545.   ::SetCursorPos(p.X(), p.Y());
  546. }
  549. PPoint PInteractor::GetCursorPos(CoordinateSystem coords) const
  550. {
  551.   PPoint p;
  552.   ::GetCursorPos(p);
  554.   if (coords == ScreenCoords)
  555.     return p;
  557.   ::ScreenToClient(GetHWND(), p);
  558.   if (coords == PixelCoords)
  559.     return p;
  561.   return FromPixels(p);
  562. }
  565. PDim PInteractor::GetBorderSize() const
  566. {
  567.   return owner->GetBorderSize();
  568. }
  571. const PColour & PInteractor::GetBorderColour() const
  572. {
  573.   return owner->GetActiveBorderColour();
  574. }
  577. void PInteractor::SetBackgroundColour(const PColour & newColour)
  578. {
  579.   backgroundColour = newColour;
  580.   Invalidate();
  581. }
  584. BOOL PInteractor::HandleScrollBar(HWND scrWnd, WPARAM code, int trackVal)
  585. {
  586.   if (scrWnd == NULL)
  587.     return FALSE;
  589.   PScrollBar * bar = (PScrollBar *)owner->GetWindowObject(scrWnd);
  590.   if (bar == NULL)
  591.     return FALSE;
  593.   OnControlNotify(*bar, bar->TrackScrollBar(code, trackVal));
  595.   return TRUE;
  596. }
  599. BOOL PInteractor::HandleCommand(NMHDR & msg)
  600. {
  601.   if (msg.hwndFrom == NULL)
  602.     return FALSE;
  604.   PControl * control = (PControl*)owner->GetWindowObject(msg.hwndFrom);
  605.   if (control == NULL)
  606.     return FALSE;
  608.   _WindowsMessage * oldMessage = control->_msg;
  609.   control->_msg = _msg;
  610.   int option = control->TranslateOption(msg);
  611.   control->_msg = oldMessage;
  613.   if (option < 0)
  614.     return option < -1;
  616.   OnControlNotify(*control, option);
  618.   return !control->GetNotifier().IsNULL();
  619. }
  622. BOOL PInteractor::HandleDrawItem(const DRAWITEMSTRUCT FAR * dis)
  623. {
  624.   PControl * item = (PControl *)owner->GetWindowObject(dis->hwndItem);
  625.   if (item == NULL)
  626.     return FALSE;
  628.   switch (dis->CtlType) {
  629.     case ODT_BUTTON :
  630.       if (!((PPushButton *)item)->IsOwnerDraw())
  631.         return FALSE;
  632.       break;
  634.     case ODT_LISTBOX :
  635.       if (!item->IsDescendant(PCustomListBox::Class()))
  636.         return FALSE;
  637.       break;
  639.     default :
  640.       return FALSE;
  641.   }
  643.   PDrawCanvas canvas(item, dis->hDC, FALSE, FALSE);
  644.   BOOL focus = (dis->itemState&ODS_FOCUS) != 0;
  645.   BOOL select = (dis->itemState&ODS_SELECTED) != 0;
  647.   if (dis->CtlType == ODT_BUTTON) {
  648.     PPushButton * btn = (PPushButton *)item;
  649.     PRect bounds = btn->DrawButtonSurround(canvas, select);
  650.     btn->OnDrawFace(canvas, bounds, focus, select);
  651.   }
  652.   else {
  653.     PRect bounds = canvas.FromPixels(PRect(dis->rcItem));
  654.     if ((int)dis->itemID < 0)
  655.       canvas.DrawFocusRect(bounds);
  656.     else {
  657.       if (!item->IsEnabled()) {
  658.         canvas.SetTextFgColour(owner->GetGrayTextColour());
  659.         canvas.SetTextBkColour(owner->GetWindowBkColour());
  660.       }
  661.       else if (select) {
  662.         canvas.SetTextFgColour(owner->GetHighlightFgColour());
  663.         canvas.SetTextBkColour(owner->GetHighlightBkColour());
  664.       }
  665.       else {
  666.         canvas.SetTextFgColour(owner->GetWindowFgColour());
  667.         canvas.SetTextBkColour(owner->GetWindowBkColour());
  668.       }
  669.       canvas.SetPenFgColour(canvas.GetTextBkColour());
  670.       canvas.SetPenBkColour(canvas.GetTextBkColour());
  671.       canvas.SetFillFgColour(canvas.GetTextBkColour());
  672.       canvas.SetFillBkColour(canvas.GetTextBkColour());
  673.       ((PCustomListBox *)item)->OnDrawEntry(dis->itemID,
  674.                      *(PObject *)dis->itemData, canvas, bounds, focus, select);
  675.     }
  676.   }
  678.   return TRUE;
  679. }
  682. BOOL PInteractor::HandleMeasureItem(MEASUREITEMSTRUCT FAR * mis)
  683. {
  684.   if (mis->CtlType != ODT_LISTBOX)
  685.     return FALSE;
  687.   PCustomListBox * listBox =
  688.              (PCustomListBox *)owner->GetWindowObject(GetDlgItem(_hWnd, mis->CtlID));
  689.   if (listBox == NULL)
  690.     return FALSE;
  692.   if (!listBox->IsDescendant(PCustomListBox::Class()))
  693.     return FALSE;
  695.   PDrawCanvas listBoxCanvas(listBox);
  696.   PDim dim = listBoxCanvas.ToPixels(listBox->OnMeasureEntry(mis->itemID,
  697.                                     *(PObject *)mis->itemData, listBoxCanvas));
  698.   mis->itemWidth = dim.Width();
  699.   mis->itemHeight = dim.Height();
  700.   return TRUE;
  701. }
  704. int PInteractor::HandleCompareItem(const COMPAREITEMSTRUCT FAR * cis)
  705. {
  706.   if (cis->CtlType != ODT_LISTBOX)
  707.     return P_MAX_INDEX;
  709.   PInteractor * listBox = owner->GetWindowObject(cis->hwndItem);
  710.   if (listBox == NULL)
  711.     return P_MAX_INDEX;
  713.   if (!listBox->IsDescendant(PCustomListBox::Class()))
  714.     return P_MAX_INDEX;
  716.   PObject * obj1 = (PObject *)cis->itemData1;
  717.   PObject * obj2 = (PObject *)cis->itemData2;
  718.   if (obj1 == NULL || obj2 == NULL)
  719.     return P_MAX_INDEX;
  721.   return obj1->Compare(*obj2);
  722. }
  725. BOOL PInteractor::HandleDeleteItem(const DELETEITEMSTRUCT FAR * dis)
  726. {
  727.   if (dis->CtlType != ODT_LISTBOX)
  728.     return FALSE;
  730.   PListBox * listBox = (PListBox*)owner->GetWindowObject(dis->hwndItem);
  731.   if (listBox == NULL)
  732.     return FALSE;
  734.   if (!listBox->IsDescendant(PCustomListBox::Class()))
  735.     return FALSE;
  737.   if (listBox->deleteObjects)
  738.     delete (PObject *)dis->itemData;
  740.   return TRUE;
  741. }
  744. static PKeyCode KeyFromMouseEvent(UINT event, WPARAM wParam)
  745. {
  746.   switch (event) {
  747.     case WM_MBUTTONDOWN :
  748.     case WM_MBUTTONDBLCLK :
  749.     case WM_MBUTTONUP :
  750.       return PKeyCode(TRUE, wParam, PKeyCode::MiddleButton);
  752.     case WM_RBUTTONDOWN :
  753.     case WM_RBUTTONDBLCLK :
  754.     case WM_RBUTTONUP :
  755.       return PKeyCode(TRUE, wParam, PKeyCode::RightButton);
  756.   }
  757.   return PKeyCode(TRUE, wParam, PKeyCode::LeftButton);
  758. }
  761. BOOL PInteractor::HandleCtlColour(HWND ctlWnd,
  762.                          HDC hDC, const PColour & defFg, const PColour & defBk)
  763. {
  764.   PInteractor * control = owner->GetWindowObject(ctlWnd);
  765.   if (control == NULL)
  766.     return FALSE;
  768.   const PColour & fg = control->GetForegroundColour();
  769.   const PColour & bk = control->GetBackgroundColour();
  770.   if (fg == defFg && bk == defBk)
  771.     return FALSE;
  773.   SetTextColor(hDC, fg.ToCOLORREF());
  774.   SetBkColor(hDC, bk.ToCOLORREF());
  775.   if (control->hBackgroundBrush == NULL)
  776.     control->hBackgroundBrush = CreateSolidBrush(bk.ToCOLORREF());
  777.   _msg->lResult = (LPARAM)control->hBackgroundBrush;
  778.   return TRUE;
  779. }
  782. void PInteractor::WndProc()
  783. {
  784.   switch (_msg->event) {
  785.     case WM_MOUSEMOVE :
  786.       if (PGET_CLASS_VALUE(_hWnd, HCURSOR) == 0)
  787.         SetWndCursor();
  788.       _OnMouseMove(PKeyCode(TRUE, _msg->wParam, PKeyCode::NullValue), PPoint(_msg->lParam));
  789.       return;
  791.     case WM_LBUTTONDOWN :
  792.     case WM_MBUTTONDOWN :
  793.     case WM_RBUTTONDOWN :
  794.       owner->DoBalloonHelp(NULL);
  795.       if (GetCapture() == NULL)
  796.         SetCapture(_hWnd);
  797.       OnMouseDown(KeyFromMouseEvent(_msg->event, _msg->wParam), PPoint(_msg->lParam), FALSE);
  798.       return;
  800.     case WM_LBUTTONDBLCLK :
  801.     case WM_MBUTTONDBLCLK :
  802.     case WM_RBUTTONDBLCLK :
  803.       owner->DoBalloonHelp(NULL);
  804.       OnMouseDown(KeyFromMouseEvent(_msg->event, _msg->wParam), PPoint(_msg->lParam), TRUE);
  805.       return;
  807.     case WM_LBUTTONUP :
  808.     case WM_MBUTTONUP :
  809.     case WM_RBUTTONUP :
  810.       _OnMouseUp(KeyFromMouseEvent(_msg->event, _msg->wParam), PPoint(_msg->lParam));
  811.       if (GetCapture() == _hWnd)
  812.         ReleaseCapture();
  813.       return;
  815.     case WM_KEYDOWN :
  816.       owner->DoBalloonHelp(NULL);
  817.       if (OnKeyDown(PKeyCode(FALSE, _msg->wParam, HIWORD(_msg->lParam)),
  818.                       (_msg->lParam&0x40000000)!=0 ? LOWORD(_msg->lParam) : 0))
  819.         DefWndProc();
  820.       return;
  822.     case WM_KEYUP :
  823.       owner->DoBalloonHelp(NULL);
  824.       OnKeyUp(PKeyCode(FALSE, _msg->wParam, HIWORD(_msg->lParam)));
  825.       return;
  827.     case WM_CHAR :
  828.       OnKeyInput(PString((char)_msg->wParam));
  829.       return;
  831.     case WM_SETFOCUS : {
  832.       caret.Activate(this, caretVisible <= 0);
  833.       OnGainFocus();
  834.       PInteractor * focus = GetFocusInteractor();
  835.       if (focus != this && focus != NULL) {
  836.         if (focus->OnEndInput()) {
  837.           SetFocusInteractor(this);
  838.           OnStartInput();
  839.         }
  840.         else
  841.           focus->GrabFocus();
  842.       }
  843.       break;
  844.     }
  846.     case WM_KILLFOCUS :
  847.       caret.Deactivate(this);
  848.       OnLostFocus();
  849.       break;
  851.     case WM_VSCROLL :
  852.     case WM_HSCROLL :
  853. #if defined(_WIN32)
  854.       if (HandleScrollBar((HWND)_msg->lParam,
  855.                                    LOWORD(_msg->wParam), HIWORD(_msg->wParam)))
  856. #else
  857.       if (HandleScrollBar((HWND)HIWORD(_msg->lParam),
  858.                                       _msg->wParam, (int)LOWORD(_msg->lParam)))
  859. #endif
  860.         return;
  861.       break;
  863.     case WM_COMMAND :
  864.     {
  865.       NMHDR msg;
  866. #if defined(_WIN32)
  867.       msg.hwndFrom = (HWND)_msg->lParam;
  868.       msg.idFrom = LOWORD(_msg->wParam);
  869.       msg.code = HIWORD(_msg->wParam);
  870. #else
  871.       msg.hwndFrom = (HWND)LOWORD(_msg->lParam);
  872.       msg.idFrom = wParam;
  873.       msg.code = HIWORD(_msg->lParam);
  874. #endif
  875.       if (HandleCommand(msg))
  876.         return;
  877.       break;
  878.     }
  880.     case WM_NOTIFY :
  881.       if (HandleCommand(*(LPNMHDR)_msg->lParam))
  882.         return;
  883.       break;
  885.     case WM_DRAWITEM :
  886.       if (HandleDrawItem((const DRAWITEMSTRUCT FAR *)_msg->lParam)) {
  887.         _msg->lResult = TRUE;
  888.         return;
  889.       }
  890.       break;
  892.     case WM_MEASUREITEM :
  893.       if (HandleMeasureItem((MEASUREITEMSTRUCT FAR *)_msg->lParam), _hWnd) {
  894.         _msg->lResult = TRUE;
  895.         return;
  896.       }
  897.       break;
  899.     case WM_COMPAREITEM :
  900.       switch (HandleCompareItem((const COMPAREITEMSTRUCT FAR *)_msg->lParam)) {
  901.         case PObject::LessThan :
  902.           _msg->lResult = -1;
  903.           return;
  904.         case PObject::EqualTo :
  905.           _msg->lResult = 0;
  906.           return;
  907.         case PObject::GreaterThan :
  908.           _msg->lResult = 1;
  909.           return;
  910.       }
  911.       break;
  913.     case WM_DELETEITEM :
  914.       if (HandleDeleteItem((const DELETEITEMSTRUCT FAR *)_msg->lParam)) {
  915.         _msg->lResult = TRUE;
  916.         return;
  917.       }
  918.       break;
  920.     case WM_ERASEBKGND :
  921.       if (PGET_CLASS_VALUE(_hWnd, HBRBACKGROUND) == 0) {
  922.         HBRUSH b = CreateSolidBrush(backgroundColour.ToCOLORREF());
  923.         RECT r;
  924.         GetClientRect(_hWnd, &r);
  925.         FillRect((HDC)_msg->wParam, &r, b);
  926.         DeleteObject(b);
  927.         _msg->lResult = TRUE;
  928.         return;
  929.       }
  930.       break;
  932. #ifdef _WIN32
  933.     case WM_CTLCOLORBTN :
  934.     case WM_CTLCOLORSTATIC :
  935.       if (HandleCtlColour((HWND)_msg->lParam, (HDC)_msg->wParam,
  936.                        owner->GetButtonFgColour(), owner->GetButtonBkColour()))
  937.         return;
  938.       break;
  939.     case WM_CTLCOLORSCROLLBAR :
  940.       if (HandleCtlColour((HWND)_msg->lParam, (HDC)_msg->wParam,
  941.                      owner->GetScrollBarColour(), owner->GetScrollBarColour()))
  942.         return;
  943.       break;
  944.     case WM_CTLCOLOREDIT :
  945.     case WM_CTLCOLORLISTBOX :
  946.       if (HandleCtlColour((HWND)_msg->lParam, (HDC)_msg->wParam,
  947.                        owner->GetWindowFgColour(), owner->GetWindowBkColour()))
  948.         return;
  949.       break;
  950. #else
  951.     case WM_CTLCOLOR :
  952.       switch (HIWORD(_msg->lParam)) {
  953.         case CTLCOLOR_BTN :
  954.           if (HandleCtlColour((HWND)LOWORD(_msg->lParam), (HDC)_msg->wParam,
  955.                        owner->GetButtonFgColour(), owner->GetButtonBkColour()))
  956.             return;
  957.           break;
  958.         case CTLCOLOR_SCROLLBAR :
  959.           if (HandleCtlColour((HWND)LOWORD(_msg->lParam), (HDC)_msg->wParam,
  960.                      owner->GetScrollBarColour(), owner->GetScrollBarColour()))
  961.             return;
  962.           break;
  963.         case CTLCOLOR_EDIT :
  964.         case CTLCOLOR_STATIC :
  965.         case CTLCOLOR_LISTBOX :
  966.           if (HandleCtlColour((HWND)LOWORD(_msg->lParam), (HDC)_msg->wParam,
  967.                        owner->GetWindowFgColour(), owner->GetWindowBkColour()))
  968.             return;
  969.           break;
  970.       }
  971.       break;
  972. #endif
  974.     case WM_PAINT :
  975.       if (_in_WM_PAINT)
  976.         DefWndProc();
  977.       else {
  978.         _in_WM_PAINT = TRUE;
  979.         PRedrawCanvas canvas(this, FALSE);
  980.         OnRedraw(canvas);
  981.         if (canvas.NullHDC())
  982.           DefWndProc();
  983.         _in_WM_PAINT = FALSE;
  984.       }
  985.       return;
  987.     case WM_DESTROY :
  988.       owner->DoBalloonHelp(NULL);
  989.       owner->RemoveWindowHandle(_hWnd);
  990.       RemoveWndFont();
  991.       _hWnd = P_DEAD_WINDOW;
  992.       return;
  993.   }
  994.   DefWndProc();
  995. }
  998. void PInteractor::DefWndProc()
  999. {
  1000.   _msg->lResult=DefWindowProc(_hWnd, _msg->event, _msg->wParam, _msg->lParam);
  1001.   _msg->processed = FALSE;
  1002. }
  1005. void PInteractor::OnMouseDown(PKeyCode, const PPoint &, BOOL)
  1006. {
  1007.   if (GetCapture() == _hWnd)
  1008.     ReleaseCapture();
  1009.   DefWndProc();
  1010. }
  1013. void PInteractor::OnMouseUp(PKeyCode, const PPoint &)
  1014. {
  1015.   DefWndProc();
  1016. }
  1019. void PInteractor::OnMouseMove(PKeyCode, const PPoint &)
  1020. {
  1021.   DefWndProc();
  1022. }
  1025. BOOL PInteractor::OnKeyDown(PKeyCode, unsigned)
  1026. {
  1027.   return TRUE;
  1028. }
  1031. void PInteractor::OnKeyUp(PKeyCode key)
  1032. {
  1033.   DefWndProc();
  1034. }
  1037. void PInteractor::OnKeyInput(const PString &)
  1038. {
  1039.   DefWndProc();
  1040. }
  1043. void PInteractor::OnGainFocus()
  1044. {
  1045.   DefWndProc();
  1046. }
  1049. void PInteractor::OnLostFocus()
  1050. {
  1051.   DefWndProc();
  1052. }
  1055. void PInteractor::OnRedraw(PCanvas & canvas)
  1056. {
  1057.   if (canvas.NullHDC() && canvas.IsDescendant(PRedrawCanvas::Class())) {
  1058.     DefWndProc();
  1059.     canvas.SetHDC(GetDC(_hWnd));
  1060.   }
  1061. }
  1064. void PInteractor::SetWndFont() const
  1065. {
  1066.   RemoveWndFont();
  1067.   HFONT hFont = CreateFont(font.GetHeight(TRUE),
  1068.                            0, 0, 0,
  1069.                            font.IsBold() ? FW_BOLD : FW_NORMAL,
  1070.                            (BYTE)font.IsItalic(),
  1071.                            (BYTE)font.IsUnderlined(),
  1072.                            0, 0, 0, 0, 0, 0,
  1073.                            font.GetFacename());
  1074.   PAssertOS(hFont != NULL);
  1075.   SendMessage(GetHWND(), WM_SETFONT, (WPARAM)hFont, 0L);
  1076.   if ((HFONT)(UINT)SendMessage(GetHWND(), WM_GETFONT, 0, 0L) != hFont)
  1077.     DeleteObject(hFont);
  1078. }
  1081. void PInteractor::RemoveWndFont() const
  1082. {
  1083.   HFONT hFont = (HFONT)(UINT)SendMessage(GetHWND(), WM_GETFONT, 0, 0L);
  1084.   if (hFont == NULL)
  1085.     return;
  1087.   HWND parWnd = P_DEAD_WINDOW;
  1088.   if (GetParent() != NULL)
  1089.     parWnd = GetParent()->_hWnd;
  1091.   if (parWnd != P_DEAD_WINDOW &&
  1092.                   (HFONT)(UINT)SendMessage(parWnd, WM_GETFONT, 0, 0L) == hFont)
  1093.     return; // Let parent class delete the hFont
  1095.   SendMessage(GetHWND(), WM_SETFONT, NULL, 0L);
  1096.   DeleteObject(hFont);
  1097. }
  1100. void PInteractor::GetCreateWinInfo(WNDCLASS & wndClass)
  1101. {
  1102.   wndClass.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
  1103.   wndClass.lpfnWndProc = owner->GetWndProcPtr(PApplication::WndProcType);
  1104.   wndClass.cbClsExtra = 0;
  1105.   wndClass.cbWndExtra = 0;
  1106.   wndClass.hInstance = owner->GetInstance();
  1107.   wndClass.hIcon = NULL;
  1108.   wndClass.hCursor = NULL;
  1109.   wndClass.hbrBackground = NULL;
  1110.   wndClass.lpszMenuName = NULL;
  1111.   wndClass.lpszClassName = GetClass();
  1112.   _styleBits = WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS;
  1113.   _exStyleBits = WS_EX_NOPARENTNOTIFY;
  1114. }
  1117. PINDEX PInteractor::GetNumChildren()
  1118. {
  1119.   if (_hWnd == NULL)
  1120.     GetHWND();
  1121.   return children.GetSize();
  1122. }
  1124. HWND PInteractor::GetHWND() const
  1125. {
  1126.   if (_hWnd == NULL) {
  1127.     if (PThread::Current() == owner)
  1128.       ((PInteractor*)this)->CreateHWND();
  1129.     else {
  1130.       // All windows must be created in the main thread, so go to stupid
  1131.       // lengths to make sure it happens
  1132.       owner->windowsMutex.Wait();
  1133.       owner->delayedCreateInteractors.Append((PInteractor*)this);
  1134.       owner->windowsMutex.Signal();
  1135.       // Post a message to unblock the main loop, so can process above.
  1136.       ::PostThreadMessage(owner->GetThreadId(), WM_USER, 0, 0);
  1137.       // Wait for main loop thread to do the job.
  1138.       owner->delayedCreateInteractorsDone.Wait();
  1139.     }
  1140.   }
  1142.   if (_hWnd != NULL && _hWnd != P_DEAD_WINDOW)
  1143.     return _hWnd;
  1145.   PAssertAlways(PInvalidWindow);
  1146.   return NULL;
  1147. }
  1150. void PInteractor::CreateHWND()
  1151. {
  1152.   PAssert(parent != NULL ||
  1153.                IsDescendant(PTopLevelWindow::Class()), "Window has no parent");
  1155.   HINSTANCE hInst = owner->GetInstance();
  1157.   WNDCLASS wclass;
  1158.   GetCreateWinInfo(wclass);
  1159.   if (!GetClassInfo(hInst, wclass.lpszClassName, &wclass))
  1160.     PAssertOS(RegisterClass(&wclass));
  1162.   _hWnd = CreateWindowEx(_exStyleBits, wclass.lpszClassName, "", _styleBits,
  1163.                          CW_USEDEFAULT, CW_USEDEFAULT,
  1164.                          CW_USEDEFAULT, CW_USEDEFAULT,
  1165.                          parent != NULL ? parent->GetHWND() : NULL,
  1166.                          NULL, hInst, NULL);
  1167.   owner->AddWindowHandle(PAssertNULL(_hWnd), this);
  1169.   SetWndFont();
  1170. }
  1173. PString PInteractor::GetWndText(UINT lenMsg,
  1174.                            UINT getMsg,WPARAM wParamGet, WPARAM wParamLen) const
  1175. {
  1176.   PString title;
  1177.   HWND hWnd = GetHWND();
  1178.   UINT len = (UINT)SendMessage(hWnd, lenMsg, wParamLen, 0L)+1;
  1179.   if (len < sizeof(UINT))
  1180.     len = sizeof(UINT);
  1181.   char * ptr = title.GetPointer(len);
  1182.   if (wParamGet == (WPARAM)-1)
  1183.     wParamGet = len;
  1184.   else
  1185.     *(UINT *)ptr = len;
  1186.   SendMessage(hWnd, getMsg, wParamGet, (DWORD)(LPSTR)ptr);
  1187.   PINDEX pos;
  1188.   while ((pos = title.Find("rn")) != P_MAX_INDEX)
  1189.     title.Delete(pos, 1);
  1190.   return title;
  1191. }
  1195. //////////////////////////////////////////////////////////////////////////////
  1198. PTitledWindow::PTitledWindow(PInteractor * par, unsigned CanDo)
  1199.   : PInteractor(par),
  1200.     icon(PSTD_ID_ICON_WINDOW)
  1201. {
  1202.   focusInteractor = this;
  1203.   initFlags = CanDo;
  1204. }
  1207. PTitledWindow::PTitledWindow(unsigned CanDo)
  1208.   : icon(PSTD_ID_ICON_WINDOW)
  1209. {
  1210.   focusInteractor = this;
  1211.   initFlags = CanDo;
  1212. }
  1215. void PTitledWindow::GetCreateWinInfo(WNDCLASS & wndClass)
  1216. {
  1217.   PInteractor::GetCreateWinInfo(wndClass);
  1219.   if ((initFlags&CanClose) == 0)
  1220.     wndClass.style |= CS_NOCLOSE;
  1221.   wndClass.hIcon = icon.GetHICON();
  1223.   if ((initFlags&CanGrow) != 0)
  1224.     _styleBits |= WS_THICKFRAME;
  1226.   if ((initFlags&CanIconify) != 0)
  1227.     _styleBits |= WS_MINIMIZEBOX;
  1229.   if ((initFlags&CanZoom) != 0)
  1230.     _styleBits |= WS_MAXIMIZEBOX;
  1232.   _styleBits |= WS_CAPTION|WS_SYSMENU;
  1233. }
  1236. void PTitledWindow::WndProc()
  1237. {
  1238.   switch (_msg->event) {
  1239.     case WM_CLOSE :
  1240.       Close();
  1241.       return;
  1243.     case WM_DESTROY :
  1244.       OnClose();
  1245.       break;
  1247.     case WM_SETFOCUS :
  1248.       if (GetFocusInteractor() != this) {
  1249.         GetFocusInteractor()->GrabFocus();
  1250.         DefWndProc();
  1251.         return;
  1252.       }
  1253.       break;
  1255.     case WM_NCACTIVATE :
  1256.       if (_msg->wParam == FALSE && owner->balloon != NULL) {
  1257.         _msg->lResult = 0;
  1258.         return;
  1259.       }
  1260.       break;
  1262.     case WM_ACTIVATE :
  1263.       OnActivate(LOWORD(_msg->wParam) != WA_INACTIVE);
  1264.       break;
  1266.     case WM_MDIACTIVATE :
  1267.       OnActivate((HWND)(UINT)_msg->lParam == _hWnd);
  1268.       break;
  1270.     case WM_MOVE :
  1271.       OnReposition(PPoint(_msg->lParam));
  1272.       break;
  1274.     case WM_SIZE :
  1275.       if (IsWindowVisible(_hWnd))
  1276.         OnResize(PDim::FromDWORD(_msg->lParam),
  1277.                  _msg->wParam == SIZE_MINIMIZED ? Iconic :
  1278.                  _msg->wParam == SIZE_MAXIMIZED ? Zoomed : Normalised);
  1279.       break;
  1281.     case WM_GETMINMAXINFO :
  1282.       MINMAXINFO * mmi = (MINMAXINFO *)_msg->lParam;
  1284.       PRect client;
  1285.       GetClientRect(GetHWND(), client);
  1286.       PRect structure = client;
  1287.       AdjustWindowRectEx(structure, _styleBits,
  1288.                          IsDescendant(PTopLevelWindow::Class()) &&
  1289.                                   ((PTopLevelWindow *)this)->GetMenu() != NULL,
  1290.                          _exStyleBits);
  1291.       PDim adjust = structure.Dimensions() - client.Dimensions();
  1293.       if (minSize.Width() != 0 && minSize.Height() != 0) {
  1294.         mmi->ptMinTrackSize.x = minSize.Width() + adjust.Width();
  1295.         mmi->ptMinTrackSize.y = minSize.Height() + adjust.Height();
  1296.       }
  1298.       if (maxSize.Width() != 0 && maxSize.Height() != 0) {
  1299.         mmi->ptMaxTrackSize.x = maxSize.Width() + adjust.Width();
  1300.         mmi->ptMaxTrackSize.y = maxSize.Height() + adjust.Height();
  1301.       }
  1303.       if (zoomSize.Width() != 0 && zoomSize.Height() != 0) {
  1304.         mmi->ptMaxSize.x = zoomSize.Width() + adjust.Width();
  1305.         mmi->ptMaxSize.y = zoomSize.Height() + adjust.Height();
  1306.       }
  1307.       break;
  1308.   }
  1309.   PInteractor::WndProc();
  1310. }
  1313. void PTitledWindow::SetMinSize(const PDim & dim, CoordinateSystem coords)
  1314. {
  1315.   if (coords != LocalCoords)
  1316.     minSize = dim;
  1317.   else
  1318.     minSize = ToPixels(dim);
  1319.   SetDimensions(GetDimensions(PixelCoords), PixelCoords);
  1320. }
  1323. void PTitledWindow::SetMaxSize(const PDim & dim, CoordinateSystem coords)
  1324. {
  1325.   if (coords != LocalCoords)
  1326.     maxSize = dim;
  1327.   else
  1328.     maxSize = ToPixels(dim);
  1329.   SetDimensions(GetDimensions(PixelCoords), PixelCoords);
  1330. }
  1333. void PTitledWindow::SetIcon(const PIcon & icn)
  1334. {
  1335.   PSET_CLASS_VALUE(GetHWND(), HICON, icn.GetHICON());
  1336.   icon = icn;
  1337. }
  1340. void PTitledWindow::OnReposition(const PPoint &)
  1341. {
  1342.   DefWndProc();
  1343. }
  1346. void PTitledWindow::OnActivate(BOOL)
  1347. {
  1348.   DefWndProc();
  1349. }
  1352. void PTitledWindow::OnResize(const PDim &, ResizeType)
  1353. {
  1354.   DefWndProc();
  1355. }
  1358. //////////////////////////////////////////////////////////////////////////////
  1361. PTopLevelWindow::PTopLevelWindow(unsigned CanDo)
  1362.   : PTitledWindow(CanDo),
  1363.     helpMenu(PResourceString(PSTD_ID_STR_HELP_MENU, "&Help"))
  1364. {
  1365.   menu = NULL;
  1366.   deleteMenu = FALSE;
  1368.   if (owner->mainWindow == NULL)
  1369.     owner->mainWindow = this;
  1371.   SetTitle(owner->GetName());
  1372.   SetMenu(NULL);
  1374.   new PMenuItem(PSTD_ID_MENU_HELP_CONTENTS, helpMenu,
  1375.                       PResourceString(PSTD_ID_STR_HELP_CONTENTS, "&Contents"));
  1376.   new PMenuItem(PSTD_ID_STR_HELP_SEARCH, helpMenu,
  1377.               PResourceString(PSTD_ID_STR_HELP_SEARCH, "&Search for Help..."));
  1378.   new PMenuItem(PSTD_ID_MENU_HELP_ON_HELP, helpMenu,
  1379.                 PResourceString(PSTD_ID_STR_HELP_ON_HELP, "&How to Use Help"));
  1380.   new PMenuSeparator(helpMenu);
  1381.   new PMenuItem(PSTD_ID_MENU_ABOUT, helpMenu, owner->GetAboutMenuItemString());
  1382. }
  1385. PTopLevelWindow::~PTopLevelWindow()
  1386. {
  1387.   if (deleteMenu)
  1388.     delete menu;
  1390.   if (owner->mainWindow == this)
  1391.     owner->mainWindow = NULL;
  1392. }
  1395. void PTopLevelWindow::WndProc()
  1396. {
  1397.   switch (_msg->event) {
  1398.     case WM_SYSCOMMAND :
  1399.       if (_msg->wParam == PSTD_ID_MENU_ABOUT) {
  1400.         owner->OnAbout();
  1401.         return;
  1402.       }
  1403.       break;
  1405.     case WM_COMMAND :
  1406.       switch (_msg->wParam) {
  1407.         case PSTD_ID_MENU_ABOUT :
  1408.           owner->OnAbout();
  1409.           return;
  1411.         case PSTD_ID_MENU_HELP_CONTENTS :
  1412.           owner->DoContextHelp(PSTD_ID_HELP_CONTENTS);
  1413.           return;
  1415.         case PSTD_ID_MENU_HELP_SEARCH :
  1416.           owner->DoContextHelp(PSTD_ID_HELP_SEARCH);
  1417.           return;
  1419.         case PSTD_ID_MENU_HELP_ON_HELP :
  1420.           owner->DoContextHelp(PSTD_ID_HELP_ON_HELP);
  1421.           return;
  1423.         default :
  1424.           if (menu != NULL &&
  1425. #if defined(_WIN32)
  1426.                               _msg->lParam == 0)
  1427. #else
  1428.                               LOWORD(_msg->lParam) == 0)
  1429. #endif
  1430.           {
  1431.             PMenuItem*item=menu->GetItemFromKey((PRESOURCE_ID)LOWORD(_msg->wParam));
  1432.             if (item != NULL) {
  1433.               OnMenuItemSelect(*item);
  1434.               return;
  1435.             }
  1436.           }
  1437.       }
  1438.       break;
  1440.     case WM_INITMENU :
  1441.       if (_msg->wParam != 0 && menu != NULL) {
  1442.         OnMenuStartSelect();
  1443.         return;
  1444.       }
  1445.       break;
  1446.   }
  1447.   PTitledWindow::WndProc();
  1448. }
  1451. void PTopLevelWindow::GetCreateWinInfo(WNDCLASS & wndClass)
  1452. {
  1453.   PTitledWindow::GetCreateWinInfo(wndClass);
  1454.   _styleBits &= ~WS_CHILD;
  1455. }
  1458. //////////////////////////////////////////////////////////////////////////////
  1461. PMDIFrameWindow::PMDIFrameWindow(unsigned CanDo)
  1462.   : PTopLevelWindow(CanDo),
  1463.     windowMenu(PResourceString(PSTD_ID_STR_WINDOW_MENU, "&Window"))
  1464. {
  1465.   CLIENTCREATESTRUCT ccs;
  1466.   ccs.hWindowMenu = windowMenu.GetHMENU();
  1467.   ccs.idFirstChild = 32000;
  1468.   mdiClient = CreateWindow("MDICLIENT", "",
  1469.        WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_VISIBLE|MDIS_ALLCHILDSTYLES,
  1470.        0, 0, 0, 0, GetHWND(), NULL, owner->GetInstance(), &ccs);
  1471.   PAssertNULL(mdiClient);
  1473.   owner->mdiClient = mdiClient;
  1475.   backgroundColour.FromSYSCOLOR(COLOR_APPWORKSPACE);
  1477.   new PMenuItem(PSTD_ID_MENU_WINDOW_CASCADE, windowMenu,
  1478.                       PResourceString(PSTD_ID_STR_WINDOW_CASCADE, "&Cascade"));
  1479.   new PMenuItem(PSTD_ID_MENU_WINDOW_TILE, windowMenu,
  1480.                             PResourceString(PSTD_ID_STR_WINDOW_TILE, "&Tile"));
  1481.   new PMenuItem(PSTD_ID_MENU_WINDOW_ARRANGE, windowMenu,
  1482.                 PResourceString(PSTD_ID_STR_WINDOW_ARRANGE, "&Arrange Icons"));
  1483. }
  1486. PMDIDocWindow * PMDIFrameWindow::GetActiveDocument()
  1487. {
  1488.   HWND hChild = (HWND)(UINT)SendMessage(mdiClient, WM_MDIGETACTIVE, 0, 0L);
  1489.   if (hChild == NULL)
  1490.     return NULL;
  1491.   PInteractor * window = owner->GetWindowObject(hChild);
  1492.   return (PMDIDocWindow *)PAssertNULL(window);
  1493. }
  1496. void PMDIFrameWindow::SetDocumentArea(const PRect & rect,
  1497.                                       CoordinateSystem coords)
  1498. {
  1499.   switch (coords) {
  1500.     case LocalCoords :
  1501.       documentArea = ToPixels(rect);
  1502.       break;
  1503.     case PixelCoords :
  1504.       documentArea = rect;
  1505.       break;
  1506.     case ScreenCoords :
  1507.       PPoint origin = rect.Origin();
  1508.       ClientToScreen(GetHWND(), origin);
  1509.       documentArea = rect;
  1510.       documentArea.SetOrigin(origin);
  1511.   }
  1512.   PRect r = documentArea;
  1513.   if (documentArea.IsEmpty())
  1514.     r = GetDimensions(PixelCoords);
  1515.   SetWindowPos(mdiClient, HWND_BOTTOM,
  1516.                           r.X(), r.Y(), r.Width(), r.Height(), SWP_NOACTIVATE);
  1517. }
  1520. void PMDIFrameWindow::WndProc()
  1521. {
  1522.   switch (_msg->event) {
  1523.     case WM_COMMAND :
  1524.       switch (_msg->wParam) {
  1525.         case PSTD_ID_MENU_WINDOW_CASCADE :
  1526.           CascadeDocuments();
  1527.           return;
  1529.         case PSTD_ID_MENU_WINDOW_TILE :
  1530.           TileDocuments(GetKeyState(VK_SHIFT) < 0);
  1531.           return;
  1533.         case PSTD_ID_MENU_WINDOW_ARRANGE :
  1534.           ArrangeIcons();
  1535.           return;
  1536.       }
  1537.       break;
  1539.     case WM_SIZE :
  1540.       PTopLevelWindow::WndProc();
  1541.       SetDocumentArea(documentArea, PixelCoords);
  1542.       return;
  1543.   }
  1544.   PTopLevelWindow::WndProc();
  1545. }
  1548. void PMDIFrameWindow::DefWndProc()
  1549. {
  1550.   _msg->lResult = DefFrameProc(_hWnd,
  1551.                            mdiClient, _msg->event, _msg->wParam, _msg->lParam);
  1552. }
  1555. ///////////////////////////////////////////////////////////////////////////////
  1556. // PMDIDocWindow
  1558. PMDIDocWindow::~PMDIDocWindow()
  1559. {
  1560.   if (_hWnd != NULL && _hWnd != P_DEAD_WINDOW)
  1561.     SendMessage(((PMDIFrameWindow*)GetParent())->mdiClient,
  1562.                                              WM_MDIDESTROY, (WPARAM)_hWnd, 0L);
  1563. }
  1566. void PMDIDocWindow::CreateHWND()
  1567. {
  1568.   PAssert(parent->IsDescendant(PMDIFrameWindow::Class()), "Bad MDI parent");
  1570.   HINSTANCE hInst = owner->GetInstance();
  1572.   WNDCLASS wclass;
  1573.   MDICREATESTRUCT mcs;
  1574.   GetCreateWinInfo(wclass);
  1575.   mcs.style = _styleBits;
  1576.   mcs.szClass = wclass.lpszClassName;
  1577.   mcs.szTitle = initialTitle;
  1578.   mcs.hOwner = hInst;
  1579.   mcs.x = mcs.y = mcs.cx = mcs.cy = CW_USEDEFAULT;
  1580.   mcs.lParam = 0;
  1582.   if (!GetClassInfo(hInst, wclass.lpszClassName, &wclass))
  1583.     PAssertOS(RegisterClass(&wclass));
  1585. #if defined(_WIN32)
  1586.   _hWnd = CreateMDIWindow((LPTSTR)mcs.szClass, (LPTSTR)mcs.szTitle,
  1587.                           mcs.style, mcs.x, mcs.y, mcs.cx, mcs.cy,
  1588.                           ((PMDIFrameWindow *)parent)->mdiClient,
  1589.                           hInst, mcs.lParam);
  1590. #else
  1591.   _hWnd = (HWND)(UINT)SendMessage(((PMDIFrameWindow *)parent)->mdiClient,
  1592.                                   WM_MDICREATE, 0, (LPARAM)&mcs);
  1593. #endif
  1595.   owner->AddWindowHandle(PAssertNULL(_hWnd), this);
  1597.   SetWndFont();
  1598. }
  1601. void PMDIDocWindow::DefWndProc()
  1602. {
  1603.   _msg->lResult = DefMDIChildProc(_hWnd,_msg->event,_msg->wParam,_msg->lParam);
  1604. }
  1607. void PMDIDocWindow::Show(BOOL visible)
  1608. {
  1609.   ShowWindow(GetHWND(), visible ? SW_SHOW : SW_HIDE);
  1610. #if defined(_WIN32)
  1611.   SendMessage(((PMDIFrameWindow *)parent)->mdiClient,WM_MDIREFRESHMENU, 0, 0L);
  1612. #else  
  1613.   SendMessage(((PMDIFrameWindow *)parent)->mdiClient, WM_MDISETMENU, TRUE, 0L);
  1614. #endif
  1615.   PDim dim = GetDimensions(PixelCoords);
  1616.   PInteractor::_WindowsMessage * oldMsg = _msg;
  1617.   PInteractor::_WindowsMessage message;
  1618.   message.event = WM_SIZE;
  1619.   message.wParam = SIZE_RESTORED;
  1620.   message.lParam = dim.ToDWORD();
  1621.   message.lResult = 0;
  1622.   message.processed = TRUE;
  1623.   _msg = &message;
  1624.   OnResize(dim, Normalised);
  1625.   _msg = oldMsg;
  1626. }
  1629. void PMDIDocWindow::Activate()
  1630. {
  1631.   if (!IsVisible())
  1632.     Show();
  1633.   SendMessage(((PMDIFrameWindow*)parent)->mdiClient,
  1634.                                        WM_MDIACTIVATE, (WPARAM)GetHWND(), 0L);
  1635. }
  1638. void PMDIDocWindow::SetTitle(const PString & title)
  1639. {
  1640.   PTitledWindow::SetTitle(title);
  1641. #if defined(_WIN32)
  1642.   SendMessage(((PMDIFrameWindow *)parent)->mdiClient,WM_MDIREFRESHMENU, 0, 0L);
  1643. #else  
  1644.   SendMessage(((PMDIFrameWindow *)parent)->mdiClient, WM_MDISETMENU, TRUE, 0L);
  1645. #endif
  1646. }
  1649. ///////////////////////////////////////////////////////////////////////////////
  1650. // PPopUp
  1652. PPopUp::PPopUp(PInteractor * parent)
  1653.   : PInteractor(parent)
  1654. {
  1655. }
  1658. void PPopUp::GetCreateWinInfo(WNDCLASS & wndClass)
  1659. {
  1660.   PInteractor::GetCreateWinInfo(wndClass);
  1661.   wndClass.style = CS_HREDRAW|CS_VREDRAW|CS_SAVEBITS;
  1662.   _styleBits = WS_POPUP|WS_BORDER|WS_DISABLED;
  1663.   _exStyleBits |= WS_EX_TOPMOST;
  1664. }
  1667. void PPopUp::WndProc()
  1668. {
  1669.   switch (_msg->event) {
  1670.     case WM_SETFOCUS :
  1671.     case WM_MOUSEMOVE :
  1672.       return;
  1673.   }
  1674.   PInteractor::WndProc();
  1675. }
  1678. // End Of File ///////////////////////////////////////////////////////////////