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

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

IP电话/视频会议

开发平台：

Visual C++

dialogs.cxx：源码内容
  1. /*
  2.  * dialogs.cxx
  3.  *
  4.  * Dialog 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: dialogs.cxx,v $
  30.  * Revision 1.66  2000/04/04 22:26:20  robertj
  31.  * Fixed bug in PDialog when close button closes regardless of OnCancel() virtual.
  32.  *
  33.  * Revision 1.65  2000/03/17 20:32:22  robertj
  34.  * Fixed race conditions in mult-threaded windows (dialogs in particular)
  35.  *
  36.  * Revision 1.64  2000/03/04 13:08:35  robertj
  37.  * Moved common function in open file dialog to common source file.
  38.  *
  39.  * Revision 1.63  2000/03/04 10:09:38  robertj
  40.  * Fixed bugs in open file dialog (showed up in Win2K).
  41.  *
  42.  * Revision 1.62  1999/11/16 06:51:42  robertj
  43.  * Created PCustomListBox to allow motif native code PStringListBox implementation
  44.  *
  45.  * Revision 1.61  1999/11/01 00:07:44  robertj
  46.  * Changed semantics of OnClose() to be the same as PTitledWindow
  47.  *
  48.  * Revision 1.60  1999/10/24 11:52:05  robertj
  49.  * Fixed problems with creating/deleting dialogs from background threads.
  50.  *
  51.  * Revision 1.59  1999/08/25 05:13:33  robertj
  52.  * Fixed problem with calling modal dialog from a background thread.
  53.  *
  54.  * Revision 1.58  1999/08/07 07:13:23  robertj
  55.  * Fixed problems with "balloon help" text popup.
  56.  *
  57.  * Revision 1.57  1999/02/16 08:08:07  robertj
  58.  * MSVC 6.0 compatibility changes.
  59.  *
  60.  * Revision 1.56  1998/12/12 00:43:51  robertj
  61.  * Added functions for user request on printing selection only.
  62.  * Fixed transfer of start and end pages from PPrintDialog.
  63.  *
  64.  * Revision 1.55  1998/12/02 03:50:12  robertj
  65.  * Unix compatibility changes
  66.  *
  67.  * Revision 1.54  1998/09/24 03:42:39  robertj
  68.  * Added open software license.
  69.  *
  70.  * Revision 1.53  1998/09/24 01:55:32  robertj
  71.  * Fixed bug that caused modal dialog not to go away when closed from another thread.
  72.  *
  73.  * Revision 1.52  1998/09/22 15:09:45  robertj
  74.  * Fixed confusion in Font Dialog, variable at different levels with same name.
  75.  * Fixed Font Dialog not returning font that was selected.
  76.  *
  77.  * Revision 1.51  1998/09/17 04:25:56  robertj
  78.  * Fixed race condition if dialog is closed by a different thread to the PProcess thrad.
  79.  *
  80.  * Revision 1.50  1998/09/14 13:14:20  robertj
  81.  * Fixed memory leak on delete of PStringList, not deleting all its contents.
  82.  * Fixed failure to update control values on non-modal dialog box initialisation.
  83.  *
  84.  * Revision 1.49  1998/09/04 07:01:06  robertj
  85.  * Added a lot of DEVMODE infor for win95 to propagate from PrintDlg to PPrintCanvas.
  86.  *
  87.  * Revision 1.48  1998/03/20 03:12:44  robertj
  88.  * Fixed bug in standard file dialog getting filename and folder.
  89.  *
  90.  * Revision 1.47  1998/03/09 07:14:31  robertj
  91.  * Explorer based OpenDirDialog.
  92.  * More implementation of file type lists.
  93.  *
  94.  * Revision 1.46  1998/03/09 01:46:45  robertj
  95.  * Enhanced file types for standard file dialog.
  96.  *
  97.  * Revision 1.44  1996/11/04 03:32:25  robertj
  98.  * Fixed bug in background colour of dialogs.
  99.  *
  100.  * Revision 1.43  1996/10/31 12:39:56  robertj
  101.  * Added RCS keywords.
  102.  *
  103.  */
  105. #include <pwlib.h>
  108. class PDummyListBox : public PListBox
  109. {
  110.   PCLASSINFO(PDummyListBox, PListBox)
  111.   public:
  112.     PDummyListBox(PInteractorLayout * layout, PRESOURCE_ID ctrlID)
  113.       : PListBox(layout, ctrlID, PNotifier(), NULL) { }
  115.     virtual void OnDrawEntry(PINDEX, PObject &, PCanvas &, const PRect &, BOOL, BOOL)
  116.       { }
  118.     virtual PDim OnMeasureEntry(PINDEX, PObject &, PCanvas &)
  119.       { return PDim(); }
  121.     virtual BOOL IsOwnerDraw() const
  122.       { return FALSE; }
  123. };
  125. #define new PNEW
  128. ///////////////////////////////////////////////////////////////////////////////
  129. // PInteractorLayout
  131. PInteractorLayout::PInteractorLayout(PInteractor * parent)
  132.   : PInteractor(parent)
  133. {
  134.   focusInteractor = this;
  135.   pResourceID = (PRESOURCE_ID)-1;
  136. }
  139. PInteractorLayout::PInteractorLayout(PInteractor * parent, PRESOURCE_ID resID)
  140.   : PInteractor(parent)
  141. {
  142.   focusInteractor = this;
  143.   pResourceID = resID;
  144. }
  147. PInteractorLayout::~PInteractorLayout()
  148. {
  149.   if (_hWnd != NULL && PThread::Current() != owner) {
  150.     if (_hWnd != P_DEAD_WINDOW)
  151.       PostMessage(_hWnd, WM_CLOSE, 0, 0);
  152.     handledDestroySignal.Wait();
  153.   }
  155.   owner->RemoveDialog(this);
  156. }
  159. BOOL PEXPORTED EnumDlgChildren(HWND hWnd, PInteractorLayout * layout)
  160. {
  161.   if (GetParent(hWnd) != layout->GetHWND())
  162.     return TRUE;
  164.   PRESOURCE_ID ctrlID = (PRESOURCE_ID)GetDlgCtrlID(hWnd);
  165.   if (ctrlID == 0xffff)
  166.     return TRUE;
  168.   if (layout->GetControl(ctrlID) != NULL)
  169.     return TRUE;
  171.   PControl * child = NULL;
  173.   char className[20];
  174.   GetClassName(hWnd, className, sizeof(className));
  175.   DWORD style = GetWindowLong(hWnd, GWL_STYLE);
  177.   if (lstrcmpi(className, "EDIT") == 0) {
  178.     if ((style&ES_MULTILINE) != 0)
  179.       child = new PMultiLineEditBox(layout, ctrlID, PNotifier(), NULL);
  180.     else {
  181.       char str[30];
  182.       GetWindowText(hWnd, str, sizeof(str));
  183.       SetWindowText(hWnd, "");
  184.       if (lstrcmpi(str, "INTEDIT") == 0)
  185.         child = new PIntegerEditBox(layout, ctrlID, PNotifier(), NULL);
  186.       else if (lstrcmpi(str, "REALEDIT") == 0)
  187.         child = new PFloatEditBox(layout, ctrlID, PNotifier(), NULL);
  188.       else
  189.         child = new PEditBox(layout, ctrlID, PNotifier(), NULL);
  190.     }
  191.   }
  192.   else if (lstrcmpi(className, "STATIC") == 0) {
  193.     switch (style&15) {
  194.       case SS_LEFT :
  195.       case SS_SIMPLE :
  196.       case SS_LEFTNOWORDWRAP :
  197.       case SS_CENTER :
  198.       case SS_RIGHT :
  199.         child = new PStaticText(layout, ctrlID, PNotifier(), NULL);
  200.         break;
  202.       case SS_ICON :
  203.         child = new PStaticIcon(layout, ctrlID, PNotifier(), NULL);
  204.         break;
  205.     }
  206.   }
  207.   else if (lstrcmpi(className, "BUTTON") == 0) {
  208.     switch (style&15) {
  209.       case BS_PUSHBUTTON :
  210.       case BS_DEFPUSHBUTTON :
  211.         child = new PTextButton(layout, ctrlID, PNotifier(), NULL);
  212.         break;
  214.       case BS_AUTOCHECKBOX :
  215.       case BS_CHECKBOX :
  216.         child = new PCheckBox(layout, ctrlID, PNotifier(), NULL);
  217.         break;
  219.       case BS_AUTO3STATE :
  220.       case BS_3STATE :
  221.         child = new PCheck3WayBox(layout, ctrlID, PNotifier(), NULL);
  222.         break;
  224.       case BS_AUTORADIOBUTTON :
  225.       case BS_RADIOBUTTON :
  226.         child = new PRadioButton(layout, ctrlID, PNotifier(), NULL);
  227.         break;
  229.       case BS_GROUPBOX :
  230.         child = new PStaticBox(layout, ctrlID, PNotifier(), NULL);
  231.         break;
  232.     }
  233.   }
  234.   else if (lstrcmpi(className, "LISTBOX") == 0) {
  235.     if ((style&LBS_OWNERDRAWVARIABLE) == 0)
  236.       child = new PDummyListBox(layout, ctrlID);
  237.     else
  238.       child = new PStringListBox(layout, ctrlID, PNotifier(), NULL);
  239.   }
  240.   else if (lstrcmpi(className, "COMBOBOX") == 0) {
  241.     switch (style&15) {
  242.       case CBS_DROPDOWN :
  243.         child = new PChoiceBox(layout, ctrlID, PNotifier(), NULL);
  244.         break;
  246.       case CBS_DROPDOWNLIST :
  247.         child = new PComboBox(layout, ctrlID, PNotifier(), NULL);
  248.         break;
  249.     }
  250.   }
  251.   else if (lstrcmpi(className, "SCROLLBAR") == 0) {
  252.     if ((style&1) != 0)
  253.       child = new PVerticalScrollBar(layout, ctrlID, PNotifier(), NULL);
  254.     else
  255.       child = new PHorizontalScrollBar(layout, ctrlID, PNotifier(), NULL);
  256.   }
  258.   return TRUE;
  259. }
  262. void PInteractorLayout::ConstructEnd(PRESOURCE_ID resID)
  263. {
  264.   EnumChildWindows(GetHWND(), (WNDENUMPROC)EnumDlgChildren, (LPARAM)this);
  266.   PResourceData dialog("#5", resID);
  267.   PResourceData strings("DIALOGSTRINGS", resID);
  268. #if defined(_WIN32)
  269.   PINDEX numControls = ((const DLGTEMPLATE *)(const BYTE *)dialog)->cdit;
  270.   const WORD * strptr = (const WORD *)(const BYTE *)strings;
  271.   const WORD * strbase;
  272. #else
  273.   PINDEX numControls = dialog[4];
  274.   const char * strptr = (const char *)(const BYTE *)strings;
  275.   const char * strbase;
  276. #endif
  278.   for (PINDEX i = 0; i < numControls; i++) {
  279.     PControl & child = (PControl &)children[i];
  280.     strbase = strptr;
  281.     PINDEX len = 0;
  282.     while (*strptr++ != 0)
  283.       len++;
  284.     if (len != 0)
  285.       child.SetBalloonHelp(PString(strbase, len));
  287.     while (*strptr != 0) {
  288.       strbase = strptr;
  289.       len = 0;
  290.       while (*strptr++ != 0)
  291.         len++;
  292.       if (child.IsDescendant(PChoiceBox::Class()))
  293.         ((PChoiceBox&)child).AddString(PString(strbase, len));
  294.       else if (child.IsDescendant(PStringListBox::Class()))
  295.         ((PStringListBox&)child).AddString(PString(strbase, len));
  296.       else if (child.IsDescendant(PComboBox::Class()))
  297.         ((PComboBox&)child).AddString(PString(strbase, len));
  298.     }
  299.     strptr++;
  300.   }
  302.   for (i = 1; i < GetNumChildren(); i++) {
  303.     if (children[i].IsDescendant(PRadioButton::Class()) &&
  304.                              children[i-1].IsDescendant(PRadioButton::Class()))
  305.       ((PRadioButton &)children[i]).AddToGroup((PRadioButton &)children[i-1]);
  306.   }
  308.   UpdateControls();
  309. }
  312. void PInteractorLayout::GetCreateWinInfo(WNDCLASS & wndClass)
  313. {
  314.   PInteractor::GetCreateWinInfo(wndClass);
  316.   wndClass.lpszClassName = "Dialog";
  317. }
  320. void PInteractorLayout::CreateHWND()
  321. {
  322.   if (pResourceID != -1) {
  323.     _hWnd = CreateDialog(owner->GetInstance(),
  324.                      MAKEINTRESOURCE(pResourceID),
  325.                      parent->GetHWND(),
  326.                      (DLGPROC)owner->GetWndProcPtr(PApplication::DlgProcType));
  327.     PAssert(_hWnd != NULL, PInvalidWindow);
  328.     PPoint pos = GetPosition(ScreenCoords);
  329.     if (pos.X() < 0 && pos.Y() < 0)
  330.       SetPosition(0,0,CentreParent,CentreParent);
  331.     HFONT hFont = (HFONT)(UINT)SendMessage(_hWnd, WM_GETFONT, 0, 0L);
  332.     if (hFont != NULL)
  333.       font = PRealFont(hFont);
  334.     else
  335.       SetFont(parent->GetFont(), TRUE);
  336.   }
  337.   else {
  338.     WNDCLASS dummyWndClass;
  339. #if defined(_WIN32)
  340.     struct {
  341.       DLGTEMPLATE header;
  342.       WORD  szMenuName[1], szClassName[1], szCaption[1];
  343.       WORD  wPointSize;
  344.       WORD  szFaceName[1];
  345.     } emptyDlg;
  346.     memset(&emptyDlg, 0, sizeof(emptyDlg));
  347.     GetCreateWinInfo(dummyWndClass);
  348.     emptyDlg.header.dwExtendedStyle = _exStyleBits;
  349. #else
  350.     struct {
  351.       struct {
  352.         DWORD style;
  353.         BYTE  bNumberOfItems;
  354.         WORD  x, y, cx, cy;
  355.       } header;
  356.       char  szMenuName[1], szClassName[1], szCaption[1];
  357.       WORD  wPointSize;
  358.       char  szFaceName[1];
  359.     } emptyDlg;
  360.     memset(&emptyDlg, 0, sizeof(emptyDlg));
  361.     GetCreateWinInfo(dummyWndClass);
  362. #endif
  363.     emptyDlg.header.style = _styleBits;
  364.     _hWnd = CreateDialogIndirect(owner->GetInstance(),
  365.                      &emptyDlg.header,
  366.                      parent->GetHWND(),
  367.                      (DLGPROC)owner->GetWndProcPtr(PApplication::DlgProcType));
  368.     PAssert(_hWnd != NULL, PInvalidWindow);
  369.   }
  371.   _styleBits = GetWindowLong(_hWnd, GWL_STYLE);
  372.   _exStyleBits = GetWindowLong(_hWnd, GWL_EXSTYLE);
  374.   owner->AddWindowHandle(_hWnd, this);
  375.   owner->AddDialog(this);
  376. }
  379. void PInteractorLayout::WndProc()
  380. {
  381.   PInteractor::WndProc();
  383.   switch (_msg->event) {
  384.     case WM_CLOSE :
  385.       DestroyWindow(_hWnd);
  386.       break;
  388.     case WM_DESTROY :
  389.       owner->RemoveDialog(this);
  390.       handledDestroySignal.Signal();
  391.       break;
  392.   }
  394.   handledMessageSignal.Signal();
  395. }
  398. void PInteractorLayout::DefWndProc()
  399. {
  400.   _msg->processed = FALSE;
  401. }
  404. ///////////////////////////////////////////////////////////////////////////////
  405. // PDialog
  407. PDialog::PDialog(PInteractor * parent)
  408.   : PInteractorLayout(parent)
  409. {
  410.   backgroundColour = owner->GetButtonBkColour();
  411. }
  414. PDialog::PDialog(PInteractor * parent, PRESOURCE_ID resID)
  415.   : PInteractorLayout(parent, resID)
  416. {
  417.   backgroundColour = owner->GetButtonBkColour();
  418. }
  421. void PDialog::WndProc()
  422. {
  423.   if (_msg->event == WM_CLOSE)
  424.     OnCancel();
  425.   else
  426.     PInteractor::WndProc();
  427. }
  430. void PDialog::GetCreateWinInfo(WNDCLASS & wndClass)
  431. {
  432.   PInteractorLayout::GetCreateWinInfo(wndClass);
  433.   _styleBits = WS_POPUP|WS_CLIPCHILDREN|WS_CAPTION|WS_SYSMENU|WS_BORDER;
  434. }
  437. ///////////////////////////////////////////////////////////////////////////////
  438. // PFloatingDialog
  440. void PFloatingDialog::Construct()
  441. {
  442.   titleFont = PRealFont(PFont("MS Sans Serif", 1));  // Smallest font possible
  443.   borderWidth = owner->GetBorderSize().Width();
  444.   borderHeight = owner->GetBorderSize().Height();
  445.   titleHeight = titleFont.GetHeight(TRUE) + borderHeight*2;
  446. }
  449. void PFloatingDialog::WndProc()
  450. {
  451.   switch (_msg->event) {
  452.     case WM_NCCALCSIZE :
  453.       NCCalcSize((LPNCCALCSIZE_PARAMS)_msg->lParam);
  454.       return;
  455.     
  456.     case WM_NCHITTEST :
  457.       _msg->lResult = NCHitTest(_msg->lParam);
  458.       return;
  460.     case WM_NCPAINT :
  461.       NCPaint();
  462.       return;
  463.   }
  464.   PDialog::WndProc();
  465. }
  468. void PFloatingDialog::NCCalcSize(LPNCCALCSIZE_PARAMS cs)
  469. {
  470.   PDim bdr = owner->GetBorderSize();
  471.   cs->rgrc[0].top += titleHeight + borderHeight;
  472.   cs->rgrc[0].left += borderWidth;
  473.   cs->rgrc[0].bottom -= borderHeight;
  474.   cs->rgrc[0].right -= borderWidth;
  475. }
  478. LRESULT PFloatingDialog::NCHitTest(const PPoint & pt)
  479. {
  480.   PRect rect;
  481.   GetWindowRect(_hWnd, rect);
  482.   rect.Inflate(-(PORDINATE)borderWidth, -(PORDINATE)borderHeight);
  484.   if (!rect.ContainsPoint(pt))
  485.     return HTBORDER;
  487.   if (pt.Y() > rect.Y() + (PORDINATE)titleHeight)
  488.     return HTCLIENT;
  490.   if (pt.X() < rect.X() + (PORDINATE)titleHeight)
  491.     return HTSYSMENU;
  493.   return HTCAPTION;
  494. }
  497. void PFloatingDialog::NCPaint()
  498. {
  499.   PDrawCanvas canvas(this, GetWindowDC(_hWnd), TRUE, TRUE);
  501.   PRect rect;
  502.   GetWindowRect(_hWnd, rect);
  503.   rect.SetOrigin(0, 0);
  505.   PColour bdrcol;
  506.   bdrcol.FromSYSCOLOR(COLOR_WINDOWFRAME);
  507.   canvas.SetPenFgColour(bdrcol);
  508.   canvas.SetFillFgColour(PColour::Clear);
  509.   canvas.DrawRect(rect);
  511.   rect.SetHeight(titleHeight+borderHeight);
  513.   canvas.SetFillFgColour(owner->GetActiveTitleBkColour());
  514.   canvas.FillRect(rect);
  516.   PString title = GetTitle();
  517.   canvas.SetTextFgColour(owner->GetActiveTitleFgColour());
  518.   canvas.SetTextBkColour(owner->GetActiveTitleBkColour());
  519.   canvas.SetFont(titleFont);
  520.   canvas.DrawTextLine(rect.X() + titleHeight,
  521.                       rect.Y() + borderHeight, title, NULL, title.GetLength());
  523.   rect.SetWidth(titleHeight);
  524.   rect.Inflate(-(int)borderWidth*2, -(int)borderHeight*2);
  525.   canvas.SetFillFgColour(owner->GetButtonBkColour());
  526.   canvas.DrawBevelledRect(rect, TRUE, FALSE);
  527. }
  530. void PFloatingDialog::GetCreateWinInfo(WNDCLASS & wndClass)
  531. {
  532.   PDialog::GetCreateWinInfo(wndClass);
  533.   _styleBits = WS_POPUP|WS_CLIPCHILDREN|WS_BORDER|WS_SYSMENU;
  534.   _exStyleBits |= WS_EX_TOPMOST;
  535. }
  538. ///////////////////////////////////////////////////////////////////////////////
  539. // PModalDialog
  541. PModalDialog::~PModalDialog()
  542. {
  543. }
  546. void PModalDialog::Construct()
  547. {
  548.   ok = cancel = NULL;
  549.   runState = Initialising;
  550. }
  553. int PModalDialog::RunModal()
  554. {
  555.   runState = Running;
  557.   owner->GetWindow()->Disable();
  559.   OnInit();
  560.   Show();
  562.   if (PThread::Current() == owner) {
  563.     while (runState == Running && owner->ProcessMessage())
  564.       ;
  565.   }
  566.   else {
  567.     while (runState == Running)
  568.       handledMessageSignal.Wait();
  569.   }
  571.   return returnValue;
  572. }
  575. void PModalDialog::EndModal(int retVal)
  576. {
  577.   owner->GetWindow()->Enable();
  578.   Hide();
  579.   returnValue = retVal;
  580.   runState = Ended;
  581.   PostMessage(_hWnd, WM_COMMAND, 0, 0);
  582. }
  585. void PModalDialog::GetCreateWinInfo(WNDCLASS & wndClass)
  586. {
  587.   PDialog::GetCreateWinInfo(wndClass);
  588.   _styleBits |= DS_MODALFRAME;
  589.   _exStyleBits |= WS_EX_DLGMODALFRAME;
  590. }
  593. void PModalDialog::InitStandardDialog()
  594. {
  595. //  EnumChildWindows(_hWnd, (WNDENUMPROC)EnumDlgChildren, (LPARAM)this);
  597.   font = PRealFont((HFONT)(UINT)SendMessage(_hWnd, WM_GETFONT, 0, 0L));
  599.   HDC hDC = GetDC(_hWnd);
  600.   HBRUSH hBrush = (HBRUSH)(UINT)SendMessage(_hWnd,
  601. #ifdef _WIN32
  602.                       WM_CTLCOLORDLG, (WPARAM)hDC, (LPARAM)_hWnd);
  603. #else
  604.                       WM_CTLCOLOR, (WPARAM)hDC, MAKELONG(_hWnd, CTLCOLOR_DLG));
  605. #endif
  606.   ReleaseDC(_hWnd, hDC);
  608.   if (hBrush == NULL)
  609.     hBrush = (HBRUSH)PGET_CLASS_VALUE(_hWnd, HBRBACKGROUND);
  611.   if (hBrush != NULL) {
  612.     LOGBRUSH brush;
  613.     GetObject(hBrush, sizeof(brush), (LPSTR)&brush);
  614.     backgroundColour.FromCOLORREF(brush.lbColor);
  615.   }
  617.   runState = Running;
  618.   _styleBits = GetWindowLong(_hWnd, GWL_STYLE) | WS_CLIPSIBLINGS;
  619.   SetWindowLong(_hWnd, GWL_STYLE, _styleBits);
  620.   _exStyleBits = GetWindowLong(_hWnd, GWL_EXSTYLE);
  621.   OnInit();
  622. }
  625. ///////////////////////////////////////////////////////////////////////////////
  626. // PFileDialog
  628. #if !defined(_WIN32)
  629. typedef UINT (CALLBACK * LPOFNHOOKPROC)(HWND, UINT, WPARAM, LPARAM);
  630. #endif
  632. PFileDialog::PFileDialog(PInteractor * parent, PRESOURCE_ID resID)
  633.   : PModalDialog(parent, resID)
  634. {
  635.   selChangeMessage = RegisterWindowMessage(LBSELCHSTRING);
  637.   memset(&fileDlgInfo, 0, sizeof(fileDlgInfo));
  638.   fileDlgInfo.lStructSize = sizeof(fileDlgInfo);
  639.   fileDlgInfo.hwndOwner = parent->GetHWND();
  640.   fileDlgInfo.hInstance = owner->GetInstance();
  641.   fileBuffer[0] = '';
  642.   fileDlgInfo.lpstrFile = fileBuffer;
  643.   strcpy(customFilter, "All Files");
  644.   memcpy(&customFilter[strlen(customFilter)+1], "*.*", 5);
  645.   fileDlgInfo.lpstrCustomFilter = customFilter;
  646.   fileDlgInfo.nMaxCustFilter = sizeof(customFilter);
  647.   fileDlgInfo.nMaxFile = sizeof(fileBuffer);
  648. #ifdef OFN_EXPLORER
  649.   fileDlgInfo.Flags = OFN_ENABLEHOOK|OFN_HIDEREADONLY|OFN_NOVALIDATE|OFN_EXPLORER;
  650. #else
  651.   fileDlgInfo.Flags = OFN_ENABLEHOOK|OFN_HIDEREADONLY|OFN_NOVALIDATE;
  652. #endif
  653.   fileDlgInfo.lCustData = (DWORD)this;
  654.   fileDlgInfo.lpfnHook =
  655.             (LPOFNHOOKPROC)owner->GetWndProcPtr(PApplication::FileDlgProcType);
  656. }
  659. PFileDialog::~PFileDialog()
  660. {
  661.   if (_hWnd != P_DEAD_WINDOW)
  662.     DestroyWindow(_hWnd);
  663. }
  666. void PFileDialog::SetTitle(const PString & title)
  667. {
  668.   if (_hWnd != NULL)
  669.     PModalDialog::SetTitle(title);
  670.   else {
  671.     dlgTitle = title;
  672.     fileDlgInfo.lpstrTitle = dlgTitle;
  673.   }
  674. }
  677. void PFileDialog::WndProc()
  678. {
  679.   switch (_msg->event) {
  680.     case WM_INITDIALOG :
  681.       InitStandardDialog();
  682.       return;
  684. #ifndef OFN_EXPLORER
  685.     case WM_COMMAND :
  686.       switch (LOWORD(_msg->wParam)) {
  687.         case IDOK : {
  688.           directory = PDirectory();
  689.           GetDlgItemText(_hWnd, 1152, fileBuffer, sizeof(fileBuffer));
  690.           file = PFilePath(fileBuffer);
  691.           OnOk();
  692.           return;
  693.         }
  695.         case IDCANCEL :
  696.           OnCancel();
  697.           return;
  698.       }
  699.       break;
  700. #endif
  702.     case WM_NOTIFY:
  703.       {
  704.         OFNOTIFY * ofNotify = (OFNOTIFY *)_msg->lParam;
  705.         HWND hDlg = ::GetParent(_hWnd);
  706.         switch (ofNotify->hdr.code) {
  707.           case CDN_FILEOK :
  708.             SendMessage(hDlg, CDM_GETFOLDERPATH, sizeof(fileBuffer), (LPARAM)fileBuffer);
  709.             directory = fileBuffer;
  710.             SendMessage(hDlg, CDM_GETFILEPATH,   sizeof(fileBuffer), (LPARAM)fileBuffer);
  711.             file = PFilePath(fileBuffer);
  712.             OnOk();
  713.             return;
  714.         }
  715.       }
  716.       break;
  718.     default:
  719.       if (_msg->event == selChangeMessage)
  720.         OnListSelection(_msg->wParam, LOWORD(_msg->lParam), HIWORD(_msg->lParam));
  721.   }
  722.   PModalDialog::WndProc();
  723. }
  726. void PFileDialog::OnOk()
  727. {
  728.   DefWndProc();
  729. }
  732. void PFileDialog::OnCancel()
  733. {
  734.   DefWndProc();
  735. }
  738. void PFileDialog::OnListSelection(UINT, UINT, UINT)
  739. {
  740. }
  743. void PFileDialog::CreateHWND()
  744. {
  745.   PAssertAlways("Illegal operation on PFileDialog");
  746. }
  749. ///////////////////////////////////////////////////////////////////////////////
  750. // POpenFileDialog
  752. POpenFileDialog::POpenFileDialog(PInteractor * parent, PRESOURCE_ID resID)
  753.   : PFileDialog(parent, resID)
  754. {
  755.   fileDlgInfo.Flags |= OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_OVERWRITEPROMPT;
  756.   if (resID != PSTD_ID_DIALOG_OPEN_FILE) {
  757.     fileDlgInfo.Flags |= OFN_ENABLETEMPLATE;
  758.     fileDlgInfo.lpTemplateName = MAKEINTRESOURCE(resID);
  759.   }
  760. }
  763. int POpenFileDialog::RunModal()
  764. {
  765.   fileDlgInfo.lpstrInitialDir = directory;
  766.   lstrcpy(fileBuffer, defaultFilename);
  767.   PString fileTypeStr;
  768.   if (fileTypes.GetSize() != 0) {
  769.     for (PINDEX i = 0; i < fileTypes.GetSize(); i++) {
  770.       PString s = fileTypes[i];
  771.       if (s.Find('377') != P_MAX_INDEX)
  772.         fileTypeStr += s + "377";
  773.       else {
  774.         PString tmp("*");
  775.         tmp += s + "377";
  776.         fileTypeStr += tmp + tmp;
  777.       }
  778.     }
  779.     fileTypeStr += "377";
  780.     fileDlgInfo.lpstrFilter = fileTypeStr;
  781.     for (LPSTR p = (LPSTR)fileDlgInfo.lpstrFilter; *p != ''; p++) {
  782.       while (*p == '377')
  783.         *p++ = '';
  784.     }
  785.     fileDlgInfo.nFilterIndex = 1;
  786.   }
  788.   if (GetOpenFileName(&fileDlgInfo)) {
  789.     runState = Ended;
  790.     return TRUE;
  791.   }
  793.   DWORD err = CommDlgExtendedError();
  794. #if defined(_WIN32)
  795.   SetLastError(err);
  796. #endif
  797.   PAssertOS(err == 0);
  798.   return FALSE;
  799. }
  802. void POpenFileDialog::SetFileTypes(const PStringArray & array)
  803. {
  804.   fileTypes = array;
  805.   SetInitialFileType(GetFinalFileType());
  806. }
  809. void POpenFileDialog::SetInitialFileType(PINDEX i)
  810. {
  811.   if (i != P_MAX_INDEX)
  812.     fileDlgInfo.nFilterIndex = i+1;
  813.   else
  814.     fileDlgInfo.nFilterIndex = 0;
  815. }
  818. void POpenFileDialog::SetInitialFileType(const PString & str)
  819. {
  820.   memset(customFilter, 0, sizeof(customFilter));
  821.   strncpy(customFilter, str, sizeof(customFilter)-1);
  822.   fileDlgInfo.nFilterIndex = 0;
  823. }
  826. PINDEX POpenFileDialog::GetFinalFileType() const
  827. {
  828.   if (fileDlgInfo.nFilterIndex > 0)
  829.     return fileDlgInfo.nFilterIndex-1;
  831.   return P_MAX_INDEX;
  832. }
  835. BOOL POpenFileDialog::GetFinalFileType(PString & str) const
  836. {
  837.   if ((PINDEX)fileDlgInfo.nFilterIndex > fileTypes.GetSize())
  838.     return FALSE;
  840.   if (fileDlgInfo.nFilterIndex > 0)
  841.     str = fileTypes[fileDlgInfo.nFilterIndex-1];
  842.   else
  843.     str = &customFilter[strlen(customFilter)+1];
  845.   return !str;
  846. }
  849. void POpenFileDialog::FilterFilesFromList()
  850. {
  851.   PINDEX i = 0;
  852.   while (i < (PINDEX)SendDlgItemMessage(_hWnd, 1120, LB_GETCOUNT, 0, 0)) {
  853.     char str[P_MAX_PATH];
  854.     SendDlgItemMessage(_hWnd, 1120, LB_GETTEXT, i, (DWORD)str);
  855.     if (OnFilterFile(str))
  856.       i++;
  857.     else
  858.       SendDlgItemMessage(_hWnd, 1120, LB_DELETESTRING, i, 0);
  859.   }
  860. }
  863. void POpenFileDialog::OnListSelection(UINT listBox, UINT item, UINT operation)
  864. {
  865.   if (listBox == 1120 && operation == CD_LBSELCHANGE) {
  866.     char str[P_MAX_PATH];
  867.     SendDlgItemMessage(_hWnd, 1120, LB_GETTEXT, item, (DWORD)str);
  868.     OnFileSelect(str);
  869.   }
  870.   else if (listBox == 1121 && !fileTypes.IsEmpty())
  871.     FilterFilesFromList();
  872. }
  875. void POpenFileDialog::WndProc()
  876. {
  877.   PFileDialog::WndProc();
  879.   switch (_msg->event) {
  880.     case WM_INITDIALOG :
  881.       FilterFilesFromList();
  882.       break;
  884.     case WM_COMMAND :
  885.       if (LOWORD(_msg->wParam) == IDOK)
  886.         FilterFilesFromList();
  887.       break;
  888.   }
  889. }
  892. ///////////////////////////////////////////////////////////////////////////////
  893. // PSaveFileDialog
  895. PSaveFileDialog::PSaveFileDialog(PInteractor * parent, PRESOURCE_ID resID)
  896.   : PFileDialog(parent, resID)
  897. {
  898.   fileDlgInfo.Flags |= OFN_CREATEPROMPT;
  899.   if (resID != PSTD_ID_DIALOG_SAVE_FILE) {
  900.     fileDlgInfo.Flags |= OFN_ENABLETEMPLATE;
  901.     fileDlgInfo.lpTemplateName = MAKEINTRESOURCE(resID);
  902.   }
  903. }
  906. int PSaveFileDialog::RunModal()
  907. {
  908.   fileDlgInfo.lpstrInitialDir = directory;
  909.   lstrcpy(fileBuffer, defaultFilename);
  910.   if (GetSaveFileName(&fileDlgInfo)) {
  911.     runState = Ended;
  912.     return TRUE;
  913.   }
  915.   DWORD err = CommDlgExtendedError();
  916. #if defined(_WIN32)
  917.   SetLastError(err);
  918. #endif
  919.   PAssertOS(err == 0);
  920.   return FALSE;
  921. }
  924. ///////////////////////////////////////////////////////////////////////////////
  925. // POpenDirDialog
  927. POpenDirDialog::POpenDirDialog(PInteractor * parent, PRESOURCE_ID resID)
  928.   : PFileDialog(parent, resID)
  929. {
  930. #ifdef OFN_EXPLORER
  931.   fileDlgInfo.lpstrFilter = "~~a.ridiculous.extensionA ridiculous extension";
  932.   lstrcpy(fileBuffer, "~~a.ridiculous.filename~~");
  933.   if (resID != PSTD_ID_DIALOG_OPEN_DIR) {
  934.     fileDlgInfo.Flags |= OFN_ENABLETEMPLATE;
  935.     fileDlgInfo.lpTemplateName = MAKEINTRESOURCE(resID);
  936.   }
  937. #else
  938.   fileDlgInfo.Flags |= OFN_ENABLETEMPLATE;
  939.   fileDlgInfo.lpTemplateName = MAKEINTRESOURCE(resID);
  940. #endif
  941. }
  944. int POpenDirDialog::RunModal()
  945. {
  946.   fileDlgInfo.lpstrInitialDir = directory;
  947.   if (GetOpenFileName(&fileDlgInfo)) {
  948.     runState = Ended;
  949.     return TRUE;
  950.   }
  952.   DWORD err = CommDlgExtendedError();
  953. #if defined(_WIN32)
  954.   SetLastError(err);
  955. #endif
  956.   PAssertOS(err == 0);
  957.   return FALSE;
  958. }
  961. void POpenDirDialog::WndProc()
  962. {
  963.   switch (_msg->event) {
  964.     case WM_INITDIALOG :
  965. #ifdef OFN_EXPLORER
  966.       {
  967.         HWND dlgWnd = ::GetParent(_hWnd);
  968.         ShowWindow(GetDlgItem(dlgWnd, 0x441), SW_HIDE);
  969.         ShowWindow(GetDlgItem(dlgWnd, 0x470), SW_HIDE);
  970.         ShowWindow(GetDlgItem(dlgWnd, 0x442), SW_HIDE);
  971.         ShowWindow(GetDlgItem(dlgWnd, 0x480), SW_HIDE);
  972.       }
  973. #else
  974.       SetDlgItemText(_hWnd, 1159, PDirectory());
  975. #endif
  976.       break;
  978. #ifndef OFN_EXPLORER
  979.     case WM_COMMAND :
  980.       if (LOWORD(_msg->wParam) == IDOK) {
  981.         GetDlgItemText(dlgWnd, 1159, fileBuffer, sizeof(fileBuffer));
  982.         directory = PDirectory(fileBuffer);
  983.         SetDlgItemText(dlgWnd, 1152, "xxxxxxxx.xxx");
  984.       }
  985. #endif
  986.   }
  988.   PFileDialog::WndProc();
  989. }
  992. void POpenDirDialog::OnListSelection(UINT, UINT, UINT)
  993. {
  994. #ifndef OFN_EXPLORER
  995.   char str[P_MAX_PATH];
  996.   GetDlgItemText(_hWnd, 1088, str, sizeof(str));
  997.   SetDlgItemText(_hWnd, 1159, str);
  998. #endif
  999. }
  1002. ///////////////////////////////////////////////////////////////////////////////
  1003. // PPrintDialog
  1005. #if !defined(_WIN32)
  1006. typedef UINT (CALLBACK * LPPRINTHOOKPROC)(HWND, UINT, WPARAM, LPARAM);
  1007. #endif
  1009. void PPrintDialog::Construct()
  1010. {
  1011.   memset(&printDlgInfo, 0, sizeof(printDlgInfo));
  1012.   printDlgInfo.hInstance = owner->GetInstance();
  1013.   printDlgInfo.lStructSize = sizeof(printDlgInfo);
  1014.   printDlgInfo.hwndOwner = GetParent()->GetHWND();
  1015.   printDlgInfo.lpfnPrintHook =
  1016.          (LPPRINTHOOKPROC)owner->GetWndProcPtr(PApplication::PrintDlgProcType);
  1017.   printDlgInfo.lCustData = (DWORD)this;
  1018.   printDlgInfo.Flags = PD_ENABLEPRINTHOOK;
  1019.   printDlgInfo.hDevMode = printInfo.GetHDEVMODE();
  1020.   printDlgInfo.hDevNames = printInfo.GetDevNames();
  1022.   if (printInfo.GetStartPage() == 0)
  1023.     printDlgInfo.Flags |= PD_NOPAGENUMS;
  1024.   else {
  1025.     printDlgInfo.nFromPage = (WORD)printInfo.GetStartPage();
  1026.     printDlgInfo.nToPage = (WORD)printInfo.GetEndPage();
  1027.   }
  1029.   switch (printInfo.GetSelectionOnly()) {
  1030.     case PPrintInfo::NoSelectionOnly :
  1031.       printDlgInfo.Flags |= PD_NOSELECTION;
  1032.       break;
  1033.     case PPrintInfo::SelectionOnlyOn :
  1034.       printDlgInfo.Flags |= PD_SELECTION;
  1035.       break;
  1036.     default :
  1037.       break;
  1038.   }
  1040.   printDlgInfo.nCopies = (WORD)printInfo.GetCopies();
  1041. }
  1044. PPrintDialog::~PPrintDialog()
  1045. {
  1046.   if (_hWnd != P_DEAD_WINDOW)
  1047.     DestroyWindow(_hWnd);
  1048.   if (printDlgInfo.hDevMode != NULL)
  1049.     GlobalFree(printDlgInfo.hDevMode);
  1050.   if (printDlgInfo.hDevNames != NULL)
  1051.     GlobalFree(printDlgInfo.hDevNames);
  1052.   if (printDlgInfo.hDC != NULL)
  1053.     DeleteDC(printDlgInfo.hDC);
  1054. }
  1057. void PPrintDialog::SetTitle(const PString & title)
  1058. {
  1059.   if (_hWnd != NULL)
  1060.     PModalDialog::SetTitle(title);
  1061.   else
  1062.     dlgTitle = title;
  1063. }
  1066. int PPrintDialog::RunModal()
  1067. {
  1068.   if (PrintDlg(&printDlgInfo)) {
  1069.     runState = Ended;
  1070.     return TRUE;
  1071.   }
  1073.   DWORD err = CommDlgExtendedError();
  1074. #if defined(_WIN32)
  1075.   SetLastError(err);
  1076. #endif
  1077.   PAssertOS(err == 0);
  1078.   return FALSE;
  1079. }
  1082. void PPrintDialog::WndProc()
  1083. {
  1084.   switch (_msg->event) {
  1085.     case WM_INITDIALOG :
  1086.       if (!dlgTitle.IsEmpty())
  1087.         SetWindowText(_hWnd, dlgTitle);
  1088.       InitStandardDialog();
  1089.       return;
  1091.     case WM_COMMAND :
  1092.       switch (LOWORD(_msg->wParam)) {
  1093.         case IDOK : {
  1094.           OnOk();
  1095.           return;
  1096.         }
  1098.         case IDCANCEL :
  1099.           OnCancel();
  1100.           return;
  1101.       }
  1102.   }
  1103.   PModalDialog::WndProc();
  1104. }
  1107. void PPrintDialog::OnOk()
  1108. {
  1109.   printInfo.SetFromPrintDlg(printDlgInfo);
  1110.   DefWndProc();
  1111. }
  1114. void PPrintDialog::OnCancel()
  1115. {
  1116.   DefWndProc();
  1117. }
  1120. void PPrintDialog::CreateHWND()
  1121. {
  1122.   PAssertAlways("Illegal operation on Print Dialog");
  1123. }
  1126. ///////////////////////////////////////////////////////////////////////////////
  1127. // PPrinterSetupDialog
  1129. void PPrinterSetupDialog::Construct()
  1130. {
  1131.   printDlgInfo.Flags |= PD_PRINTSETUP;
  1132.   if (pResourceID != PSTD_ID_DIALOG_PRINTER_SETUP) {
  1133.     printDlgInfo.Flags |= PD_ENABLEPRINTTEMPLATE;
  1134.     printDlgInfo.lpSetupTemplateName = MAKEINTRESOURCE(pResourceID);
  1135.   }
  1136. }
  1139. ///////////////////////////////////////////////////////////////////////////////
  1140. // PPrintJobDialog
  1142. void PPrintJobDialog::Construct()
  1143. {
  1144.   if (pResourceID != PSTD_ID_DIALOG_PRINT_JOB) {
  1145.     printDlgInfo.Flags |= PD_ENABLEPRINTTEMPLATE;
  1146.     printDlgInfo.lpPrintTemplateName = MAKEINTRESOURCE(pResourceID);
  1147.   }
  1148. }
  1151. ///////////////////////////////////////////////////////////////////////////////
  1152. // PFontDialog
  1154. #if !defined(_WIN32)
  1155. typedef UINT (CALLBACK * LPCFHOOKPROC)(HWND, UINT, WPARAM, LPARAM);
  1156. #endif
  1158. void PFontDialog::Construct(PRESOURCE_ID)
  1159. {
  1160.   memset(&fontDlgInfo, 0, sizeof(fontDlgInfo));
  1161.   fontDlgInfo.lStructSize = sizeof(fontDlgInfo);
  1162.   fontDlgInfo.hInstance = owner->GetInstance();
  1163.   fontDlgInfo.hwndOwner = GetParent()->GetHWND();
  1164.   fontDlgInfo.lpLogFont = &logFont;
  1165.   fontDlgInfo.lpfnHook =
  1166.              (LPCFHOOKPROC)owner->GetWndProcPtr(PApplication::FontDlgProcType);
  1167.   fontDlgInfo.lCustData = (DWORD)this;
  1168.   fontDlgInfo.Flags = CF_ANSIONLY|CF_EFFECTS|CF_INITTOLOGFONTSTRUCT|CF_ENABLEHOOK;
  1169.   if (printerCanvas == NULL)
  1170.     fontDlgInfo.Flags |= CF_SCREENFONTS;
  1171.   else {
  1172.     fontDlgInfo.Flags |= CF_PRINTERFONTS;
  1173.     fontDlgInfo.hDC = printerCanvas->GetHDC();
  1174.   }
  1175.   if (pResourceID != PSTD_ID_DIALOG_FONT) {
  1176.     fontDlgInfo.Flags |= CF_ENABLETEMPLATE;
  1177.     fontDlgInfo.lpTemplateName = MAKEINTRESOURCE(pResourceID);
  1178.   }
  1180.   SetDefaultFont(selectedFont);
  1181. }
  1184. PFontDialog::~PFontDialog()
  1185. {
  1186.   if (_hWnd != P_DEAD_WINDOW)
  1187.     DestroyWindow(_hWnd);
  1188. }
  1191. void PFontDialog::SetTitle(const PString & title)
  1192. {
  1193.   if (_hWnd != NULL)
  1194.     PModalDialog::SetTitle(title);
  1195.   else
  1196.     dlgTitle = title;
  1197. }
  1200. void PFontDialog::SetDefaultFont(const PFont & font)
  1201. {
  1202.   if (runState != Initialising)
  1203.     return;
  1205.   selectedFont = font;
  1206.   memset(&logFont, 0, sizeof(logFont));
  1208.   if (printerCanvas != NULL)
  1209.     logFont.lfHeight = printerCanvas->FromPointsY(font.GetSize());
  1210.   else {
  1211.     PDrawCanvas canvas(parent, TRUE);
  1212.     logFont.lfHeight = canvas.FromPointsY(font.GetSize());
  1213.   }
  1214.   logFont.lfWeight = font.IsBold() ? FW_BOLD : FW_NORMAL;
  1215.   logFont.lfItalic = (BYTE)font.IsItalic();
  1216.   logFont.lfUnderline = (BYTE)font.IsUnderlined();
  1217.   strncpy(logFont.lfFaceName, font.GetFacename(), LF_FACESIZE-1);
  1218. }
  1221. int PFontDialog::RunModal()
  1222. {
  1223.   if (ChooseFont(&fontDlgInfo)) {
  1224.     runState = Ended;
  1225.     return TRUE;
  1226.   }
  1228.   DWORD err = CommDlgExtendedError();
  1229. #if defined(_WIN32)
  1230.   SetLastError(err);
  1231. #endif
  1232.   PAssertOS(err == 0);
  1233.   return FALSE;
  1234. }
  1237. void PFontDialog::WndProc()
  1238. {
  1239.   switch (_msg->event) {
  1240.     case WM_INITDIALOG :
  1241.       if (!dlgTitle.IsEmpty())
  1242.         SetWindowText(_hWnd, dlgTitle);
  1243.       InitStandardDialog();
  1244.       return;
  1246.     case WM_COMMAND :
  1247.       switch (LOWORD(_msg->wParam)) {
  1248.         case IDOK : {
  1249.           SendMessage(_hWnd, WM_CHOOSEFONT_GETLOGFONT, 0, (DWORD)&logFont);
  1250.           PDIMENSION size = PABS(logFont.lfHeight);
  1251.           if (printerCanvas != NULL)
  1252.             size = printerCanvas->ToPointsY(size);
  1253.           else {
  1254.             PDrawCanvas canvas(parent, TRUE);
  1255.             size = canvas.ToPointsY(size);
  1256.           }
  1257.           WORD styles = PFont::Regular;
  1258.           if (logFont.lfWeight > FW_NORMAL)
  1259.             styles |= PFont::Bold;
  1260.           if (logFont.lfItalic)
  1261.             styles |= PFont::Italic;
  1262.           if (logFont.lfUnderline)
  1263.             styles |= PFont::Underline;
  1264.           selectedFont = PFont(logFont.lfFaceName, size, styles);
  1265.           OnOk();
  1266.           return;
  1267.         }
  1269.         case IDCANCEL :
  1270.           OnCancel();
  1271.           return;
  1272.       }
  1273.   }
  1274.   PModalDialog::WndProc();
  1275. }
  1278. void PFontDialog::OnOk()
  1279. {
  1280.   DefWndProc();
  1281. }
  1284. void PFontDialog::OnCancel()
  1285. {
  1286.   DefWndProc();
  1287. }
  1290. void PFontDialog::CreateHWND()
  1291. {
  1292.   PAssertAlways("Illegal operation on Print Dialog");
  1293. }
  1296. ///////////////////////////////////////////////////////////////////////////////
  1297. // PColourDialog
  1299. #if !defined(_WIN32)
  1300. typedef UINT (CALLBACK * LPCCHOOKPROC)(HWND, UINT, WPARAM, LPARAM);
  1301. #endif
  1303. void PColourDialog::Construct(PRESOURCE_ID)
  1304. {
  1305.   PConfig cfg("CONTROL.INI", "Custom Colors");
  1306.   for (PINDEX i = 0; i < NumCustomColours; i++)
  1307.     customColours[i] = cfg.GetString(psprintf("Color%c", i+'A')).AsInteger(16);
  1308.   memset(&colourDlgInfo, 0, sizeof(colourDlgInfo));
  1309.   colourDlgInfo.lStructSize = sizeof(colourDlgInfo);
  1310.   colourDlgInfo.hInstance = (HWND)owner->GetInstance();
  1311.   colourDlgInfo.hwndOwner = GetParent()->GetHWND();
  1312.   colourDlgInfo.lpfnHook =
  1313.            (LPCCHOOKPROC)owner->GetWndProcPtr(PApplication::ColourDlgProcType);
  1314.   colourDlgInfo.rgbResult = colour.ToCOLORREF();
  1315.   colourDlgInfo.lpCustColors = customColours;
  1316.   colourDlgInfo.lCustData = (DWORD)this;
  1317.   colourDlgInfo.Flags = CC_RGBINIT|CC_ENABLEHOOK;
  1318.   if (pResourceID != PSTD_ID_DIALOG_COLOUR) {
  1319.     colourDlgInfo.Flags |= CC_ENABLETEMPLATE;
  1320.     colourDlgInfo.lpTemplateName = MAKEINTRESOURCE(pResourceID);
  1321.   }
  1322. }
  1325. PColourDialog::~PColourDialog()
  1326. {
  1327.   if (_hWnd != P_DEAD_WINDOW)
  1328.     DestroyWindow(_hWnd);
  1329. }
  1332. void PColourDialog::SetTitle(const PString & title)
  1333. {
  1334.   if (_hWnd != NULL)
  1335.     PModalDialog::SetTitle(title);
  1336.   else
  1337.     dlgTitle = title;
  1338. }
  1341. void PColourDialog::SetColour(const PColour & col)
  1342. {
  1343.   if (runState == Initialising)
  1344.     colour = col;
  1345. }
  1348. int PColourDialog::RunModal()
  1349. {
  1350.   if (ChooseColor(&colourDlgInfo)) {
  1351.     runState = Ended;
  1352.     colour.FromCOLORREF(colourDlgInfo.rgbResult);
  1353.     return TRUE;
  1354.   }
  1356.   DWORD err = CommDlgExtendedError();
  1357. #if defined(_WIN32)
  1358.   SetLastError(err);
  1359. #endif
  1360.   PAssertOS(err == 0);
  1361.   return FALSE;
  1362. }
  1365. void PColourDialog::WndProc()
  1366. {
  1367.   switch (_msg->event) {
  1368.     case WM_INITDIALOG :
  1369.       if (!dlgTitle.IsEmpty())
  1370.         SetWindowText(_hWnd, dlgTitle);
  1371.       InitStandardDialog();
  1372.       return;
  1374.     case WM_COMMAND :
  1375.       switch (LOWORD(_msg->wParam)) {
  1376.         case IDOK : {
  1377.           OnOk();
  1378.           return;
  1379.         }
  1381.         case IDCANCEL :
  1382.           OnCancel();
  1383.           return;
  1384.       }
  1385.   }
  1386.   PModalDialog::WndProc();
  1387. }
  1390. void PColourDialog::OnOk()
  1391. {
  1392.   DefWndProc();
  1393. }
  1396. void PColourDialog::OnCancel()
  1397. {
  1398.   DefWndProc();
  1399. }
  1402. void PColourDialog::CreateHWND()
  1403. {
  1404.   PAssertAlways("Illegal operation on Print Dialog");
  1405. }
  1408. ///////////////////////////////////////////////////////////////////////////////
  1409. // PApplication
  1411. BOOL PApplication::DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  1412. {
  1413.   if (msg == WM_INITDIALOG)
  1414.     ShowWindow(hWnd, SW_HIDE);
  1416.   PInteractor * window = (PInteractor *)createdWindows.GetAt((HWNDKey)hWnd);
  1417.   if (window == NULL)
  1418.     return FALSE;
  1420.   PInteractor::_WindowsMessage message;
  1421.   message.event = msg;
  1422.   message.wParam = wParam;
  1423.   message.lParam = lParam;
  1424.   message.lResult = 0;
  1425.   message.processed = TRUE;
  1426.   PInteractor::_WindowsMessage * oldMessage = window->_msg;
  1427.   window->_msg = &message;
  1428.   window->WndProc();
  1429.   window->_msg = oldMessage;
  1430.   if (message.processed) {
  1431.     switch (msg) {
  1432. #ifdef WIN32
  1433.       case WM_CTLCOLORBTN :
  1434.       case WM_CTLCOLORDLG :
  1435.       case WM_CTLCOLOREDIT :
  1436.       case WM_CTLCOLORLISTBOX :
  1437.       case WM_CTLCOLORMSGBOX :
  1438.       case WM_CTLCOLORSCROLLBAR :
  1439.       case WM_CTLCOLORSTATIC :
  1440. #else
  1441.       case WM_CTLCOLOR :
  1442. #endif
  1443.       case WM_COMPAREITEM :
  1444.       case WM_VKEYTOITEM :
  1445.       case WM_CHARTOITEM :
  1446.       case WM_QUERYDRAGICON :
  1447.         return (UINT)message.lResult;
  1448.     }
  1449.     SetWindowLong(hWnd, DWL_MSGRESULT, message.lResult);
  1450.   }
  1451.   return message.processed;
  1452. }
  1455. BOOL PApplication::FileDlgProc(HWND hWnd,
  1456.                                         UINT msg, WPARAM wParam, LPARAM lParam)
  1457. {
  1458.   if (msg == WM_INITDIALOG) {
  1459.     PInteractor * window = (PInteractor *)((LPOPENFILENAME)lParam)->lCustData;
  1460.     PAssert(window != NULL, PLogicError);
  1461.     AddWindowHandle(hWnd, window);
  1462.     window->_hWnd = hWnd;
  1463.   }
  1464.   return DlgProc(hWnd, msg, wParam, lParam);
  1465. }
  1468. BOOL PApplication::PrintDlgProc(HWND hWnd,
  1469.                                         UINT msg, WPARAM wParam, LPARAM lParam)
  1470. {
  1471.   if (msg == WM_INITDIALOG) {
  1472.     PInteractor * window = (PInteractor *)((LPPRINTDLG)lParam)->lCustData;
  1473.     PAssert(window != NULL, PLogicError);
  1474.     AddWindowHandle(hWnd, window);
  1475.     window->_hWnd = hWnd;
  1476.   }
  1477.   return DlgProc(hWnd, msg, wParam, lParam);
  1478. }
  1481. BOOL PApplication::FontDlgProc(HWND hWnd,
  1482.                                         UINT msg, WPARAM wParam, LPARAM lParam)
  1483. {
  1484.   if (msg == WM_INITDIALOG) {
  1485.     PInteractor * window = (PInteractor *)((LPCHOOSEFONT)lParam)->lCustData;
  1486.     PAssert(window != NULL, PLogicError);
  1487.     AddWindowHandle(hWnd, window);
  1488.     window->_hWnd = hWnd;
  1489.   }
  1490.   return DlgProc(hWnd, msg, wParam, lParam);
  1491. }
  1494. BOOL PApplication::ColourDlgProc(HWND hWnd,
  1495.                                         UINT msg, WPARAM wParam, LPARAM lParam)
  1496. {
  1497.   if (msg == WM_INITDIALOG) {
  1498.     PInteractor * window = (PInteractor *)((LPCHOOSECOLOR)lParam)->lCustData;
  1499.     PAssert(window != NULL, PLogicError);
  1500.     AddWindowHandle(hWnd, window);
  1501.     window->_hWnd = hWnd;
  1502.   }
  1503.   return DlgProc(hWnd, msg, wParam, lParam);
  1504. }
  1508. // End Of File ///////////////////////////////////////////////////////////////