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

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

IP电话/视频会议

开发平台：

Visual C++

pwlib.cxx：源码内容
  1. /*
  2.  * pwlib.cxx
  3.  *
  4.  * GUI classes.
  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: pwlib.cxx,v $
  30.  * Revision 1.82  2000/04/28 06:59:14  robertj
  31.  * Fixed race condition causing asserts in ballon help.
  32.  *
  33.  * Revision 1.81  2000/03/04 13:08:35  robertj
  34.  * Moved common function in open file dialog to common source file.
  35.  *
  36.  * Revision 1.80  1999/11/01 00:07:58  robertj
  37.  * Changed semantics of OnClose() to be the same as PTitledWindow
  38.  *
  39.  * Revision 1.79  1999/08/07 07:13:23  robertj
  40.  * Fixed problems with "balloon help" text popup.
  41.  *
  42.  * Revision 1.78  1999/03/29 03:39:55  robertj
  43.  * Changed semantics of PTitledWindow::OnClose() function.
  44.  *
  45.  * Revision 1.77  1999/03/09 10:30:19  robertj
  46.  * Fixed ability to have PMEMORY_CHECK on/off on both debug/release versions.
  47.  *
  48.  * Revision 1.76  1998/12/02 03:50:11  robertj
  49.  * Unix compatibility changes
  50.  *
  51.  * Revision 1.75  1998/12/01 13:01:10  robertj
  52.  * new directory structure.
  53.  * Unix version
  54.  *
  55.  * Revision 1.74  1998/12/01 11:41:49  craigs
  56.  * Remove warnings under GCC
  57.  *
  58.  * Revision 1.73  1998/10/15 11:32:52  robertj
  59.  * New memory leak detection system.
  60.  *
  61.  * Revision 1.72  1998/10/13 14:06:37  robertj
  62.  * Complete rewrite of memory leak detection code.
  63.  *
  64.  * Revision 1.71  1998/09/23 06:29:54  robertj
  65.  * Added open source copyright license.
  66.  *
  67.  * Revision 1.70  1998/09/22 15:06:54  robertj
  68.  * Fixed confusion in Font Dialog, variable at different levels with same name.
  69.  *
  70.  * Revision 1.69  1998/09/14 12:43:27  robertj
  71.  * Fixed standard "about" dialog
  72.  *
  73.  * Revision 1.68  1997/04/27 05:50:22  robertj
  74.  * DLL support.
  75.  *
  76.  * Revision 1.67  1996/06/28 13:23:21  robertj
  77.  * Temporary disable of balloon help under NT until thread problem fixed.
  78.  *
  79.  * Revision 1.66  1996/06/03 09:59:30  robertj
  80.  * Fixed coordinate system for caret position.
  81.  *
  82.  * Revision 1.65  1996/04/30 12:33:56  robertj
  83.  * Changed "inPixels" boolean to enum for three coordinate systems.
  84.  *
  85.  * Revision 1.64  1996/01/28 02:52:06  robertj
  86.  * Added assert into all Compare functions to assure comparison between compatible objects.
  87.  *
  88.  * Revision 1.63  1995/12/23 03:42:30  robertj
  89.  * Changed version numbers.
  90.  *
  91.  * Revision 1.62  1995/12/10 11:41:44  robertj
  92.  * Changed default default OnAbout() function to have user specified dialog.
  93.  *
  94.  * Revision 1.61  1995/11/20 11:04:52  robertj
  95.  * Fixed bug in scrolling twice on scroll bar click.
  96.  *
  97.  * Revision 1.60  1995/10/14 15:10:14  robertj
  98.  * Added function to update all control values from data pointers.
  99.  *
  100.  * Revision 1.58  1995/08/24 12:37:04  robertj
  101.  * Added standard colours for balloon help windows.
  102.  * Added UpdateCommandSources() to menu start selection.
  103.  *
  104.  * Revision 1.57  1995/08/12 22:34:48  robertj
  105.  * Changed balloon help font to something more portable.
  106.  * Added resID parameter passing to colour dialog Construct() function.
  107.  *
  108.  * Revision 1.56  1995/07/31 12:09:53  robertj
  109.  * Drag track documentation and semantic adjustment.
  110.  * Split off pop up window from balloon.
  111.  *
  112.  * Revision 1.55  1995/07/02 01:22:09  robertj
  113.  * Added drag tracking support.
  114.  * Moved function to .cxx file when fixed bug.
  115.  *
  116.  * Revision 1.54  1995/06/04 12:42:25  robertj
  117.  * Redesign of caret driver functions (made a lot more common).
  118.  * Fixed order of initialisers for GNU.
  119.  *
  120.  * Revision 1.53  1995/04/25 11:11:40  robertj
  121.  * Moved functions to .cxx file to avoid triadic compiler problems.
  122.  * Fixed incorrect parameter on colour component virtual functions.
  123.  *
  124.  * Revision 1.52  1995/04/22 00:51:41  robertj
  125.  * Fixed bug in balloon help for balloon help in a balloon help interactor.
  126.  *
  127.  * Revision 1.51  1995/04/03 11:27:43  robertj
  128.  * Fixed balloon help window so doesn't flash main window.
  129.  *
  130.  * Revision 1.50  1995/04/02 09:27:32  robertj
  131.  * Added "balloon" help.
  132.  *
  133.  * Revision 1.49  1995/02/22 10:54:05  robertj
  134.  * Stopped memory leak by removing stupid mod.
  135.  * ./
  136.  *
  137.  * Revision 1.48  1995/02/22  10:50:38  robertj
  138.  * Changes required for compiling release (optimised) version.
  139.  *
  140.  * Revision 1.47  1995/02/19  04:14:38  robertj
  141.  * Changed font constructor to be more general PString.
  142.  * Added dynamically linked command processing.
  143.  * Added AllowClose() function for PTitledWindow descendents.
  144.  *
  145.  * Revision 1.46  1995/02/05  00:52:17  robertj
  146.  * Fixed default About box, using resource string and memory stats dump.
  147.  *
  148.  * Revision 1.45  1995/01/27  11:15:45  robertj
  149.  * Added description string.
  150.  * Changed face name strings to be caseless.
  151.  *
  152.  * Revision 1.44  1995/01/22  07:29:16  robertj
  153.  * Added font description string.
  154.  * Added font & colour standard dialogs.
  155.  *
  156.  * Revision 1.43  1995/01/21  05:16:27  robertj
  157.  * Modified ShowAll so PScrollable does not change show state of scroll bars..
  158.  *
  159.  * Revision 1.42  1995/01/18  09:03:18  robertj
  160.  * Fixed bug for having multiple top level windows and all closing application.
  161.  *
  162.  * Revision 1.41  1995/01/15  04:57:51  robertj
  163.  * Fixed global cursor set function.
  164.  * Added memory stats to default About box.
  165.  *
  166.  * Revision 1.40  1995/01/07  04:39:47  robertj
  167.  * Redesigned font enumeration code and changed font styles.
  168.  *
  169.  * Revision 1.39  1995/01/06  10:44:01  robertj
  170.  * Changed PRealFont usage from pointer to reference.
  171.  *
  172.  * Revision 1.38  1995/01/02  12:25:48  robertj
  173.  * Added global cursor setting for wait cursor.
  174.  *
  175.  * Revision 1.37  1994/12/21  11:54:21  robertj
  176.  * Documentation and variable normalisation.
  177.  * Fixed bad behaviour in closing PTopLevelWindow
  178.  *
  179.  * Revision 1.36  1994/12/17  01:22:35  robertj
  180.  * Changed semantics of file filering in standard file dialogs.
  181.  *
  182.  * Revision 1.35  1994/12/14  11:17:19  robertj
  183.  * Changed PDIMENSION to be unsigned causing untold number of changes.
  184.  *
  185.  * Revision 1.34  1994/11/19  00:04:38  robertj
  186.  * Removed variable argument list binding for menus and controls.
  187.  * Added clear standard colour.
  188.  *
  189.  * Revision 1.33  1994/11/01  11:56:18  robertj
  190.  * Rearranged stdarg stuff to get over compiler wierdness.
  191.  *
  192.  * Revision 1.32  1994/10/30  11:47:14  robertj
  193.  * Changed mechanism for doing notification callback functions.
  194.  *
  195.  * Revision 1.31  1994/10/24  00:05:46  robertj
  196.  * Fixed bug in dialogs not setting value of first control.
  197.  *
  198.  * Revision 1.30  1994/10/23  03:47:49  robertj
  199.  * Changed colours to have 8 bit components.
  200.  * Completed PScrollable implementation.
  201.  *
  202.  * Revision 1.29  1994/09/25  10:52:58  robertj
  203.  * Removed PNULL_MENU_NOTIFY
  204.  *
  205.  * Revision 1.28  1994/08/21  23:43:02  robertj
  206.  * Added delayed close of interactors to avoid the "delete this" problem.
  207.  *
  208.  * Revision 1.27  1994/08/01  03:41:24  robertj
  209.  * Use of PNEW instead of new for heap debugging. Need undef for Unix end.
  210.  *
  211.  * Revision 1.26  1994/07/27  05:58:07  robertj
  212.  * Synchronisation.
  213.  *
  214.  * Revision 1.25  1994/07/17  10:46:06  robertj
  215.  * Adjusted menu handling so can have orphan sub menus.
  216.  *
  217.  * Revision 1.24  1994/07/02  03:03:49  robertj
  218.  * Time interval and timer redesign.
  219.  *
  220.  * Revision 1.23  1994/06/25  11:55:15  robertj
  221.  * Unix version synchronisation.
  222.  *
  223.  * Revision 1.22  1994/04/20  12:17:44  robertj
  224.  * assert changes
  225.  *
  226.  * Revision 1.21  1994/04/03  08:34:18  robertj
  227.  * Added help and focus functionality.
  228.  *
  229.  * Revision 1.20  1994/04/01  14:04:23  robertj
  230.  * Added OnInit function to all modal dialogs.
  231.  *
  232.  * Revision 1.19  1994/03/07  07:47:00  robertj
  233.  * Major upgrade
  234.  *
  235.  * Revision 1.18  1994/01/03  04:42:23  robertj
  236.  * Mass changes to common container classes and interactors etc etc etc.
  237.  *
  238.  * Revision 1.17  1993/12/31  06:54:17  robertj
  239.  * Made inlines optional for debugging purposes.
  240.  * Added PImgIcon class.
  241.  *
  242.  * Revision 1.16  1993/12/29  04:41:26  robertj
  243.  * Mac port.
  244.  *
  245.  * Revision 1.15  1993/12/24  04:34:31  robertj
  246.  * G++ warning elimination.
  247.  *
  248.  * Revision 1.14  1993/12/24  04:20:52  robertj
  249.  * Mac CFront port.
  250.  *
  251.  * Revision 1.13  1993/12/16  09:22:11  robertj
  252.  * Fixed problems with callback function.
  253.  *
  254.  * Revision 1.12  1993/12/16  06:20:57  robertj
  255.  * Changes to callback function definition due to GCC.
  256.  *
  257.  * Revision 1.11  1993/12/15  21:10:10  robertj
  258.  * Use new function for container class reference count.
  259.  *
  260.  * Revision 1.10  1993/12/04  05:21:26  robertj
  261.  * Moved code from pwlib.inl to reduce its size.
  262.  *
  263.  * Revision 1.9  1993/12/01  16:09:05  robertj
  264.  * Windows NT port.
  265.  *
  266.  * Revision 1.8  1993/11/20  17:26:28  robertj
  267.  * PCanvasState class creation and integration.
  268.  * PPoint and PRect ancestror class becoming private.
  269.  * Shape classes implementation.
  270.  *
  271.  * Revision 1.7  1993/08/27  18:17:47  robertj
  272.  * Added canvas function for drawing bevelled 3D areas.
  273.  * Added timer support.
  274.  * Added group checking of menu items.
  275.  * Fixed some CFront compatibility problems.
  276.  *
  277.  * Revision 1.6  1993/08/24  00:27:59  robertj
  278.  * Rearrangement of pushbutton classes.
  279.  * Added Grey standard colour.
  280.  * Added inPixels parameter to the validate.invalidate functions.
  281.  *
  282.  * Revision 1.5  1993/08/21  17:09:50  robertj
  283.  * Added function to allow setting of menus whenever it is selected.
  284.  *
  285.  * Revision 1.4  1993/08/21  01:50:33  robertj
  286.  * Made Clone() function optional, default will assert if called.
  287.  *
  288.  * Revision 1.3  1993/08/21  01:07:35  robertj
  289.  * Fission of file into bars.cxx & control.cxx
  290.  *
  291.  * Revision 1.2  1993/08/20  21:26:09  robertj
  292.  * Number edit box common code added.
  293.  *
  294.  * Revision 1.7  1993/08/10  12:58:38  robertj
  295.  * Fixed bug in DrawString(), right adjusted text.
  296.  * Very small optimisation of PStringListBox DrawItem() function.
  297.  *
  298.  * Revision 1.6  1993/07/15  04:29:39  robertj
  299.  * Adjustments to the 3D shadowing effect on buttons/status bar etc.
  300.  *
  301.  * Revision 1.5  1993/07/14  12:41:52  robertj
  302.  * Fixed comment leader.
  303.  *
  304.  * Revision 1.4  1993/07/14  02:08:18  robertj
  305.  * Fixed header comment for RCS logs.
  306.  */
  308. #ifdef __GNUC__
  309. #pragma implementation "commands.h"
  310. #pragma implementation "scrollab.h"
  311. #pragma implementation "balloon.h"
  312. #endif
  314. #include <pwlib.h>
  316. class PAboutDialog : public PModalDialog
  317. {
  318.   PCLASSINFO(PAboutDialog, PModalDialog)
  319.   public:
  320.     PAboutDialog(PInteractor * parent, PRESOURCE_ID id)
  321.       : PModalDialog(parent, id)
  322.     {
  323.       ConstructEnd(id);
  324.       for (PINDEX i = 0; i < GetNumChildren(); i++) {
  325.         if (children[i].IsDescendant(PPushButton::Class())) {
  326.           SetStdButtons((PPushButton *)&children[i]);
  327.           break;
  328.         }
  329.       }
  330.     }
  331. };
  334. #define new PNEW
  337. //////////////////////////////////////////////////////////////////////////////
  338. // PKeyCode
  340. #if defined(_PKEYCODE)
  342. PObject * PKeyCode::Clone() const
  343. {
  344.   return new PKeyCode(value, modifiers);
  345. }
  348. PObject::Comparison PKeyCode::Compare(const PObject & obj) const
  349. {
  350.   PAssert(obj.IsDescendant(PKeyCode::Class()), PInvalidCast);
  351.   const PKeyCode & other = (const PKeyCode &)obj;
  352.   if (value == other.value && modifiers == other.modifiers)
  353.     return EqualTo;
  354.   return value < other.value ? LessThan : GreaterThan;
  355. }
  358. #endif
  361. //////////////////////////////////////////////////////////////////////////////
  362. // PColour
  364. #if defined(_PCOLOUR)
  366. PColour::PColour(BYTE r, BYTE g, BYTE b, BYTE a)
  367. {
  368.   component[RedComponent] = r;
  369.   component[GreenComponent] = g;
  370.   component[BlueComponent] = b;
  371.   component[AlphaComponent] = a;
  372. }
  375. PColour::PColour(StandardColours col)
  376. {
  377.   static BYTE stdCol[NumStandardColours][NumComponents] = {
  378.     { 0,    0,    0,    0xff }, // Black
  379.     { 0xff, 0,    0,    0xff }, // Red
  380.     { 0,    0xff, 0,    0xff }, // Green
  381.     { 0xff, 0xff, 0,    0xff }, // Yellow
  382.     { 0,    0,    0xff, 0xff }, // Blue
  383.     { 0xff, 0,    0xff, 0xff }, // Magenta
  384.     { 0,    0xff, 0xff, 0xff }, // Cyan
  385.     { 0xff, 0xff, 0xff, 0xff }, // White
  386.     { 0x40, 0x40, 0x40, 0xff }, // Grey
  387.     { 0x80, 0x80, 0x80, 0xff }, // Grey
  388.     { 0xC0, 0xC0, 0xC0, 0xff }, // Grey
  389.     { 0,    0,    0,    0    }  // Clear
  390.   };
  392.   PAssert(col < NumStandardColours, PInvalidParameter);
  393.   for (PINDEX i = 0; i < NumComponents; i++)
  394.     component[i] = stdCol[col][i];
  395. }
  397. PObject * PColour::Clone() const
  398. {
  399.   return new PColour(component[RedComponent],  component[GreenComponent],
  400.                      component[BlueComponent], component[AlphaComponent]);
  401. }
  404. PObject::Comparison PColour::Compare(const PObject & obj) const
  405. {
  406.   PAssert(obj.IsDescendant(PColour::Class()), PInvalidCast);
  407.   const PColour & other = (const PColour &)obj;
  408.   
  409.   for (PINDEX i = 0; i < NumComponents; i++)
  410.     if (component[i] != other.component[i])
  411.       return GreaterThan;
  412.   
  413.   return EqualTo;
  414. }
  417. PINDEX PColour::HashFunction() const
  418. {
  419.   
  420.   return (PINDEX)((component[RedComponent]^0x55) +
  421.                   (component[GreenComponent]^0xaa) +
  422.                   (component[BlueComponent]^0xc3))%51;
  423. }
  426. void PColour::SetRed(BYTE r)
  427. {
  428.   component[RedComponent] = r;
  429. }
  432. void PColour::SetGreen(BYTE g)
  433. {
  434.   component[GreenComponent] = g;
  435. }
  438. void PColour::SetBlue(BYTE b)
  439. {
  440.   component[BlueComponent] = b;
  441. }
  444. void PColour::SetAlpha(BYTE a)
  445. {
  446.   component[AlphaComponent] = a;
  447. }
  450. long PColour::GetDistance(const PColour & other) const
  451. {
  452.   long sum = 0;
  453.   for (PINDEX i = 0; i < AlphaComponent; i++)
  454.     sum += component[i]*other.component[i];
  455.   return sum;
  456. }
  459. #endif
  462. //////////////////////////////////////////////////////////////////////////////
  463. // PRealColour
  465. #if defined(_PREALCOLOUR)
  467. void PRealColour::SetRed(BYTE)
  468. {
  469.   PAssertAlways(PUnimplementedFunction);
  470. }
  473. void PRealColour::SetGreen(BYTE)
  474. {
  475.   PAssertAlways(PUnimplementedFunction);
  476. }
  479. void PRealColour::SetBlue(BYTE)
  480. {
  481.   PAssertAlways(PUnimplementedFunction);
  482. }
  485. void PRealColour::SetAlpha(BYTE)
  486. {
  487.   PAssertAlways(PUnimplementedFunction);
  488. }
  491. #endif
  494. //////////////////////////////////////////////////////////////////////////////
  495. // PFont
  497. #if defined(_PFONT)
  499. PFont::PFont(const PString & theFacename, PDIMENSION theSize, WORD theStyle)
  500.   : facename(theFacename)
  501. {
  502.   size = theSize;
  503.   styles = theStyle;
  504. }
  507. void PFont::Construct(const PCaselessString & fontDescription)
  508. {
  509.   size = 12;
  510.   styles = Regular;
  512.   PStringArray field = fontDescription.Tokenise(",");
  514.   switch (field.GetSize()) {
  515.     case 3 :
  516.       if (field[2].FindOneOf("Bb") != P_MAX_INDEX)
  517.         styles |= Bold;
  518.       if (field[2].FindOneOf("Ii") != P_MAX_INDEX)
  519.         styles |= Italic;
  520.       if (field[2].FindOneOf("Uu") != P_MAX_INDEX)
  521.         styles |= Underline;
  522.       // Then do next case
  524.     case 2 :
  525.       size = (PDIMENSION)field[1].AsInteger();
  526.       // Then do next case
  528.     case 1 :
  529.       facename = field[0];
  530.   }
  531. }
  534. PObject * PFont::Clone() const
  535. {
  536.   return new PFont(facename, size, styles);
  537. }
  540. PObject::Comparison PFont::Compare(const PObject & obj) const
  541. {
  542.   PAssert(obj.IsDescendant(PFont::Class()), PInvalidCast);
  543.   const PFont & other = (const PFont &)obj;
  544.   return size == other.size &&
  545.          styles == other.styles &&
  546.          facename == other.facename
  547.                ? EqualTo : GreaterThan;
  548. }
  551. PCaselessString PFont::GetDescription() const
  552. {
  553.   PString desc = facename + ',' + PString(PString::Unsigned, size);
  554.   if (styles != Regular)
  555.     desc += ',';
  556.   if (IsBold())
  557.     desc += 'B';
  558.   if (IsItalic())
  559.     desc += 'I';
  560.   if (IsUnderlined())
  561.     desc += 'U';
  562.   return desc;
  563. }
  566. #endif
  569. //////////////////////////////////////////////////////////////////////////////
  570. // PFontFamily
  572. #if defined(_PFONTFAMILY)
  574. PObject::Comparison PFontFamily::Compare(const PObject & obj) const
  575. {
  576.   PAssert(obj.IsDescendant(PFontFamily::Class()), PInvalidCast);
  577.   return facename.Compare(((const PFontFamily &)obj).facename);
  578. }
  581. #endif
  584. //////////////////////////////////////////////////////////////////////////////
  585. // PCaret
  587. #if defined(_PCARET)
  589. PObject::Comparison PCaret::Compare(const PObject & obj) const
  590. {
  591.   PAssert(obj.IsDescendant(PCaret::Class()), PInvalidCast);
  592.   return caretSize.Compare(((const PCaret &)obj).caretSize);
  593. }
  596. #endif
  599. //////////////////////////////////////////////////////////////////////////////
  600. // PInteractor
  602. #if defined (_PINTERACTOR)
  604. PRect PInteractor::GetDrawingBounds(CoordinateSystem coords) const
  605. {
  606.   return GetDimensions(coords);
  607. }
  610. BOOL PInteractor::IsChild(PInteractor * parent) const
  611. {
  612.   for (PINDEX i = 0; i < parent->GetNumChildren(); i++) {
  613.     if (&parent[i] == this)
  614.       return TRUE;
  615.   }
  616.   return FALSE;
  617. }
  620. void PInteractor::UpdateCommandSources()
  621. {
  622.   PInteractor * top = this;
  623.   while (top->GetParent() != NULL)
  624.     top = top->GetParent();
  625.   top->UpdateMyCommandSources();
  626. }
  629. void PInteractor::UpdateMyCommandSources()
  630. {
  631.   for (PINDEX i = 0; i < GetNumChildren(); i++)
  632.     children[i].UpdateMyCommandSources();
  633. }
  636. void PInteractor::SetAllCursors(const PCursor & newCursor)
  637. {
  638.   savedCursor = cursor;
  639.   SetCursor(newCursor);
  641.   switch (cursorMode) {
  642.     case UseCurrentCursor :
  643.       cursorMode = UseSetAllCursor;
  644.       break;
  646.     case UseParentCursor :
  647.       cursorMode = UseSetAllParentCursor;
  648.       break;
  650.     default :
  651.       return;
  652.   }
  654.   for (PINDEX i = 0; i < GetNumChildren(); i++)
  655.     children[i].SetAllCursors(newCursor);
  656. }
  659. void PInteractor::RestoreAllCursors()
  660. {
  661.   for (PINDEX i = 0; i < GetNumChildren(); i++)
  662.     children[i].RestoreAllCursors();
  664.   cursorMode = UseCurrentCursor;
  665.   SetCursor(savedCursor);
  667.   switch (cursorMode) {
  668.     case UseSetAllCursor :
  669.       cursorMode = UseCurrentCursor;
  670.       break;
  672.     case UseSetAllParentCursor :
  673.       cursorMode = UseParentCursor;
  674.       break;
  676.     default :
  677.       break;
  678.   }
  679. }
  682. void PInteractor::_SetCaretPos(PORDINATE x, PORDINATE y,
  683.                                CoordinateSystem coords)
  684. {
  685.   switch (coords) {
  686.     case LocalCoords :
  687.       caretPosition = PPoint(FromPixelsDX(x), FromPixelsDY(y));
  688.       break;
  689.     case PixelCoords :
  690.       caretPosition = PPoint(x, y);
  691.       break;
  692.     case ScreenCoords :
  693.       caretPosition = FromScreen(x, y, PixelCoords);
  694.   }
  695.   caret.SetPosition(this);
  696. }
  699. PPoint PInteractor::GetCaretPos(CoordinateSystem coords) const
  700. {
  701.   switch (coords) {
  702.     case LocalCoords :
  703.       return FromPixels(caretPosition);
  704.     case ScreenCoords :
  705.       return ToScreen(caretPosition, PixelCoords);
  706.     case PixelCoords:
  707.     default:
  708.       break;
  709.   }
  710.   return caretPosition;
  711. }
  714. void PInteractor::ShowCaret(BOOL show)
  715. {
  716.   caretVisible += show ? -1 : 1;
  717.   if (show && caretVisible == 0)
  718.     caret.Show(this);
  719.   else if (!show && caretVisible == 1)
  720.     caret.Hide(this);
  721. }
  724. void PInteractor::SetFocusInteractor(PInteractor * interactor)
  725. {
  726.   if (parent != NULL)
  727.     parent->SetFocusInteractor(interactor);
  728. }
  731. PInteractor * PInteractor::GetFocusInteractor() const
  732. {
  733.   return (parent != NULL) ? parent->GetFocusInteractor() : (PInteractor *)NULL;
  734. }
  737. PCanvas * PInteractor::StartMouseTrack(PInteractor * child, BOOL wantCanvas)
  738. {
  739.   PAssert(mouseTrackInteractor == NULL, "Starting new mouse track while tracking.");
  740.   mouseTrackInteractor = child;
  741.   if (wantCanvas) {
  742.     mouseTrackCanvas = new PDrawCanvas(this, TRUE, TRUE);
  743.     mouseTrackCanvas->SetPenMode(PCanvas::InvertDst);
  744.     mouseTrackCanvas->SetFillMode(PCanvas::InvertDst);
  745.   }
  746.   if (child != this)
  747.     GrabMouse();
  748.   return mouseTrackCanvas;
  749. }
  752. void PInteractor::OnMouseTrack(PCanvas *, const PPoint &, BOOL)
  753. {
  754. }
  757. void PInteractor::_OnMouseMove(PKeyCode button, const PPoint & where)
  758. {
  759.   if (mouseTrackInteractor == NULL)
  760.     OnMouseMove(button, where);
  761.   else {
  762.     if (HasMouse())
  763.       mouseTrackInteractor->OnMouseTrack(mouseTrackCanvas, where, FALSE);
  764.     else
  765.       _OnMouseUp(button, where);
  766.   }
  767.   owner->DoBalloonHelp(this);
  768. }
  771. void PInteractor::_OnMouseUp(PKeyCode button, const PPoint & where)
  772. {
  773.   if (mouseTrackInteractor == NULL)
  774.     OnMouseUp(button, where);
  775.   else {
  776.     mouseTrackInteractor->OnMouseTrack(mouseTrackCanvas, where, TRUE);
  777.     delete mouseTrackCanvas;
  778.     if (this != mouseTrackInteractor)
  779.       ReleaseMouse();
  780.     mouseTrackInteractor = NULL;
  781.     mouseTrackCanvas = NULL;
  782.   }
  783. }
  786. void PInteractor::OnStartInput()
  787. {
  788. }
  791. BOOL PInteractor::OnEndInput()
  792. {
  793.   return TRUE;
  794. }
  797. void PInteractor::OnControlNotify(PControl & control, int option)
  798. {
  799. #if defined (_PCONTROL)
  800.   control.TransferValue(option);
  801.   PNotifier callback = control.GetNotifier();
  802.   if (!callback.IsNULL())
  803.     callback(control, option);
  804. #endif
  805. }
  808. void PInteractor::OnSelectHelp()
  809. {
  810.   if (parent != NULL)
  811.     parent->OnSelectHelp();
  812. }
  815. PBalloon * PInteractor::OnBalloonHelp()
  816. {
  817.   return (parent != NULL) ? parent->OnBalloonHelp() : (PBalloon *)NULL;
  818. }
  821. void PInteractor::ShowAll()
  822. {
  823.   for (PINDEX i = 0; i < GetNumChildren(); i++)
  824.     children[i].ShowAll();
  825.   Show();
  826. }
  829. void PInteractor::AutoAdjustBounds(PRect & bounds, AutoAdjustType type)
  830. {
  831.   PDim dim = GetDimensions(PixelCoords);
  832.   PDIMENSION vsWidth = owner->GetVScrollWidth();
  833.   PDIMENSION hsHeight = owner->GetHScrollHeight();
  834.   PRect structure = GetStructureBounds(PixelCoords);
  835.   PDim extra = structure.Dimensions() - dim;
  836.   switch (type) {
  837.     case AdjustBounds :
  838.       SetPosition(bounds.Left(), bounds.Top(), TopLeftPixels, TopLeftPixels);
  839.       SetDimensions(bounds.Width()-extra.Width(),
  840.                                  bounds.Height()-extra.Height(), PixelCoords);
  841.       break;
  843.     case AdjustTop :
  844.       SetPosition(bounds.Left(), bounds.Top(), TopLeftPixels, TopLeftPixels);
  845.       SetDimensions(bounds.Width()-extra.Width(), dim.Height(), PixelCoords);
  846.       bounds.SetTop(bounds.Top() + dim.Height() + extra.Height());
  847.       break;
  849.     case AdjustBottom :
  850.       SetDimensions(bounds.Width()-extra.Width(), dim.Height(), PixelCoords);
  851.       bounds.SetBottom(bounds.Bottom() - dim.Height() - extra.Height());
  852.       SetPosition(bounds.Left(), bounds.Bottom(), TopLeftPixels,TopLeftPixels);
  853.       break;
  855.     case AdjustLeft :
  856.       SetPosition(bounds.Left(), bounds.Top(), TopLeftPixels, TopLeftPixels);
  857.       SetDimensions(dim.Width(), bounds.Height()-extra.Height(), PixelCoords);
  858.       bounds.SetLeft(bounds.Left() + dim.Width() + extra.Width());
  859.       break;
  861.     case AdjustRight :
  862.       SetDimensions(dim.Width(), bounds.Height()-extra.Height(), PixelCoords);
  863.       bounds.SetRight(bounds.Right() - dim.Width() - extra.Width());
  864.       SetPosition(bounds.Right(), bounds.Top(), TopLeftPixels, TopLeftPixels);
  865.       break;
  867.     case AdjustVScrollOnly :
  868.       SetDimensions(vsWidth, bounds.Height(), PixelCoords);
  869.       bounds.SetRight(bounds.Right() - vsWidth);
  870.       SetPosition(bounds.Right(), bounds.Top(), TopLeftPixels, TopLeftPixels);
  871.       break;
  873.     case AdjustHScrollOnly :
  874.       SetDimensions(bounds.Width(), hsHeight, PixelCoords);
  875.       bounds.SetBottom(bounds.Bottom() - hsHeight);
  876.       SetPosition(bounds.Left(), bounds.Bottom(), TopLeftPixels,TopLeftPixels);
  877.       break;
  879.     case AdjustVScrollBeforeHScroll :
  880.       SetDimensions(vsWidth, bounds.Height() - hsHeight, PixelCoords);
  881.       bounds.SetRight(bounds.Right() - vsWidth);
  882.       SetPosition(bounds.Right(), bounds.Top(), TopLeftPixels,TopLeftPixels);
  883.       break;
  885.     case AdjustHScrollAfterVScroll :
  886.       SetDimensions(bounds.Width(), hsHeight, PixelCoords);
  887.       bounds.SetBottom(bounds.Bottom() - hsHeight);
  888.       SetPosition(bounds.Left(), bounds.Bottom(), TopLeftPixels,TopLeftPixels);
  889.       break;
  890.   }
  891. }
  894. PORDINATE PInteractor::ToPixelsX(PORDINATE x) const
  895. {
  896.   return (PORDINATE)(((long)x*(PORDINATE)font.GetAvgWidth(TRUE)+2)/4);
  897. }
  900. PORDINATE PInteractor::ToPixelsY(PORDINATE y) const
  901. {
  902.   return (PORDINATE)(((long)y*(PORDINATE)font.GetHeight(TRUE)+4)/8);
  903. }
  906. PORDINATE PInteractor::FromPixelsX(PORDINATE x) const
  907. {
  908.   int fontScaleX = font.GetAvgWidth(TRUE);
  909.   return (PORDINATE)(((long)x*4+fontScaleX/2)/fontScaleX);
  910. }
  913. PORDINATE PInteractor::FromPixelsY(PORDINATE y) const
  914. {
  915.   int fontScaleY = font.GetHeight(TRUE);
  916.   return (PORDINATE)(((long)y*8+fontScaleY/2)/fontScaleY);
  917. }
  920. #endif
  923. //////////////////////////////////////////////////////////////////////////////
  924. // PInteractorLayout
  926. #if defined(_PINTERACTORLAYOUT)
  928. PControl * PInteractorLayout::GetControl(PRESOURCE_ID id)
  929. {
  930.   for (PINDEX i = 0; i < GetNumChildren(); i++) {
  931.     PInteractor & child = children[i];
  932.     if (child.IsDescendant(PControl::Class()) &&
  933.                                    ((PControl &)child).GetControlID() == id)
  934.       return (PControl *)&child;
  935.   }
  936.   return NULL;
  937. }
  940. void PInteractorLayout::SetFocusInteractor(PInteractor * interactor)
  941. {
  942.   focusInteractor = interactor;
  943. }
  946. PInteractor * PInteractorLayout::GetFocusInteractor() const
  947. {
  948.   return focusInteractor;
  949. }
  952. void PInteractorLayout::UpdateControls()
  953. {
  954.   for (PINDEX i = 0; i < GetNumChildren(); i++)
  955.     if (children[i].IsDescendant(PControl::Class()))
  956.       ((PControl &)children[i]).TransferValue(PControl::NotifyUpdate);
  957. }
  960. #endif
  963. //////////////////////////////////////////////////////////////////////////////
  964. // PDialog
  966. #if defined(_PDIALOG)
  968. void PDialog::Close()
  969. {
  970.   OnClose();
  971.   owner->DelayedCloseInteractor(this);
  972. }
  975. void PDialog::OnClose()
  976. {
  977. }
  980. void PDialog::OnOk()
  981. {
  982.   Close();
  983. }
  986. void PDialog::OnCancel()
  987. {
  988.   Close();
  989. }
  992. void PDialog::StdButtonPressed(PPushButton & button, INT)
  993. {
  994.   if (&button == ok)
  995.     OnOk();
  996.   else if (&button == help)
  997.     OnSelectHelp();
  998.   else
  999.     OnCancel();
  1000. }
  1003. void PDialog::SetStdButtons(PPushButton * okBtn,
  1004.                                PPushButton * cancelBtn, PPushButton * helpBtn)
  1005. {
  1006.   if ((ok = okBtn) != NULL)
  1007.     ok->SetNotifier(PCREATE_NOTIFIER(StdButtonPressed));
  1009.   if ((cancel = cancelBtn) != NULL)
  1010.     cancel->SetNotifier(PCREATE_NOTIFIER(StdButtonPressed));
  1012.   if ((help = helpBtn) != NULL)
  1013.     help->SetNotifier(PCREATE_NOTIFIER(StdButtonPressed));
  1014. }
  1017. #endif
  1020. ///////////////////////////////////////////////////////////////////////////////
  1021. // PFloatingDialog
  1023. #if defined(_PFLOATINGDIALOG)
  1025. PFloatingDialog::PFloatingDialog(PInteractor * parent)
  1026.   : PDialog(parent)
  1027. {
  1028.   Construct();
  1029. }
  1032. PFloatingDialog::PFloatingDialog(PInteractor * parent, PRESOURCE_ID resID)
  1033.   : PDialog(parent, resID)
  1034. {
  1035.   Construct();
  1036. }
  1039. #endif
  1042. ///////////////////////////////////////////////////////////////////////////////
  1043. // PModalDialog
  1045. #if defined(_PMODALDIALOG)
  1047. void PModalDialog::OnInit()
  1048. {
  1049.   UpdateControls();
  1050.   Save();
  1051. }
  1054. void PModalDialog::OnOk()
  1055. {
  1056.   EndModal(TRUE);
  1057. }
  1060. void PModalDialog::OnCancel()
  1061. {
  1062.   Restore();
  1063.   EndModal(FALSE);
  1064. }
  1067. void PModalDialog::Save()
  1068. {
  1069. }
  1071. void PModalDialog::Restore()
  1072. {
  1073. }
  1076. #endif
  1079. //////////////////////////////////////////////////////////////////////////////
  1080. // PFileDialog
  1082. #if defined (_PFILEDIALOG)
  1084. void PFileDialog::OnFileSelect(const PFilePath &)
  1085. {
  1086. }
  1089. #endif
  1092. //////////////////////////////////////////////////////////////////////////////
  1093. // POpenFileDialog
  1095. #if defined (_POPENFILEDIALOG)
  1097. PINDEX POpenFileDialog::AddFileType(const PString & type)
  1098. {
  1099.   PINDEX i = fileTypes.GetSize();
  1100.   fileTypes[i] = type;
  1101.   return i;
  1102. }
  1105. BOOL POpenFileDialog::OnFilterFile(const PFilePath &)
  1106. {
  1107.   return TRUE;
  1108. }
  1111. #endif
  1114. //////////////////////////////////////////////////////////////////////////////
  1115. // PPrintDialog
  1117. #ifdef _PPRINTDIALOG
  1119. PPrintDialog::PPrintDialog(PInteractor * parent, PRESOURCE_ID resID)
  1120.   : PModalDialog(parent, resID)
  1121. {
  1122.   Construct();
  1123. }
  1126. PPrintDialog::PPrintDialog(PInteractor * parent,
  1127.                                   const PPrintInfo & info, PRESOURCE_ID resID)
  1128.   : PModalDialog(parent, resID),
  1129.     printInfo(info)
  1130. {
  1131.   Construct();
  1132. }
  1135. #endif
  1138. //////////////////////////////////////////////////////////////////////////////
  1139. // PPrinterSetupDialog
  1141. #ifdef _PPRINTERSETUPDIALOG
  1143. PPrinterSetupDialog::PPrinterSetupDialog(PInteractor * parent,
  1144.                                                            PRESOURCE_ID resID)
  1145.   : PPrintDialog(parent, resID)
  1146. {
  1147.   Construct();
  1148. }
  1151. PPrinterSetupDialog::PPrinterSetupDialog(PInteractor * parent,
  1152.                                   const PPrintInfo & info, PRESOURCE_ID resID)
  1153.   : PPrintDialog(parent, info, resID)
  1154. {
  1155.   Construct();
  1156. }
  1159. #endif
  1162. //////////////////////////////////////////////////////////////////////////////
  1163. // PPrintJobDialog
  1165. #ifdef _PPRINTJOBDIALOG
  1167. PPrintJobDialog::PPrintJobDialog(PInteractor * parent, PRESOURCE_ID resID)
  1168.   : PPrintDialog(parent, resID)
  1169. {
  1170.   Construct();
  1171. }
  1174. PPrintJobDialog::PPrintJobDialog(PInteractor * parent,
  1175.                                   const PPrintInfo & info, PRESOURCE_ID resID)
  1176.   : PPrintDialog(parent, info, resID)
  1177. {
  1178.   Construct();
  1179. }
  1182. #endif
  1185. //////////////////////////////////////////////////////////////////////////////
  1186. // PFontDialog
  1188. #ifdef _PFONTDIALOG
  1190. PFontDialog::PFontDialog(PInteractor * parent,
  1191.                                     PPrintCanvas * pCanvas, PRESOURCE_ID resID)
  1192.   : PModalDialog(parent, resID),
  1193.     selectedFont(owner->GetSystemFont()),
  1194.     printerCanvas(pCanvas)
  1195. {
  1196.   Construct(resID);
  1197. }
  1200. PFontDialog::PFontDialog(PInteractor * parent,
  1201.              const PFont & newFont, PPrintCanvas * pCanvas, PRESOURCE_ID resID)
  1202.   : PModalDialog(parent, resID),
  1203.     selectedFont(newFont),
  1204.     printerCanvas(pCanvas)
  1205. {
  1206.   Construct(resID);
  1207. }
  1210. #endif
  1213. //////////////////////////////////////////////////////////////////////////////
  1214. // PColourDialog
  1216. #ifdef _PCOLOURDIALOG
  1218. PColourDialog::PColourDialog(PInteractor * parent, PRESOURCE_ID resID)
  1219.   : PModalDialog(parent, resID)
  1220. {
  1221.   Construct(resID);
  1222. }
  1225. PColourDialog::PColourDialog(PInteractor * parent,
  1226.                                 const PColour & newColour, PRESOURCE_ID resID)
  1227.   : PModalDialog(parent, resID),
  1228.     colour(newColour)
  1229. {
  1230.   Construct(resID);
  1231. }
  1234. #endif
  1237. //////////////////////////////////////////////////////////////////////////////
  1238. // PTitledWindow
  1240. #if defined (_PTITLEDWINDOW)
  1242. PDim PTitledWindow::GetMinSize(CoordinateSystem coords)
  1243. {
  1244.   if (coords != LocalCoords)
  1245.     return minSize;
  1246.   return FromPixels(minSize);
  1247. }
  1250. PDim PTitledWindow::GetMaxSize(CoordinateSystem coords)
  1251. {
  1252.   if (coords != LocalCoords)
  1253.     return maxSize;
  1254.   return ToPixels(maxSize);
  1255. }
  1258. PDim PTitledWindow::GetZoomSize(CoordinateSystem coords)
  1259. {
  1260.   if (coords != LocalCoords)
  1261.     return zoomSize;
  1262.   return ToPixels(zoomSize);
  1263. }
  1266. void PTitledWindow::SetZoomSize(const PDim & dim, CoordinateSystem coords)
  1267. {
  1268.   if (coords != LocalCoords)
  1269.     zoomSize = dim;
  1270.   else
  1271.     zoomSize = ToPixels(dim);
  1272. }
  1275.   void PTitledWindow::SetFocusInteractor(PInteractor * interactor)
  1276. {
  1277.   focusInteractor = interactor;
  1278. }
  1281. PInteractor * PTitledWindow::GetFocusInteractor() const
  1282. {
  1283.   return focusInteractor;
  1284. }
  1287. void PTitledWindow::OnClose()
  1288. {
  1289. }
  1292. BOOL PTitledWindow::Close()
  1293. {
  1294.   if (!AllowClose(FALSE))
  1295.     return FALSE;
  1297.   owner->DelayedCloseInteractor(this);
  1298.   return TRUE;
  1299. }
  1302. BOOL PTitledWindow::AllowClose(BOOL)
  1303. {
  1304.   return TRUE;
  1305. }
  1308. #endif
  1311. //////////////////////////////////////////////////////////////////////////////
  1312. // PTopLevelWindow
  1314. #if defined (_PTOPLEVELWINDOW) && defined (_PMENUITEM)
  1316. BOOL PTopLevelWindow::Close()
  1317. {
  1318.   if (this != owner->GetWindow())
  1319.     return PTitledWindow::Close();
  1321.   if (!AllowClose(TRUE))
  1322.     return FALSE;
  1324.   PINDEX i;
  1325.   for (i = 0; i < GetNumChildren(); i++) {
  1326.     if (children[i].IsDescendant(PTitledWindow::Class()))
  1327.       if (!((PTitledWindow&)children[i]).AllowClose(TRUE))
  1328.         return FALSE;
  1329.   }
  1331.   for (i = 0; i < GetNumChildren(); i++) {
  1332.     if (children[i].IsDescendant(PTitledWindow::Class()))
  1333.       ((PTitledWindow&)children[i]).Close();
  1334.   }
  1336.   OnClose();
  1337.   owner->Terminate();
  1338.   return TRUE;
  1339. }
  1342. void PTopLevelWindow::UpdateMyCommandSources()
  1343. {
  1344.   if (menu != NULL)
  1345.     menu->UpdateMyCommandSources();
  1346.   PTitledWindow::UpdateMyCommandSources();
  1347. }
  1350. void PTopLevelWindow::OnMenuStartSelect()
  1351. {
  1352.   UpdateCommandSources();
  1353. }
  1356. void PTopLevelWindow::OnMenuItemSelect(PMenuItem & item)
  1357. {
  1358.   PNotifier notifier = item.GetNotifier();
  1359.   if (!notifier.IsNULL())
  1360.     notifier(item, 0);
  1361. }
  1364. #endif
  1367. ///////////////////////////////////////////////////////////////////////////////
  1368. // PMDIFrameWindow
  1370. #if defined(_PMDIFRAMEWINDOW)
  1372. PRect PMDIFrameWindow::GetDocumentArea(CoordinateSystem coords) const
  1373. {
  1374.   if (coords != LocalCoords)
  1375.     return documentArea;
  1376.   return FromPixels(documentArea);
  1377. }
  1380. #endif
  1383. ///////////////////////////////////////////////////////////////////////////////
  1384. // PBalloon
  1386. PBalloon::PBalloon(PInteractor * parent)
  1387.   : PPopUp(parent)
  1388. {
  1389.   Construct();
  1390. }
  1393. PBalloon::PBalloon(PInteractor * parent, const PString & text)
  1394.   : PPopUp(parent),
  1395.     balloonText(text)
  1396. {
  1397.   Construct();
  1398.   SetText(text);
  1399. }
  1402. void PBalloon::Construct()
  1403. {
  1404.   owner->DoBalloonHelp(this, 1); // Initialise the new balloon help window
  1405.   SetForegroundColour(owner->GetBalloonFgColour());
  1406.   SetBackgroundColour(owner->GetBalloonBkColour());
  1407.   SetFont(owner->GetBalloonFont());
  1408. }
  1411. void PBalloon::SetText(const PString & text)
  1412. {
  1413.   balloonText = text;
  1415.   PDrawCanvas canvas(this);
  1416.   SetDimensions(canvas.MeasureString(balloonText) + PDim(2, 2), LocalCoords);
  1418.   PDim myDim = GetDimensions(PixelCoords);
  1420.   PRect r = parent->GetStructureBounds(ScreenCoords);
  1421.   r.Offset(r.Width()/8, r.Height() + myDim.Height()/2);
  1422.   r.SetDimensions(myDim);
  1424.   PRect scr = owner->GetScreenRect();
  1425.   if (r.Right() > scr.Right())
  1426.     r.SetX(scr.Right() - r.Width());
  1427.   if (r.Bottom() > scr.Bottom())
  1428.     r.SetY(scr.Bottom() - r.Height());
  1430.   SetPosition(r.X(), r.Y(), TopLeftScreen, TopLeftScreen);
  1431.   Show();
  1432. }
  1435. void PBalloon::OnRedraw(PCanvas & canvas)
  1436. {
  1437.   canvas.DrawString(canvas.GetDrawingBounds(),
  1438.                         balloonText, PCanvas::Centred|PCanvas::CentreVertical);
  1439. }
  1442. ///////////////////////////////////////////////////////////////////////////////
  1443. // PScrollable & PScroller
  1445. #if defined(_PSCROLLABLE)
  1447. PScroller::PScroller(PInteractor * parent)
  1448.   : PInteractor(parent)
  1449. {
  1450.   vScroll = new PVerticalScrollBar(this, PCREATE_NOTIFIER(ScrollBarNotify), 0);
  1451.   vScroll->Show();
  1452.   hScroll = new PHorizontalScrollBar(this,PCREATE_NOTIFIER(ScrollBarNotify),0);
  1453.   hScroll->Show();
  1454. }
  1457. PScrollable & PScroller::GetContents()
  1458. {
  1459.   PINDEX num = GetNumChildren();
  1460.   while (num > 2) {
  1461.     num--;
  1462.     PInteractor & contents = children[num];
  1463.     if (contents.IsDescendant(PScrollable::Class()))
  1464.       return (PScrollable &)contents;
  1465.   }
  1466.   PAssertAlways("No scrollable window in scroller");
  1467.   return *(PScrollable *)this;
  1468. }
  1471. void PScroller::ShowAll()
  1472. {
  1473.   GetContents().Show();
  1474.   Show();
  1475. }
  1478. void PScroller::_SetDimensions(PDIMENSION width, PDIMENSION height,
  1479.                                CoordinateSystem coords)
  1480. {
  1481.   PInteractor::_SetDimensions(width, height, coords);
  1483.   PRect bounds(GetDimensions(PixelCoords));
  1484.   if (hScroll->IsVisible() && vScroll->IsVisible()) {
  1485.     vScroll->AutoAdjustBounds(bounds, AdjustVScrollBeforeHScroll);
  1486.     hScroll->AutoAdjustBounds(bounds, AdjustHScrollAfterVScroll);
  1487.   }
  1488.   else if (vScroll->IsVisible())
  1489.     vScroll->AutoAdjustBounds(bounds, AdjustVScrollOnly);
  1490.   else if (hScroll->IsVisible())
  1491.     hScroll->AutoAdjustBounds(bounds, AdjustHScrollOnly);
  1493.   PScrollable & contents = GetContents();
  1494.   contents.AutoAdjustBounds(bounds);
  1495.   contents.SetScrollRange(contents.GetScrollRange());
  1496. }
  1499. void PScroller::ScrollBarNotify(PScrollBar &, INT option)
  1500. {
  1501.   if (option != PScrollBar::StartTrack)
  1502.     GetContents().ScrollTo(hScroll->GetValue(), vScroll->GetValue());
  1503. }
  1507. PScrollable::PScrollable(PScroller * parent)
  1508.   : PInteractor(parent), scrollRange(0, 0, 10000, 10000), scaleFactor(1, 1)
  1509. {
  1510. }
  1513. PRect PScrollable::GetDrawingBounds(CoordinateSystem coords) const
  1514. {
  1515.   PRect r(scrollRange.Origin()*scaleFactor, scrollRange.Corner()*scaleFactor);
  1516.   if (coords != LocalCoords)
  1517.     return r;
  1518.   return FromPixels(r);
  1519. }
  1522. static void AdjustScrollBar(PORDINATE min, PORDINATE max, PORDINATE scale,
  1523.                                         PDIMENSION window, PScrollBar * scroll)
  1524. {
  1525.   int winSize = window/scale;
  1526.   int maxAdjusted = max - min - winSize;
  1527.   if (maxAdjusted < min)
  1528.     maxAdjusted = min;
  1529.   scroll->SetMinimum((PSCROLLBAR_VALUE)min);
  1530.   scroll->SetMaximum((PSCROLLBAR_VALUE)maxAdjusted);
  1531.   scroll->SetSmallNudge((PSCROLLBAR_VALUE)((winSize+9)/10));
  1532.   scroll->SetLargeNudge((PSCROLLBAR_VALUE)((winSize*9+9)/10));
  1533. }
  1536. void PScrollable::SetScrollRange(const PRect & rect)
  1537. {
  1538.   scrollRange = rect;
  1540.   PScroller * scroller = (PScroller *)GetParent();
  1541.   PDim dim = GetDimensions(PixelCoords);
  1543.   AdjustScrollBar(scrollRange.Left(), scrollRange.Right(),
  1544.                              scaleFactor.X(), dim.Width(),  scroller->hScroll);
  1545.   AdjustScrollBar(scrollRange.Top(), scrollRange.Bottom(),
  1546.                              scaleFactor.Y(), dim.Height(), scroller->vScroll);
  1547.   origin.SetX(scroller->hScroll->GetValue());
  1548.   origin.SetY(scroller->vScroll->GetValue());
  1549. }
  1552. void PScrollable::SetScaleFactor(const PPoint & scale)
  1553. {
  1554.   PAssert(scale.X() > 0 && scale.Y() > 0, PInvalidParameter);
  1555.   scaleFactor = scale;
  1556.   SetScrollRange(GetScrollRange());
  1557. }
  1560. void PScrollable::ScrollTo(const PPoint & newOrg)
  1561. {
  1562.   PPoint oldOrigin = origin;
  1563.   PScroller * scroller = (PScroller *)GetParent();
  1565.   PNotifier notifer = scroller->hScroll->GetNotifier();
  1566.   scroller->hScroll->SetNotifier(PNotifier());
  1567.   scroller->hScroll->SetValue((PSCROLLBAR_VALUE)newOrg.X());
  1568.   scroller->hScroll->SetNotifier(notifer);
  1570.   notifer = scroller->vScroll->GetNotifier();
  1571.   scroller->vScroll->SetNotifier(PNotifier());
  1572.   scroller->vScroll->SetValue((PSCROLLBAR_VALUE)newOrg.Y());
  1573.   scroller->vScroll->SetNotifier(notifer);
  1575.   origin.SetX(scroller->hScroll->GetValue());
  1576.   origin.SetY(scroller->vScroll->GetValue());
  1578.   OnScroll(oldOrigin - origin);
  1579. }
  1582. void PScrollable::OnScroll(const PPoint & scrollDelta)
  1583. {
  1584.   if (scrollDelta.X() == 0 && scrollDelta.Y() == 0)
  1585.     return;
  1587.   PDim dim = GetDimensions(PixelCoords);
  1589.   PPoint delta = scrollDelta * scaleFactor;
  1590.   if ((PDIMENSION)PABS(delta.X()) > dim.Width() ||
  1591.       (PDIMENSION)PABS(delta.Y()) > dim.Height()) {
  1592.     Invalidate();
  1593.     return;
  1594.   }
  1596.   PDrawCanvas canvas(this, TRUE);
  1597.   canvas.Scroll(delta, PRect(dim));
  1599.   if (delta.X() > 0)
  1600.     Invalidate(0, 0, (PDIMENSION)delta.X(), dim.Height(), PixelCoords);
  1601.   else if (delta.X() < 0) {
  1602.     PORDINATE x=(dim.Width()/scaleFactor.X()+scrollDelta.X())*scaleFactor.X();
  1603.     Invalidate(x, 0, dim.Width()-x, dim.Height(), PixelCoords);
  1604.   }
  1606.   if (delta.Y() > 0)
  1607.     Invalidate(0, 0, dim.Width(), (PDIMENSION)delta.Y(), PixelCoords);
  1608.   else if (delta.Y() < 0) {
  1609.     PORDINATE y=(dim.Height()/scaleFactor.Y()+scrollDelta.Y())*scaleFactor.Y();
  1610.     Invalidate(0, y, dim.Width(), dim.Height()-y, PixelCoords);
  1611.   }
  1612. }
  1615. #endif
  1618. ///////////////////////////////////////////////////////////////////////////////
  1619. // PMenuEntry
  1621. #if defined(_PMENUENTRY)
  1623. PMenuEntry::PMenuEntry()
  1624. {
  1625.   itsMenu = NULL;
  1626. }
  1629. PMenuEntry::PMenuEntry(PSubMenu & menu, PMenuEntry * before)
  1630. {
  1631.   itsMenu = &menu;
  1632.   if (before != NULL)
  1633.     itsMenu->entries.Insert(*before, this);
  1634.   else
  1635.     itsMenu->entries.Append(this);
  1636. }
  1639. PObject::Comparison PMenuEntry::Compare(const PObject & obj) const
  1640. {
  1641.   PAssert(obj.IsDescendant(PMenuEntry::Class()), PInvalidCast);
  1642.   const PMenuEntry & other = (const PMenuEntry &)obj;
  1643.   int myPosition = GetPosition();
  1644.   int otherPosition = other.GetPosition();
  1645.   if (itsMenu != other.itsMenu)
  1646.     return itsMenu->Compare(*other.itsMenu);
  1647.   if (myPosition > otherPosition)
  1648.     return GreaterThan;
  1649.   if (myPosition < otherPosition)
  1650.     return LessThan;
  1651.   return EqualTo;
  1652. }
  1655. PRootMenu * PMenuEntry::GetRootMenu() const
  1656. {
  1657.   PSubMenu * root = GetMenu();
  1658.   if (root != NULL) {
  1659.     while (root->GetMenu() != NULL)
  1660.       root = root->GetMenu();
  1661.     if (root->IsDescendant(PRootMenu::Class()))
  1662.       return (PRootMenu *)root;
  1663.   }
  1664.   return NULL;
  1665. }
  1668. BOOL PMenuEntry::IsMenuItemCheckGroup(const PMenuItem &) const
  1669. {
  1670.   return FALSE;
  1671. }
  1674. void PMenuEntry::UpdateMyCommandSources()
  1675. {
  1676.   // Do nothing
  1677. }
  1680. #endif
  1683. ///////////////////////////////////////////////////////////////////////////////
  1684. // PMenuItem
  1686. #if defined(_PMENUITEM)
  1688. PMenuItem::PMenuItem(PSubMenu & menu,
  1689.                                 const PString & itemName, PMenuEntry * before)
  1690.   : PMenuEntry(menu, before),
  1691.     name(itemName),
  1692.     checkPointer(NULL),
  1693.     notifyForStateUpdate(FALSE)
  1694. {
  1695.   Construct(TRUE);
  1696. }
  1699. PMenuItem::PMenuItem(PSubMenu & menu, const PString & itemName,
  1700.                       const PNotifier & func, BOOL update, PMenuEntry * before)
  1701.   : PMenuEntry(menu, before),
  1702.     name(itemName),
  1703.     callback(func),
  1704.     checkPointer(NULL),
  1705.     notifyForStateUpdate(update)
  1706. {
  1707.   Construct(TRUE);
  1708. }
  1711. PMenuItem::PMenuItem(PSubMenu & menu, const PString & itemName,
  1712.                      const PKeyCode & accel, const PNotifier & func,
  1713.                      BOOL update, PMenuEntry * before)
  1714.   : PMenuEntry(menu, before),
  1715.     name(itemName),
  1716.     callback(func),
  1717.     checkPointer(NULL),
  1718.     notifyForStateUpdate(update)
  1719. {
  1720.   accelerator = accel;
  1721.   Construct(TRUE);
  1722. }
  1725. PMenuItem::PMenuItem(PRESOURCE_ID newID,
  1726.                 PSubMenu & menu, const char * itemName, const PKeyCode & accel)
  1727.   : PMenuEntry(menu, NULL),
  1728.     name(itemName),
  1729.     accelerator(accel),
  1730.     checkPointer(NULL),
  1731.     notifyForStateUpdate(FALSE)
  1732. {
  1733.   menuID = newID;
  1734.   Construct(FALSE);
  1735. }
  1738. PMenuItem::~PMenuItem()
  1739. {
  1740.   PRootMenu * root = GetRootMenu();
  1741.   if (root != NULL)
  1742.     root->keyedItems.SetAt(menuID, NULL);
  1743. }
  1746. PString PMenuItem::GetString() const
  1747. {
  1748.   return name;
  1749. }
  1752. void PMenuItem::UpdateMyCommandSources()
  1753. {
  1754.   if (notifyForStateUpdate && !callback.IsNULL())
  1755.     callback(*this, TRUE);
  1756. }
  1759. BOOL PMenuItem::IsMenuItemCheckGroup(const PMenuItem & groupItem) const
  1760. {
  1761.   return groupItem.GetNotifier() == callback;
  1762. }
  1765. void PMenuItem::SetGroupCheck(PINDEX newItem)
  1766. {
  1767.   PINDEX i = GetPosition();
  1768.   PSubMenu & myMenu = *itsMenu;
  1769.   while (i > 0 && myMenu[i-1].IsMenuItemCheckGroup(*this))
  1770.     i--;
  1771.   PINDEX pos = i;
  1772.   while (i < myMenu.GetSize() && myMenu[i].IsMenuItemCheckGroup(*this)) {
  1773.     ((PMenuItem &)myMenu[i]).Check((i - pos) == (newItem - 1));
  1774.     i++;
  1775.   }
  1776. }
  1779. void PMenuItem::SetGroupCheck()
  1780. {
  1781.   PINDEX pos = GetPosition();
  1782.   PINDEX i = pos;
  1783.   PSubMenu & myMenu = *itsMenu;
  1784.   while (i > 0 && myMenu[i-1].IsMenuItemCheckGroup(*this))
  1785.     i--;
  1786.   while (i < myMenu.GetSize() && myMenu[i].IsMenuItemCheckGroup(*this)) {
  1787.     ((PMenuItem &)myMenu[i]).Check(i == pos);
  1788.     i++;
  1789.   }
  1790. }
  1793. PINDEX PMenuItem::GetGroupCheck() const
  1794. {
  1795.   PINDEX i = GetPosition();
  1796.   PSubMenu & myMenu = *itsMenu;
  1797.   while (i > 0 && myMenu[i-1].IsMenuItemCheckGroup(*this))
  1798.     i--;
  1799.   PINDEX pos = i;
  1800.   while (i < myMenu.GetSize() && myMenu[i].IsMenuItemCheckGroup(*this)) {
  1801.     if (((PMenuItem &)myMenu[i]).IsChecked())
  1802.       return i - pos + 1;
  1803.     i++;
  1804.   }
  1805.   return 0;
  1806. }
  1809. #endif
  1812. //////////////////////////////////////////////////////////////////////////////
  1813. // PMenuSeparator
  1815. #if defined(_PMENUSEPARATOR)
  1817. PString PMenuSeparator::GetString() const
  1818. {
  1819.   return "";
  1820. }
  1823. void PMenuSeparator::SetString(const PString &)
  1824. {
  1825. }
  1828. #endif
  1831. //////////////////////////////////////////////////////////////////////////////
  1832. // PSubMenu
  1834. #if defined(_PSUBMENU)
  1836. void PSubMenu::UpdateMyCommandSources()
  1837. {
  1838.   for (PINDEX i = 0; i < GetSize(); i++)
  1839.     entries[i].UpdateMyCommandSources();
  1840. }
  1843. #endif
  1846. ///////////////////////////////////////////////////////////////////////////////
  1847. // PResourceString
  1849. #if defined(_PRESOURCESTRING)
  1851. PResourceString::PResourceString(PRESOURCE_ID resID)
  1852. {
  1853.   Construct(resID);
  1854. }
  1857. PResourceString::PResourceString(PRESOURCE_ID resID, const PString & dflt)
  1858. {
  1859.   Construct(resID);
  1860.   if (IsEmpty())
  1861.     strcpy(GetPointer(dflt.GetLength()+1), dflt);
  1862. }
  1865. #endif
  1868. ///////////////////////////////////////////////////////////////////////////////
  1869. // PApplication
  1871. #if defined(_PAPPLICATION)
  1873. PApplication & PApplication::Current()
  1874. {
  1875.   PApplication & app = (PApplication &)PProcess::Current();
  1876.   PAssert(app.IsDescendant(PApplication::Class()), "Invalid PApplication class");
  1877.   return app;
  1878. }
  1881. void PApplication::Construct()
  1882. {
  1883.   balloonee = NULL;
  1884.   balloon = NULL;
  1885.   blowUpTimer.SetNotifier(PCREATE_NOTIFIER(BlowUpBalloon));
  1887.   aboutMenuItemString = PResourceString(PSTD_ID_STR_ABOUT_MENU, "&About...");
  1888.   aboutDialogID = 0;
  1889. }
  1892. void PApplication::PassMainLoop()
  1893. {
  1894. }
  1897. void PApplication::OnAbout()
  1898. {
  1899.   if (aboutDialogID != 0) {
  1900.     PAboutDialog dlg(mainWindow, aboutDialogID);
  1901.     dlg.RunModal();
  1902.   }
  1903.   else {
  1904.     PResourceString title(PSTD_ID_STR_ABOUT_TEXT,
  1905.                                        "Portable Windows Library Application");
  1906.     PStringStream s;
  1907.     s << title << 'n' << GetName();
  1908.     if (!GetVersion(TRUE).IsEmpty())
  1909.       s << " v" << GetVersion(TRUE);
  1910.     if (!GetManufacturer().IsEmpty())
  1911.       s << " by " << GetManufacturer();
  1912. #if PMEMORY_CHECK
  1913.     PMemoryHeap::DumpStatistics(s);
  1914. #endif
  1915.     PSimpleDialog::Info(mainWindow, s);
  1916.   }
  1917. }
  1920. PBalloon * PApplication::DoBalloonHelp(PInteractor * interactor, int action)
  1921. {
  1922.   switch (action) {
  1923.     case 0 :
  1924.       if (balloon == NULL)
  1925.         if (interactor != NULL)
  1926.           blowUpTimer = blowUpTimeout;
  1927.         else
  1928.           blowUpTimer = 0;
  1929.       else if (balloon != interactor && balloon->GetParent() != interactor) {
  1930.         PBalloon * oldBalloon = balloon;
  1931.         PBalloon * newBalloon = balloon;
  1932.         if (interactor != NULL)
  1933.           newBalloon = interactor->OnBalloonHelp();
  1934.         if (oldBalloon == newBalloon)
  1935.           blowUpTimer = 0;
  1936.         else {
  1937.           delete oldBalloon;
  1938.           balloon = newBalloon;
  1939.         }
  1940.       }
  1941.       balloonee = interactor;
  1942.       break;
  1944.     case 1 :
  1945.       balloon = (PBalloon *)interactor;
  1946.   }
  1948.   return balloon;
  1949. }
  1952. void PApplication::BlowUpBalloon(PTimer &, INT)
  1953. {
  1954.   if (balloonee != NULL)
  1955.     balloon = balloonee->OnBalloonHelp();
  1956. }
  1959. void PApplication::DelayedCloseInteractor(PInteractor * interactor)
  1960. {
  1961.   if (delayedCloseInteractors.GetObjectsIndex(interactor) == P_MAX_INDEX)
  1962.     delayedCloseInteractors.Append(interactor);
  1963. }
  1966. #endif
  1969. ///////////////////////////////////////////////////////////////////////////////
  1970. // PCommandSink
  1972. PCommandSink::PCommandSink(const char * className, const char * commandName)
  1973. {
  1974.   PApplication::Current().commandManager.Register(className, commandName, this);
  1975. }
  1978. BOOL PCommandSink::Enabled(PTitledWindow *) const
  1979. {
  1980.   return TRUE;
  1981. }
  1984. PINDEX PCommandSink::Value(PTitledWindow *) const
  1985. {
  1986.   return 0;
  1987. }
  1990. ///////////////////////////////////////////////////////////////////////////////
  1991. // PCommandSource
  1993. void PCommandSource::Call(PObject & notifier, INT extra) const
  1994. {
  1995.   PCommandSink * sink = NULL;
  1997.   PTitledWindow * wind = (PTitledWindow *)object;
  1998.   if (wind->IsDescendant(PMDIFrameWindow::Class())) {
  1999.     PMDIDocWindow * child = ((PMDIFrameWindow *)wind)->GetActiveDocument();
  2000.     if (child != NULL) {
  2001.       unsigned ancestor = 0;
  2002.       for (;;) {
  2003.         const char * className = child->GetClass(ancestor);
  2004.         if (strcmp(className, PMDIDocWindow::Class()) == 0)
  2005.           break;
  2007.         sink = PApplication::Current().commandManager.Find(className, name);
  2008.         if (sink != NULL) {
  2009.           wind = child;
  2010.           break;
  2011.         }
  2013.         ancestor++;
  2014.       }
  2015.     }
  2016.   }
  2018.   if (sink == NULL)
  2019.     sink = PApplication::Current().commandManager.Find(wind->GetClass(),name);
  2021.   if (notifier.IsDescendant(PMenuItem::Class())) {
  2022.     if (extra) {
  2023.       PMenuItem & item = (PMenuItem &)notifier;
  2024.       item.Enable(sink != NULL && sink->Enabled(wind));
  2025.       item.SetGroupCheck(sink != NULL ? sink->Value(wind) : 0);
  2026.     }
  2027.     else if (sink != NULL)
  2028.       sink->Execute(wind);
  2029.   }
  2030.   else {
  2031.     PControl & item = (PControl &)notifier;
  2032.     switch (extra) {
  2033.       case PControl::NotifyUpdate :
  2034.         if (sink != NULL)
  2035.           sink->Value(wind);
  2036.         break;
  2037.       case PControl::NotifyEnable :
  2038.         item.Enable(sink != NULL && sink->Enabled(wind));
  2039.         break;
  2040.       case PControl::NotifyChange :
  2041.         if (sink != NULL)
  2042.           sink->Execute(wind);
  2043.     }
  2044.   }
  2045. }
  2048. ///////////////////////////////////////////////////////////////////////////////
  2049. // PCommandManager
  2051. void PCommandManager::Register(const char * className,
  2052.                                  const char * commandName, PCommandSink * sink)
  2053. {
  2054.   PString classNameString = className;
  2055.   if (commands.GetAt(classNameString) == NULL)
  2056.     commands.SetAt(classNameString, new CommandsByName);
  2057.   commands[classNameString].SetAt(PString(commandName), sink);
  2058. }
  2061. PCommandSink * PCommandManager::Find(const PString & className,
  2062.                                                   const PString & commandName)
  2063. {
  2064.   if (commands.GetAt(className) == NULL)
  2065.     return NULL;
  2067.   return (PCommandSink *)commands[className].GetAt(commandName);
  2068. }
  2071. #undef new
  2074. // End Of File ///////////////////////////////////////////////////////////////