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

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

IP电话/视频会议

开发平台：

Visual C++

controls.cxx：源码内容
  1. /*
  2.  * controls.cxx
  3.  *
  4.  * Control interactor classes implmentation.
  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: controls.cxx,v $
  30.  * Revision 1.63  2000/07/11 19:01:36  robertj
  31.  * Fix of resizing PMultiLineEditBox allowing for scroll bars etc.
  32.  *
  33.  * Revision 1.62  2000/07/11 18:24:03  robertj
  34.  * Fixed incorrect return value on PComboBox::GetCurrent() when no selection.
  35.  *
  36.  * Revision 1.61  2000/06/27 00:14:53  robertj
  37.  * Fixed bug that causes crash when gettng cursor/selection position.
  38.  *
  39.  * Revision 1.60  2000/04/13 23:18:42  robertj
  40.  * Fixed problems with sizing controls with scroll bars.
  41.  *
  42.  * Revision 1.59  2000/04/13 01:37:14  robertj
  43.  * Added missing implementation of PEditBox::GetSelection() on Win32.
  44.  * Added PEditBox::ReplaceSelection() function.
  45.  *
  46.  * Revision 1.58  1999/11/23 05:24:32  robertj
  47.  * Moved function from platform independent to platform dependent files.
  48.  *
  49.  * Revision 1.57  1999/11/16 06:51:42  robertj
  50.  * Created PCustomListBox to allow motif native code PStringListBox implementation
  51.  *
  52.  * Revision 1.56  1998/09/24 03:42:36  robertj
  53.  * Added open software license.
  54.  *
  55.  * Revision 1.55  1998/09/21 13:31:01  robertj
  56.  * Changes to support new PListView class. Different call back method.
  57.  *
  58.  * Revision 1.54  1998/09/14 14:57:46  robertj
  59.  * Fixed incorrect return of owner draw mode for PStringListBox class.
  60.  *
  61.  * Revision 1.53  1998/09/14 13:11:14  robertj
  62.  * Fixed memory leak on delete of PStringList, not deleting all its contents.
  63.  * Added tab stops to string list box.
  64.  *
  65.  * Revision 1.52  1998/09/07 14:02:32  robertj
  66.  * Fixed double delete of PStrings in PStringListBix descendents.
  67.  *
  68.  * Revision 1.51  1998/09/03 15:48:34  robertj
  69.  * Added missing vertical scroll bar on drop down boxes.
  70.  *
  71.  * Revision 1.50  1998/08/06 00:55:59  robertj
  72.  * Fixed using non-standard controls as PControl descendants.
  73.  *
  74.  * Revision 1.49  1998/05/07 05:22:11  robertj
  75.  * Fixed bug in colour setting of radio buttons from resource.
  76.  *
  77.  * Revision 1.48  1998/02/06 04:00:17  robertj
  78.  * Fixed colour of controls, again!
  79.  *
  80.  * Revision 1.47  1998/01/26 00:20:04  robertj
  81.  * Fixed colour of static controls in windows and dialogs.
  82.  *
  83.  * Revision 1.46  1995/11/20 11:07:20  robertj
  84.  * Fixed bug in scroll bar colour.
  85.  * Fixed bug causing double notification in scroll bar click.
  86.  *
  87.  * Revision 1.45  1995/11/09 12:29:56  robertj
  88.  * Moved window style bits to member variable.
  89.  *
  90.  * Revision 1.44  1995/08/24 12:43:52  robertj
  91.  * Function OnEndInput() moved to platform dependent code.
  92.  *
  93.  * Revision 1.43  1995/07/02 06:23:32  robertj
  94.  * Fixed mouse button events not appearing in static text controls.
  95.  * Fixed bug with creating right and centred static text controls being left aligned.
  96.  *
  97.  * Revision 1.42  1995/06/17 11:10:02  robertj
  98.  * Added function to determine if control is a tab stop.
  99.  *
  100.  * Revision 1.41  1995/06/04 12:52:15  robertj
  101.  * Fixed bug in assert of list box resource control.
  102.  *
  103.  * Revision 1.40  1995/04/25 11:44:05  robertj
  104.  * Fixed Borland compiler warnings.
  105.  *
  106.  * Revision 1.39  1995/04/02 09:28:05  robertj
  107.  * Added "balloon" help.
  108.  *
  109.  * Revision 1.38  1995/03/12 05:00:24  robertj
  110.  * Re-organisation of DOS/WIN16 and WIN32 platforms to maximise common code.
  111.  * Used built-in equate for WIN32 API (_WIN32).
  112.  *
  113.  * Revision 1.37  1995/02/19  04:16:31  robertj
  114.  * Added callback when PListBox::SetSelection changes selection.
  115.  * Added dynamically linked command processing.
  116.  *
  117.  * Revision 1.36  1995/02/05  00:57:21  robertj
  118.  * Had to change variable name "small" for MSVC 2.0
  119.  *
  120.  * Revision 1.35  1995/01/28  07:28:49  robertj
  121.  * Assured all Windows strings have n converted to rn and vice versa.
  122.  *
  123.  * Revision 1.34  1995/01/27  11:29:21  robertj
  124.  * Fixed numerous bugs.
  125.  * Fixed bug in nested messages.
  126.  * Underscored library variables.
  127.  *
  128.  */
  130. #include <pwlib.h>
  131. #include <math.h>
  133. static char ControlResourceMismatch[] = "Control class mismatch from resource";
  136. //////////////////////////////////////////////////////////////////////////////
  137. // PControl
  139. PControl::PControl(PInteractor * parent, const PNotifier & notify, void *valuePtr)
  140.   : PInteractor(PAssertNULL(parent)),
  141.     callback(notify)
  142. {
  143.   PAssert(_hWnd == NULL, PLogicError);
  145.   notifyForStateUpdate = FALSE;
  146.   valuePointer = valuePtr;
  148.   PRESOURCE_ID id = (PRESOURCE_ID)(parent->GetNumChildren() + 100);
  149.   if (parent->IsDescendant(PInteractorLayout::Class())) {
  150.     while (((PInteractorLayout*)parent)->GetControl(id))
  151.       id++;
  152.   }
  153.   controlID = id;
  154. }
  157. PControl::PControl(PInteractorLayout * parent,
  158.                  PRESOURCE_ID ctlID, const PNotifier & notify, void * valuePtr)
  159.   : PInteractor(parent, GetDlgItem(PAssertNULL(parent)->GetHWND(), ctlID)),
  160.     callback(notify)
  161. {
  162.   PAssert(_hWnd != NULL, "GetDlgItem() failed.");
  164.   notifyForStateUpdate = FALSE;
  165.   valuePointer = valuePtr;
  167.   controlID = ctlID;
  169.   _styleBits = GetWindowLong(_hWnd, GWL_STYLE);
  170.   _exStyleBits = GetWindowLong(_hWnd, GWL_EXSTYLE);
  171.   SubClassControlWndProc();
  172. }
  175. BOOL PControl::IsTabStop() const
  176. {
  177.   return (_styleBits&WS_TABSTOP) != 0;
  178. }
  181. void PControl::CreateHWND()
  182. {
  183.   HINSTANCE hInst = owner->GetInstance();
  185.   WNDCLASS wclass;
  186.   GetCreateWinInfo(wclass);
  187.   if (!GetClassInfo(hInst, wclass.lpszClassName, &wclass))
  188.     PAssertOS(RegisterClass(&wclass));
  190.   _hWnd = CreateWindow(wclass.lpszClassName,
  191.                        "",
  192.                        _styleBits,
  193.                        -100, -100,
  194.                        10, 10,
  195.                        parent->GetHWND(),
  196.                        (HMENU)(controlID),
  197.                        hInst,
  198.                        NULL);
  199.   owner->AddWindowHandle(PAssertNULL(_hWnd), this);
  201.   SubClassControlWndProc();
  202.   SetWndFont();
  203. }
  206. void PControl::SubClassControlWndProc()
  207. {
  208.   wndProc = (WNDPROC)GetWindowLong(_hWnd, GWL_WNDPROC);
  209.   WNDPROC pwlibWndProc = owner->GetWndProcPtr(PApplication::WndProcType);
  210.   if (wndProc != pwlibWndProc)
  211.     SetWindowLong(_hWnd, GWL_WNDPROC, (DWORD)pwlibWndProc);
  212.   else
  213.     wndProc = NULL;
  215. #ifdef _WIN32
  216.   SetClassLong(_hWnd, GCL_STYLE, GetClassLong(_hWnd, GCL_STYLE)|CS_DBLCLKS);
  217. #else
  218.   SetClassWord(_hWnd, GCW_STYLE, GetClassWord(_hWnd, GCW_STYLE)|CS_DBLCLKS);
  219. #endif
  220. }
  223. void PControl::SetControlID(PRESOURCE_ID ID)
  224. {
  225.   controlID = ID;
  226.   PSET_WINDOW_VALUE(GetHWND(), ID, controlID);
  227. }
  230. void PControl::DefWndProc()
  231. {
  232.   if (wndProc == NULL)
  233.     PInteractor::DefWndProc();
  234.   else {
  235.     _msg->lResult =
  236.          CallWindowProc(wndProc, _hWnd, _msg->event, _msg->wParam, _msg->lParam);
  237.     _msg->processed = TRUE;
  238.   }
  239. }
  242. int PControl::TranslateOption(NMHDR &) const
  243. {
  244.   return -1;
  245. }
  248. //////////////////////////////////////////////////////////////////////////////
  249. // PNamedControl
  251. PNamedControl::PNamedControl(PInteractor * parent,
  252.            const PString & newName, const PNotifier & notify, void * valuePtr)
  253.   : PControl(parent, notify, valuePtr), initName(newName)
  254. {
  255. }
  258. void PNamedControl::SetName(const PString & name)
  259. {
  260.   SendMessage(GetHWND(), WM_SETREDRAW, FALSE, 0L);
  261.   SetWndText(name);
  262.   SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  263.   InvalidateRect(_hWnd, NULL, TRUE);
  264.   UpdateWindow(_hWnd);
  265. }
  268. void PNamedControl::CreateHWND()
  269. {
  270.   PControl::CreateHWND();
  271.   SetName(initName);
  272. }
  275. void PNamedControl::GetCreateWinInfo(WNDCLASS & wndClass)
  276. {
  277.   PControl::GetCreateWinInfo(wndClass);
  279.   wndClass.lpszClassName = "Button";
  280.   _styleBits |= WS_TABSTOP;
  281. }
  284. //////////////////////////////////////////////////////////////////////////////
  285. // PStaticText
  287. PStaticText::PStaticText(PInteractorLayout * parent,
  288.                 PRESOURCE_ID ctlID, const PNotifier & notify, void * valuePtr)
  289.   : PNamedControl(parent, ctlID, notify, valuePtr)
  290. {
  291.   switch (_styleBits&15) {
  292.     case SS_LEFT :
  293.     case SS_SIMPLE :
  294.     case SS_LEFTNOWORDWRAP :
  295.       alignment = PCanvas::LeftAlign;
  296.       break;
  298.     case SS_CENTER :
  299.       alignment = PCanvas::Centred;
  300.       break;
  302.     case SS_RIGHT :
  303.       alignment = PCanvas::RightAlign;
  304.       break;
  306.     default:
  307.       PAssertAlways(ControlResourceMismatch);
  308.   }
  310.   foregroundColour = parent->GetForegroundColour();
  311.   backgroundColour = parent->GetBackgroundColour();
  312. }
  315. void PStaticText::SetAlignment(int newAlign)
  316. {
  317.   if (alignment != newAlign) {
  318.     alignment = newAlign;
  319.     _styleBits &= ~15;
  320.     switch (alignment&PCanvas::HorizontalAlignmentMask) {
  321.       case PCanvas::LeftAlign :
  322.         _styleBits |= SS_LEFT;
  323.         break;
  325.       case PCanvas::Centred :
  326.         _styleBits |= SS_CENTER;
  327.         break;
  329.       case PCanvas::RightAlign :
  330.         _styleBits |= SS_RIGHT;
  331.     }
  332.     SetWindowLong(_hWnd, GWL_STYLE, _styleBits);
  333.     Invalidate();
  334.   }
  335. }
  338. void PStaticText::GetCreateWinInfo(WNDCLASS & wndClass)
  339. {
  340.   PNamedControl::GetCreateWinInfo(wndClass);
  342.   wndClass.lpszClassName = "Static";
  344.   switch (alignment&PCanvas::HorizontalAlignmentMask) {
  345.     case PCanvas::RightAlign :
  346.       _styleBits |= SS_RIGHT;
  347.       break;
  349.     case PCanvas::Centred :
  350.       _styleBits |= SS_CENTER;
  351.       break;
  353.     default :
  354.       _styleBits |= SS_LEFT;
  355.   }
  356. }
  359. void PStaticText::OnRedraw(PCanvas & canvas)
  360. {
  361.   if (canvas.NullHDC() &&
  362.               (alignment&PCanvas::VerticalAlignmentMask) == PCanvas::TopAlign)
  363.     PControl::OnRedraw(canvas);
  364.   else
  365.     canvas.DrawString(canvas.GetDrawingBounds(), GetName(), alignment);
  366. }
  369. void PStaticText::WndProc()
  370. {
  371.   if (_msg->event == WM_NCHITTEST)
  372.     _msg->lResult = HTCLIENT;
  373.   else
  374.     PNamedControl::WndProc();
  375. }
  378. //////////////////////////////////////////////////////////////////////////////
  379. // PEditBox
  381. void PEditBox::SetText(const PString & name)
  382. {
  383.   SetWndText(name);
  384.   parent->OnControlNotify(*this, EditChange);
  385. }
  388. BOOL PEditBox::GetSelection(PINDEX * start, PINDEX * finish) const
  389. {
  390.   PINDEX dummyStart;
  391.   if (start == NULL)
  392.     start = &dummyStart;
  394.   PINDEX dummyFinish;
  395.   if (finish == NULL)
  396.     finish = &dummyFinish;
  398.   SendMessage(GetHWND(), EM_GETSEL, (WPARAM)start, (LPARAM)finish);
  399.   return *finish > *start;
  400. }
  403. int PEditBox::TranslateOption(NMHDR & msg) const
  404. {
  405.   return msg.code == EN_CHANGE ? NotifyChange : -1;
  406. }
  409. void PEditBox::GetCreateWinInfo(WNDCLASS & wndClass)
  410. {
  411.   PControl::GetCreateWinInfo(wndClass);
  413.   wndClass.lpszClassName = "Edit";
  414.   _styleBits |= WS_BORDER|WS_TABSTOP|ES_AUTOHSCROLL;
  415. }
  418. //////////////////////////////////////////////////////////////////////////////
  419. // PPasswordEditBox
  421. PPasswordEditBox::PPasswordEditBox(PInteractorLayout * parent,
  422.               PRESOURCE_ID ctlID, const PNotifier & notify, PString * valuePtr)
  423.   : PEditBox(parent, ctlID, notify, valuePtr)
  424. {
  425.   PAssert((_styleBits&ES_PASSWORD) != 0, ControlResourceMismatch);
  426. }
  429. void PPasswordEditBox::GetCreateWinInfo(WNDCLASS & wndClass)
  430. {
  431.   PEditBox::GetCreateWinInfo(wndClass);
  432.   _styleBits |= ES_PASSWORD;
  433. }
  436. //////////////////////////////////////////////////////////////////////////////
  437. // PMultiLineEditBox
  439. PMultiLineEditBox::PMultiLineEditBox(PInteractorLayout * parent,
  440.               PRESOURCE_ID ctlID, const PNotifier & notify, PString * valuePtr)
  441.   : PEditBox(parent, ctlID, notify, valuePtr)
  442. {
  443.   PAssert((_styleBits&ES_MULTILINE) != 0, ControlResourceMismatch);
  444. }
  447. void PMultiLineEditBox::GetCreateWinInfo(WNDCLASS & wndClass)
  448. {
  449.   PEditBox::GetCreateWinInfo(wndClass);
  450.   _styleBits |= WS_VSCROLL|WS_HSCROLL|ES_AUTOVSCROLL|ES_MULTILINE|ES_WANTRETURN;
  451. }
  454. void PMultiLineEditBox::_SetDimensions(PDIMENSION width, PDIMENSION height,
  455.                                  CoordinateSystem coords)
  456. {
  457.   GetHWND();
  459.   if (coords == LocalCoords) {
  460.     width = ToPixelsDX(width);
  461.     height = ToPixelsDY(height);
  462.   }
  464.   SetWindowPos(_hWnd, NULL, 0, 0, width, height, SWP_NOMOVE|SWP_NOZORDER);
  465. }
  468. //////////////////////////////////////////////////////////////////////////////
  469. // PIntegerEditBox
  471. PIntegerEditBox::PIntegerEditBox(PInteractorLayout * parent,
  472.                  PRESOURCE_ID ctlID, const PNotifier & notify, long * valuePtr)
  473.   : PNumberEditBox(parent, ctlID, notify, valuePtr)
  474. {
  475.   PStringArray limits = GetWndText().Tokenise(" ");
  476.   SetWndText("");
  477.   PAssert(limits.GetSize() > 1 && limits[0] == "INTEDITBOX", ControlResourceMismatch);
  478.   minimum = limits.GetSize() < 2 ? LONG_MIN : limits[1].AsInteger();
  479.   maximum = limits.GetSize() < 3 ? LONG_MAX : limits[2].AsInteger();
  480.   nudge   = limits.GetSize() < 4 ? 1 : limits[3].AsInteger();
  481.   base    = (BYTE)(limits.GetSize() < 5 ? 1 : limits[4].AsInteger());
  482.   PAssert(base >= 2 && base <= 36, PInvalidParameter);
  483. }
  486. //////////////////////////////////////////////////////////////////////////////
  487. // PFloatEditBox
  489. PFloatEditBox::PFloatEditBox(PInteractorLayout * parent,
  490.                PRESOURCE_ID ctlID, const PNotifier & notify, double * valuePtr)
  491.   : PNumberEditBox(parent, ctlID, notify, valuePtr)
  492. {
  493.   PStringArray limits = GetWndText().Tokenise(" ");
  494.   SetWndText("");
  495.   PAssert(limits.GetSize() > 1 && limits[0] == "FLOATEDITBOX", ControlResourceMismatch);
  496.   minimum  = limits.GetSize() < 2 ? -HUGE_VAL : limits[1].AsReal();
  497.   maximum  = limits.GetSize() < 3 ?  HUGE_VAL : limits[2].AsReal();
  498.   nudge    = limits.GetSize() < 4 ? 1 : limits[3].AsReal();
  499.   decimals = limits.GetSize() < 5 ? 1 : (int)limits[4].AsInteger();
  500. }
  503. //////////////////////////////////////////////////////////////////////////////
  504. // PPushButton
  506. PPushButton::PPushButton(PInteractorLayout * parent,
  507.                 PRESOURCE_ID ctlID, const PNotifier & notify, void * valuePtr)
  508.   : PNamedControl(parent, ctlID, notify, valuePtr)
  509. {
  510.   DWORD style = _styleBits&15;
  511.   PAssert(style == BS_DEFPUSHBUTTON || style == BS_PUSHBUTTON,
  512.                                                      ControlResourceMismatch);
  513.   defaultButton = style == BS_DEFPUSHBUTTON;
  515.   foregroundColour.FromSYSCOLOR(COLOR_BTNTEXT);
  516.   backgroundColour.FromSYSCOLOR(COLOR_BTNFACE);
  517. }
  520. void PPushButton::GetCreateWinInfo(WNDCLASS & wndClass)
  521. {
  522.   PNamedControl::GetCreateWinInfo(wndClass);
  524.   if (defaultButton)
  525.     _styleBits |= BS_DEFPUSHBUTTON;
  526.   else
  527.     _styleBits |= BS_PUSHBUTTON;
  529.   if (!IsClass(PTextButton::Class()))
  530.     _styleBits |= BS_OWNERDRAW;
  532.   foregroundColour.FromSYSCOLOR(COLOR_BTNTEXT);
  533.   backgroundColour.FromSYSCOLOR(COLOR_BTNFACE);
  534. }
  537. int PPushButton::TranslateOption(NMHDR & msg) const
  538. {
  539.   return msg.code == BN_CLICKED ? NotifyChange : -1;
  540. }
  543. //////////////////////////////////////////////////////////////////////////////
  544. // PTextButton
  546. void PTextButton::DefaultDimensions()
  547. {
  548.   PDrawCanvas canvas(this);
  549.   PString name = GetName();
  550.   PDim dim(16, 8);
  551.   if (!name.IsEmpty()) {
  552.     dim = canvas.MeasureString(name);
  553.     // 2 average character width either side of the button text and half a
  554.     // character height above and below
  555.     dim += PDim(16, dim.Height());
  556.     if (dim.Width() < dim.Height()*3)
  557.       dim.SetWidth(dim.Height()*3);
  558.   }
  559.   SetDimensions(dim, LocalCoords);
  560. }
  563. //////////////////////////////////////////////////////////////////////////////
  564. // PImageButton
  566. void PImageButton::Construct()
  567. {
  568.   _in_WM_PAINT = TRUE; // Prevent calling OnRedraw in the normal WM_PAINT
  569. }
  572. //////////////////////////////////////////////////////////////////////////////
  573. // PCheck3WayBox
  575. PCheck3WayBox::PCheck3WayBox(PInteractorLayout * parent,
  576.           PRESOURCE_ID ctlID, const PNotifier & notify, CheckValues * valuePtr)
  577.   : PNamedControl(parent, ctlID, notify, valuePtr)
  578. {
  579.   DWORD style = _styleBits&15;
  580.   PAssert(style == BS_AUTO3STATE || style == BS_AUTOCHECKBOX,
  581.                                                      ControlResourceMismatch);
  582.   Construct();
  583. }
  586. void PCheck3WayBox::Construct()
  587. {
  588.   foregroundColour = parent->GetForegroundColour();
  589.   backgroundColour = parent->GetBackgroundColour();
  590. }
  593. void PCheck3WayBox::GetCreateWinInfo(WNDCLASS & wndClass)
  594. {
  595.   PNamedControl::GetCreateWinInfo(wndClass);
  596.   _styleBits |= BS_AUTO3STATE;
  597. }
  600. int PCheck3WayBox::TranslateOption(NMHDR & msg) const
  601. {
  602.   return msg.code == BN_CLICKED ? NotifyChange : -1;
  603. }
  606. //////////////////////////////////////////////////////////////////////////////
  607. // PCheckBox
  609. PCheckBox::PCheckBox(PInteractorLayout * parent,
  610.                  PRESOURCE_ID ctlID, const PNotifier & notify, BOOL * valuePtr)
  611.   : PCheck3WayBox(parent, ctlID, notify, (CheckValues *)valuePtr)
  612. {
  613.   PAssert((_styleBits&15) == BS_AUTOCHECKBOX, ControlResourceMismatch);
  614. }
  617. void PCheckBox::GetCreateWinInfo(WNDCLASS & wndClass)
  618. {
  619.   PCheck3WayBox::GetCreateWinInfo(wndClass);
  620.   _styleBits &= 0xfffffff0;
  621.   _styleBits |= BS_AUTOCHECKBOX;
  622. }
  625. //////////////////////////////////////////////////////////////////////////////
  626. // PRadioButton
  628. PRadioButton::PRadioButton(PInteractorLayout * parent,
  629.                PRESOURCE_ID ctlID, const PNotifier & notify, PINDEX * valuePtr)
  630.   : PNamedControl(parent, ctlID, notify, valuePtr)
  631. {
  632.   PAssert((_styleBits&15) == BS_RADIOBUTTON, ControlResourceMismatch);
  633.   group.DisallowDeleteObjects();
  634.   group.Append(this);
  635.   Construct();
  636. }
  639. void PRadioButton::Construct()
  640. {
  641.   foregroundColour = parent->GetForegroundColour();
  642.   backgroundColour = parent->GetBackgroundColour();
  643. }
  646. PINDEX PRadioButton::GetValue() const
  647. {
  648.   for (PINDEX i = 0; i < group.GetSize(); i++) {
  649.     if (SendMessage(group[i].GetHWND(), BM_GETCHECK, 0, 0L) != 0)
  650.       return i+1;
  651.   }
  652.   return 0;
  653. }
  656. void PRadioButton::SetValue(PINDEX newVal)
  657. {
  658.   for (PINDEX i = 0; i < group.GetSize(); i++)
  659.     SendMessage(group[i].GetHWND(), BM_SETCHECK, newVal == i+1, 0L);
  660. }
  663. void PRadioButton::GetCreateWinInfo(WNDCLASS & wndClass)
  664. {
  665.   PNamedControl::GetCreateWinInfo(wndClass);
  666.   _styleBits |= BS_RADIOBUTTON;
  667. }
  670. int PRadioButton::TranslateOption(NMHDR & msg) const
  671. {
  672.   if (msg.code != BN_CLICKED)
  673.     return -1;
  675.   for (PINDEX i = 0; i < group.GetSize(); i++) {
  676.     PRadioButton & btn = group[i];
  677.     SendMessage(btn.GetHWND(), BM_SETCHECK, &btn == this, 0L);
  678.   }
  680.   return NotifyChange;
  681. }
  684. //////////////////////////////////////////////////////////////////////////////
  685. // PStaticIcon
  687. PStaticIcon::PStaticIcon(PInteractorLayout * parent,
  688.                 PRESOURCE_ID ctlID, const PNotifier & notify, void * valuePtr)
  689.   : PControl(parent, ctlID, notify, valuePtr),
  690. #if defined(_WIN32)
  691.     icon((HICON)NULL)
  692. #else
  693.     icon((HICON)GetWindowWord(_hWnd, 4))
  694. #endif
  695. {
  696.   PAssert((_styleBits&15) == SS_ICON, ControlResourceMismatch);
  698.   foregroundColour = parent->GetForegroundColour();
  699.   backgroundColour = parent->GetBackgroundColour();
  700. }
  703. void PStaticIcon::SetIcon(const PIcon & icn)
  704. {
  705.   HICON oldIcon = (HICON)
  706. #if defined(_WIN32)
  707.                 SendMessage(GetHWND(), STM_SETICON, (WPARAM)icn.GetHICON(), 0);
  708. #else
  709.                 SetWindowWord(GetHWND(), 4, (WORD)icn.GetHICON());
  710. #endif
  712.   if (oldIcon!=NULL && oldIcon!=icon.GetHICON() && oldIcon!=icn.GetHICON())
  713.     DestroyIcon(oldIcon);
  715.   icon = icn;
  716. }
  719. void PStaticIcon::GetCreateWinInfo(WNDCLASS & wndClass)
  720. {
  721.   PControl::GetCreateWinInfo(wndClass);
  723.   wndClass.lpszClassName = "Static";
  724.   _styleBits |= SS_ICON;
  725. }
  728. #if defined(_WIN32)
  729. void PStaticIcon::WndProc()
  730. {
  731.   PControl::WndProc();
  732.   if (_msg->event == WM_CREATE && icon.GetHICON() == NULL)
  733.     icon = PIcon((HICON)SendMessage(_hWnd, STM_GETICON, 0, 0));
  734. }
  735. #endif
  738. //////////////////////////////////////////////////////////////////////////////
  739. // PStaticBox
  741. PStaticBox::PStaticBox(PInteractorLayout * parent,
  742.                 PRESOURCE_ID ctlID, const PNotifier & notify, void * valuePtr)
  743.   : PNamedControl(parent, ctlID, notify, valuePtr)
  744. {
  745.   PAssert((_styleBits&15) == BS_GROUPBOX, ControlResourceMismatch);
  746.   foregroundColour = parent->GetForegroundColour();
  747.   backgroundColour = parent->GetBackgroundColour();
  748. }
  751. void PStaticBox::GetCreateWinInfo(WNDCLASS & wndClass)
  752. {
  753.   PNamedControl::GetCreateWinInfo(wndClass);
  754.   _styleBits |= BS_GROUPBOX;
  755. }
  758. //////////////////////////////////////////////////////////////////////////////
  759. // PStaticRect
  761. void PStaticRect::GetCreateWinInfo(WNDCLASS & wndClass)
  762. {
  763.   PControl::GetCreateWinInfo(wndClass);
  764.   wndClass.lpszClassName = "Static";
  765.   _styleBits |= SS_LEFT;
  766. }
  769. //////////////////////////////////////////////////////////////////////////////
  770. // PChoiceBox
  772. PChoiceBox::PChoiceBox(PInteractorLayout * parent,
  773.                PRESOURCE_ID ctlID, const PNotifier & notify, PINDEX * valuePtr)
  774.   : PControl(parent, ctlID, notify, valuePtr)
  775. {
  776.   sort  = (_styleBits&CBS_SORT) != 0;
  777.   PAssert((_styleBits&CBS_DROPDOWNLIST) != 0, ControlResourceMismatch);
  778. }
  781. void PChoiceBox::GetCreateWinInfo(WNDCLASS & wndClass)
  782. {
  783.   PControl::GetCreateWinInfo(wndClass);
  785.   wndClass.lpszClassName = "ComboBox";
  786.   if (sort)
  787.     _styleBits |= CBS_SORT;
  788.   _styleBits |= WS_BORDER|CBS_DROPDOWNLIST|WS_VSCROLL;
  789. }
  792. int PChoiceBox::TranslateOption(NMHDR & msg) const
  793. {
  794.   switch (msg.code) {
  795.     case CBN_SELCHANGE :
  796.       return NewSelection;
  797.     case CBN_DROPDOWN :
  798.       return ListDropped;
  799.     case CBN_CLOSEUP :
  800.       return ListClosed;
  801.   }
  802.   return -1;
  803. }
  806. //////////////////////////////////////////////////////////////////////////////
  807. // PListBox
  809. PListBox::PListBox(PInteractorLayout * parent,
  810.                PRESOURCE_ID ctlID, const PNotifier & notify, PINDEX * valuePtr)
  811.   : PControl(parent, ctlID, notify, valuePtr)
  812. {
  813.   sort  = (_styleBits&LBS_SORT) != 0;
  814.   multi = (_styleBits&LBS_EXTENDEDSEL) != 0;
  815.   width = (PDIMENSION)((_styleBits&LBS_MULTICOLUMN) != 0 ? 20 : 0);
  816.   PAssert((_styleBits&LBS_NOTIFY) != 0, ControlResourceMismatch);
  817. }
  820. void PListBox::Construct()
  821. {
  822.   if (width != 0 && _hWnd != NULL)
  823.     SetColumnWidth(width, FALSE);
  824. }
  827. void PListBox::DeleteEntry(PINDEX index, BOOL update)
  828. {
  829.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  831.   BOOL doNotify = GetSelection() == index;
  833.   SendMessage(_hWnd, LB_DELETESTRING, index, 0L);
  835.   if (!update)
  836.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  838.   if (doNotify)
  839.     parent->OnControlNotify(*this, NewSelection);
  840. }
  843. void PListBox::DeleteAllEntries(BOOL update)
  844. {
  845.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  847.   BOOL doNotify = GetSelection() != P_MAX_INDEX;
  849.   SendMessage(_hWnd, LB_RESETCONTENT, 0, 0L);
  851.   if (!update)
  852.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  854.   if (doNotify)
  855.     parent->OnControlNotify(*this, NewSelection);
  856. }
  859. void PListBox::SetColumnWidth(PDIMENSION newWidth, BOOL update)
  860. {
  861.   PAssert(width != 0 && newWidth != 0, PInvalidParameter);
  862.   width = newWidth;
  864.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  866.   SendMessage(_hWnd, LB_SETCOLUMNWIDTH, newWidth, 0L);
  868.   if (!update)
  869.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  870. }
  873. void PListBox::SetTopIndex(PINDEX index, BOOL update)
  874. {
  875.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  877.   SendMessage(_hWnd, LB_SETTOPINDEX, index, 0L);
  879.   if (!update)
  880.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  881. }
  884. PINDEX PListBox::GetSelection() const
  885. {
  886.   long retVal = SendMessage(GetHWND(), LB_GETCURSEL, 0, 0L);
  887.   return retVal != LB_ERR ? (PINDEX)retVal : P_MAX_INDEX;
  888. }
  891. void PListBox::SetSelection(PINDEX index)
  892. {
  893.   if (GetSelection() != index) {
  894.     SendMessage(GetHWND(), LB_SETCURSEL, index, 0L);
  895.     parent->OnControlNotify(*this, NewSelection);
  896.   }
  897. }
  900. void PListBox::Select(PINDEX index, BOOL update, BOOL sel)
  901. {
  902.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  904.   SendMessage(_hWnd, LB_SETSEL, sel, MAKELPARAM(index, 0));
  906.   if (!update)
  907.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  909.   parent->OnControlNotify(*this, NewSelection);
  910. }
  913. void PListBox::GetCreateWinInfo(WNDCLASS & wndClass)
  914. {
  915.   PControl::GetCreateWinInfo(wndClass);
  917.   wndClass.lpszClassName = "ListBox";
  919.   if (sort)
  920.     _styleBits |= LBS_SORT;
  922.   if (multi)
  923.     _styleBits |= LBS_EXTENDEDSEL;
  925.   if (width != 0)
  926.     _styleBits |= LBS_MULTICOLUMN|WS_HSCROLL;
  927.   else
  928.     _styleBits |= WS_VSCROLL;
  930.   _styleBits |= WS_BORDER|LBS_NOINTEGRALHEIGHT|LBS_NOTIFY|LBS_DISABLENOSCROLL;
  931. }
  934. int PListBox::TranslateOption(NMHDR & msg) const
  935. {
  936.   switch (msg.code) {
  937.     case LBN_SELCHANGE :
  938.       return NewSelection;
  939.     case LBN_DBLCLK :
  940.       return DoubleClick;
  941.   }
  942.   return -1;
  943. }
  946. void PListBox::CreateHWND()
  947. {
  948.   PControl::CreateHWND();
  949.   if (width != 0)
  950.     SetColumnWidth(width, FALSE);
  951. }
  954. void PListBox::WndProc()
  955. {
  956.   if (_msg->event == WM_DESTROY && deleteObjects && IsDescendant(PCustomListBox::Class())) {
  957.     for (PINDEX i = 0; i < GetCount(); i++) {
  958.       LPARAM itemData = SendMessage(GetHWND(), LB_GETITEMDATA, i, 0L);
  959.       if (itemData != LB_ERR)
  960.         delete (PObject *)itemData;
  961.     }
  962.   }
  963.   PControl::WndProc();
  964. }
  967. BOOL PListBox::AdjustDimensionForScrollBar(UINT) const
  968. {
  969.   return FALSE;
  970. }
  973. //////////////////////////////////////////////////////////////////////////////
  974. // PStringListBox
  976. PINDEX PStringListBox::AddString(const PString & str, BOOL update)
  977. {
  978.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  980.   PINDEX retval = (PINDEX)SendMessage(_hWnd, LB_ADDSTRING, 0, (DWORD)(const char *)str);
  982.   if (!update)
  983.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  985.   return retval;
  986. }
  989. void PStringListBox::InsertString(const PString & str, PINDEX index, BOOL update)
  990. {
  991.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  993.   SendMessage(_hWnd, LB_INSERTSTRING, index, (DWORD)(const char *)str);
  995.   if (!update)
  996.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  997. }
  1000. void PStringListBox::DeleteString(PINDEX index, BOOL update)
  1001. {
  1002.   DeleteEntry(index, update);
  1003. }
  1006. PINDEX PStringListBox::FindString(const PString & str, PINDEX startIndex, BOOL exact) const
  1007. {
  1008.   if (startIndex == P_MAX_INDEX)
  1009.     startIndex = -1;
  1010.   long retVal = SendMessage(GetHWND(),
  1011.                       exact ? LB_FINDSTRINGEXACT : LB_FINDSTRING, startIndex,
  1012.                       (DWORD)(const char *)str);
  1013.   return retVal != LB_ERR ? (PINDEX)retVal : P_MAX_INDEX;
  1014. }
  1017. PString PStringListBox::GetString(PINDEX index) const
  1018. {
  1019.   PString str;
  1021.   long len = SendMessage(GetHWND(), LB_GETTEXTLEN, index, 0);
  1022.   if (len != LB_ERR)
  1023.     SendMessage(GetHWND(), LB_GETTEXT, index, (DWORD)str.GetPointer(len+1));
  1025.   return str;
  1026. }
  1029. void PStringListBox::SetTabStops(PDIMENSION tab)
  1030. {
  1031.   tabStops.SetSize(1);
  1032.   tabStops[0] = tab;
  1033.   SendMessage(GetHWND(), LB_SETTABSTOPS, 1, (LPARAM)&tab);
  1034. }
  1037. void PStringListBox::SetTabStops(const PORDINATE * tabs, PINDEX count)
  1038. {
  1039.   PAssert(count > 0, PInvalidParameter);
  1040.   memcpy(tabStops.GetPointer(count), tabs, count*sizeof(int));
  1041.   SendMessage(GetHWND(), LB_SETTABSTOPS, count, (LPARAM)tabs);
  1042. }
  1045. void PStringListBox::SetTabStops(const PIntArray & tabs)
  1046. {
  1047.   PAssert(tabs.GetSize() > 0, PInvalidParameter);
  1048.   SendMessage(GetHWND(), LB_SETTABSTOPS,
  1049.               tabs.GetSize(), (LPARAM)(const int *)tabs);
  1050. }
  1053. void PStringListBox::GetCreateWinInfo(WNDCLASS & wndClass)
  1054. {
  1055.   PListBox::GetCreateWinInfo(wndClass);
  1056.   _styleBits |= LBS_USETABSTOPS;
  1057. }
  1060. //////////////////////////////////////////////////////////////////////////////
  1061. // PCustomListBox
  1063. PINDEX PCustomListBox::AddEntry(PObject * obj, BOOL update)
  1064. {
  1065.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  1067.   PINDEX retval = (PINDEX)SendMessage(_hWnd, LB_ADDSTRING, 0, (DWORD)obj);
  1069.   if (!update)
  1070.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  1072.   return retval;
  1073. }
  1076. void PCustomListBox::InsertEntry(PObject * obj, PINDEX index, BOOL update)
  1077. {
  1078.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  1080.   SendMessage(_hWnd, LB_INSERTSTRING, index, (DWORD)obj);
  1082.   if (!update)
  1083.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  1084. }
  1087. PINDEX PCustomListBox::FindEntry(const PObject & obj, PINDEX startIndex) const
  1088. {
  1089.   if (startIndex == P_MAX_INDEX)
  1090.     startIndex = -1;
  1092.   long retVal = SendMessage(_hWnd,
  1093.           LB_FINDSTRINGEXACT, startIndex, (DWORD)(const char *)(PString &)obj);
  1095.   return retVal != LB_ERR ? (PINDEX)retVal : P_MAX_INDEX;
  1096. }
  1099. void PCustomListBox::SetEntry(PObject * obj, PINDEX index, BOOL update)
  1100. {
  1101.   SendMessage(GetHWND(), WM_SETREDRAW, update, 0L);
  1103.   BOOL doNotify = GetSelection() == index;
  1105.   SendMessage(_hWnd, LB_SETITEMDATA, index, (DWORD)obj);
  1107.   if (!update)
  1108.     SendMessage(_hWnd, WM_SETREDRAW, TRUE, 0L);
  1110.   if (doNotify)
  1111.     parent->OnControlNotify(*this, NewSelection);
  1112. }
  1115. const PObject * PCustomListBox::GetEntry(PINDEX index) const
  1116. {
  1117.   long retVal = SendMessage(GetHWND(), LB_GETITEMDATA, index, 0L);
  1118.   return retVal != LB_ERR ? (const PObject *)retVal : NULL;
  1119. }
  1122. void PCustomListBox::GetCreateWinInfo(WNDCLASS & wndClass)
  1123. {
  1124.   PListBox::GetCreateWinInfo(wndClass);
  1125.   _styleBits |= LBS_OWNERDRAWVARIABLE;
  1126. }
  1129. //////////////////////////////////////////////////////////////////////////////
  1130. // PComboBox
  1132. PComboBox::PComboBox(PInteractorLayout * parent,
  1133.               PRESOURCE_ID ctlID, const PNotifier & notify, PString * valuePtr)
  1134.   : PControl(parent, ctlID, notify, valuePtr)
  1135. {
  1136.   sort  = (_styleBits&CBS_SORT) != 0;
  1137.   PAssert((_styleBits&CBS_DROPDOWN) != 0, ControlResourceMismatch);
  1138. }
  1141. PINDEX PComboBox::GetCurrent() const
  1142. {
  1143.   long retVal = SendMessage(GetHWND(), CB_GETCURSEL, 0, 0L);
  1144.   return retVal != CB_ERR ? (PINDEX)retVal : P_MAX_INDEX;
  1145. }
  1148. void PComboBox::GetCreateWinInfo(WNDCLASS & wndClass)
  1149. {
  1150.   PControl::GetCreateWinInfo(wndClass);
  1152.   wndClass.lpszClassName = "ComboBox";
  1154.   if (sort != 0)
  1155.     _styleBits |= CBS_SORT;
  1156.   _styleBits |= CBS_DROPDOWN|CBS_AUTOHSCROLL|WS_VSCROLL;
  1157. }
  1160. int PComboBox::TranslateOption(NMHDR & msg) const
  1161. {
  1162.   switch (msg.code) {
  1163.     case CBN_SELCHANGE :
  1164.       return NewSelection;
  1165.     case CBN_DROPDOWN :
  1166.       return ListDropped;
  1167.     case CBN_CLOSEUP :
  1168.       return ListClosed;
  1169.     case CBN_EDITCHANGE :
  1170.      return EditChange;
  1171.   }
  1172.   return -1;
  1173. }
  1176. BOOL PComboBox::OnEndInput()
  1177. {
  1178.   parent->OnControlNotify(*this, PEditBox::EndEdit);
  1179.   return TRUE;
  1180. }
  1183. //////////////////////////////////////////////////////////////////////////////
  1184. // PScrollBar
  1186. PScrollBar::PScrollBar(PInteractorLayout * parent, PRESOURCE_ID ctlID,
  1187.                          const PNotifier & notify, PSCROLLBAR_VALUE * valuePtr)
  1188.   : PControl(parent, ctlID, notify, valuePtr)
  1189. {
  1190.   PStringArray limits = GetWndText().Tokenise(" ");
  1192.   value = minimum = 0;
  1193.   maximum = 100;
  1194.   smallNudge = 1;
  1195.   largeNudge = 10;
  1197.   switch (limits.GetSize()) {
  1198.     case 4 :
  1199.       largeNudge = (PSCROLLBAR_VALUE)limits[3].AsInteger();
  1200.     case 3 :
  1201.       smallNudge = (PSCROLLBAR_VALUE)limits[2].AsInteger();
  1202.     case 2 :
  1203.       maximum = (PSCROLLBAR_VALUE)limits[1].AsInteger();
  1204.     case 1 :
  1205.       value = minimum = (PSCROLLBAR_VALUE)limits[0].AsInteger();
  1206.   }
  1208.   SetScrollRange(_hWnd, SB_CTL, minimum, maximum, FALSE);
  1209.   SetScrollPos(_hWnd, SB_CTL, value, FALSE);
  1211.   tracking = FALSE;
  1213.   foregroundColour = owner->GetScrollBarColour();
  1214.   backgroundColour = owner->GetScrollBarColour();
  1215. }
  1218. void PScrollBar::SetMaximum(PSCROLLBAR_VALUE val, BOOL redraw)
  1219. {
  1220.   maximum = val;
  1221.   if (minimum > maximum)
  1222.     minimum = maximum;
  1223.   SetScrollRange(GetHWND(), SB_CTL, minimum, maximum, redraw);
  1224.   SetValue(value);
  1225. }
  1228. void PScrollBar::SetMinimum(PSCROLLBAR_VALUE val, BOOL redraw)
  1229. {
  1230.   minimum = val;
  1231.   if (maximum < minimum)
  1232.     maximum = minimum;
  1233.   SetScrollRange(GetHWND(), SB_CTL, minimum, maximum, redraw);
  1234.   SetValue(value);
  1235. }
  1238. void PScrollBar::SetValue(PSCROLLBAR_VALUE val, BOOL redraw)
  1239. {
  1240.   SetScrollPos(GetHWND(), SB_CTL, val, redraw);
  1241.   PSCROLLBAR_VALUE newValue = (PSCROLLBAR_VALUE)GetScrollPos(_hWnd, SB_CTL);
  1242.   if (value != newValue) {
  1243.     parent->OnControlNotify(*this, StartTrack);
  1244.     value = newValue;
  1245.     parent->OnControlNotify(*this, EndTrack);
  1246.   }
  1247. }
  1250. int PScrollBar::TrackScrollBar(WPARAM code, int trackVal)
  1251. {
  1252.   int newVal = value;
  1253.   switch (code) {
  1254.     case SB_LINEUP :
  1255.       newVal -= smallNudge;
  1256.       break;
  1258.     case SB_LINEDOWN :
  1259.       newVal += smallNudge;
  1260.       break;
  1262.     case SB_PAGEUP :
  1263.       newVal -= largeNudge;
  1264.       break;
  1266.     case SB_PAGEDOWN :
  1267.       newVal += largeNudge;
  1268.       break;
  1270.     case SB_TOP :
  1271.       newVal = minimum;
  1272.       break;
  1274.     case SB_BOTTOM :
  1275.       newVal = maximum;
  1276.       break;
  1278.     case SB_THUMBTRACK :
  1279.     case SB_THUMBPOSITION :
  1280.       newVal = trackVal;
  1281.   }
  1282.   SetScrollPos(_hWnd, SB_CTL, newVal, TRUE);
  1283.   value = (PSCROLLBAR_VALUE)GetScrollPos(_hWnd, SB_CTL);
  1285.   if (tracking) {
  1286.     if (code != SB_ENDSCROLL)
  1287.       return Tracking;
  1288.     tracking = FALSE;
  1289.     return EndTrack;
  1290.   }
  1292.   tracking = TRUE;
  1293.   return StartTrack;
  1294. }
  1297. void PScrollBar::CreateHWND()
  1298. {
  1299.   PControl::CreateHWND();
  1301.   SetScrollRange(_hWnd, SB_CTL, minimum, maximum, FALSE);
  1302.   SetScrollPos(_hWnd, SB_CTL, value, TRUE);
  1304.   foregroundColour = owner->GetScrollBarColour();
  1305.   backgroundColour = owner->GetScrollBarColour();
  1306. }
  1309. void PScrollBar::GetCreateWinInfo(WNDCLASS & wndClass)
  1310. {
  1311.   PControl::GetCreateWinInfo(wndClass);
  1313.   wndClass.lpszClassName = "ScrollBar";
  1314.   _styleBits |= WS_TABSTOP;
  1315. }
  1318. PVerticalScrollBar::PVerticalScrollBar(PInteractorLayout * parent,
  1319.      PRESOURCE_ID ctlID, const PNotifier & notify, PSCROLLBAR_VALUE * valuePtr)
  1320.   : PScrollBar(parent, ctlID, notify, valuePtr)
  1321. {
  1322.   PAssert((_styleBits&1)!=0, ControlResourceMismatch);
  1323. }
  1326. void PVerticalScrollBar::GetCreateWinInfo(WNDCLASS & wndClass)
  1327. {
  1328.   PScrollBar::GetCreateWinInfo(wndClass);
  1329.   _styleBits |= SBS_VERT;
  1330. }
  1333. PHorizontalScrollBar::PHorizontalScrollBar(PInteractorLayout * parent,
  1334.      PRESOURCE_ID ctlID, const PNotifier & notify, PSCROLLBAR_VALUE * valuePtr)
  1335.   : PScrollBar(parent, ctlID, notify, valuePtr)
  1336. {
  1337.   PAssert((_styleBits&1)==0,ControlResourceMismatch);
  1338. }
  1341. void PHorizontalScrollBar::GetCreateWinInfo(WNDCLASS & wndClass)
  1342. {
  1343.   PScrollBar::GetCreateWinInfo(wndClass);
  1344.   _styleBits |= SBS_HORZ;
  1345. }
  1348. // End Of File ///////////////////////////////////////////////////////////////