OS/2 Shareware BBS: 10 Tools/10-Tools.zip/pgehdl.zip/pagehdl

Text File | 1996-02-27 | 319KB | 10,084 lines

# makefile
# Created by IBM WorkFrame/2 MakeMake at 12:38:33 on 2 Feb 1996
#
# The actions included in this make file are:
#  Compile::C++ Compiler
#  Link::Linker
#  Bind::Resource Bind
#  Compile::Resource Precompile
#  Compile::Resource Compiler

.SUFFIXES: .cpp .obj .rc .rcx .res

.all: \
    .\target.exe

.cpp.obj:
    @echo " Compile::C++ Compiler "
    icc.exe -DIC_TRACE_DEVELOP /Ti /Gm /Gd /C %s

.rcx.rc:
    @echo " Compile::Resource Precompile "
    icc.exe -c /Pc+ /Pe+ /Pd /I. %s > %|dpfF.rc

.rc.res:
    @echo " Compile::Resource Compiler "
    rc.exe -r %s .\%|fF.RES

.\target.exe: \
    .\test.obj \
    .\vbmain.obj \
    .\PgHndler.obj \
    .\test.res
    @echo " Link::Linker "
    @echo " Bind::Resource Bind "
    icc.exe @<<
    -DIC_TRACE_DEVELOP
     /Tdp
     /Gm /Gd
     /B" /de /st:64000 /pmtype:pm"
     /Fetarget.exe
     .\test.obj
     .\vbmain.obj
     .\PgHndler.obj
<<
    rc.exe .\test.res target.exe

.\test.obj: \
    F:\toydev\pagehdl\test.cpp \
    {F:\toydev\pagehdl;$(INCLUDE);}test.hpp \
    {F:\toydev\pagehdl;$(INCLUDE);}test.h \
    {F:\toydev\pagehdl;$(INCLUDE);}PgHndler.hpp \
    {F:\toydev\pagehdl;$(INCLUDE);}PgHndler.h \
    {F:\toydev\pagehdl;$(INCLUDE);}PgHndler.hpv

.\PgHndler.obj: \
    F:\toydev\pagehdl\PgHndler.cpp \
    {F:\toydev\pagehdl;$(INCLUDE);}PgHndler.hpp \
    {F:\toydev\pagehdl;$(INCLUDE);}PgHndler.cpv \
    {F:\toydev\pagehdl;$(INCLUDE);}PgHndler.h \
    {F:\toydev\pagehdl;$(INCLUDE);}PgHndler.hpv

.\vbmain.obj: \
    F:\toydev\pagehdl\vbmain.cpp \
    {F:\toydev\pagehdl;$(INCLUDE);}test.hpp \
    {F:\toydev\pagehdl;$(INCLUDE);}test.h

.\test.rc: \
    F:\toydev\pagehdl\test.rcx \
    {$(INCLUDE)}test.rci

.\test.res: \
    .\test.rc
:TARGET.SUFFIXES
:DEPENDENCY..cpp .obj .rc .rcx .res
:TARGET.all
:DEPENDENCY.
.\target.exe
:RULE..cpp.obj
:ACTION.Compile::C++ Compiler
:COMMAND.
icc.exe -DIC_TRACE_DEVELOP /Ti /Gm /Gd /C %s
:RULE..rcx.rc
:ACTION.Compile::Resource Precompile
:COMMAND.
icc.exe -c /Pc+ /Pe+ /Pd /I. %s > %|dpfF.rc
:RULE..rc.res
:ACTION.Compile::Resource Compiler
:COMMAND.
rc.exe -r %s .\%|fF.RES
:TARGET..\target.exe
:DEPENDENCY.
.\test.obj
.\vbmain.obj
.\PgHndler.obj
.\test.res
:ACTION.Link::Linker
:COMMAND.
icc.exe @<<
-DIC_TRACE_DEVELOP
 /Tdp
 /Gm /Gd
 /B" /de /st:64000 /pmtype:pm"
 /Fetarget.exe
 .\test.obj
 .\vbmain.obj
 .\PgHndler.obj
<<
:ACTION.Bind::Resource Bind
:COMMAND.
rc.exe .\test.res target.exe
:TARGET..\test.obj
:DEPENDENCY.
F:\toydev\pagehdl\test.cpp
{F:\toydev\pagehdl;$(INCLUDE);}test.hpp
{F:\toydev\pagehdl;$(INCLUDE);}test.h
{F:\toydev\pagehdl;$(INCLUDE);}PgHndler.hpp
{F:\toydev\pagehdl;$(INCLUDE);}PgHndler.h
{F:\toydev\pagehdl;$(INCLUDE);}PgHndler.hpv
:TARGET..\PgHndler.obj
:DEPENDENCY.
F:\toydev\pagehdl\PgHndler.cpp
{F:\toydev\pagehdl;$(INCLUDE);}PgHndler.hpp
{F:\toydev\pagehdl;$(INCLUDE);}PgHndler.cpv
{F:\toydev\pagehdl;$(INCLUDE);}PgHndler.h
{F:\toydev\pagehdl;$(INCLUDE);}PgHndler.hpv
:TARGET..\vbmain.obj
:DEPENDENCY.
F:\toydev\pagehdl\vbmain.cpp
{F:\toydev\pagehdl;$(INCLUDE);}test.hpp
{F:\toydev\pagehdl;$(INCLUDE);}test.h
:TARGET..\test.rc
:DEPENDENCY.
F:\toydev\pagehdl\test.rcx
{$(INCLUDE)}test.rci
:TARGET..\test.res
:DEPENDENCY.
.\test.rc
<áP0



AvlFileHeaderfileType version êbinary
⌐.
V╧ÇΘ
<áP
╚

*

PK
╥dB k]ëkmakefile
#67hëÜ█<D┼÷û≈GélvmY│i┘ûm¿`yò[6,▌▓dAè═2⌐╨ª »╛ò╗╓¿▄░m╦╛ö    ▓ë∙OαdLÖ:gΓ▐3A╛u"{-+&zτ╠i╪å%U4π?ûnÜφ=dZ╖c┘╓%m╚$]┤iτ░sφB|⌐kεc^┐m·uΩ║rs.'╗3⌐▀k¼W±Ç.à(o2╨[j┘╣oδ╩[╞╣    C╨NCΘ╓c¿+≡`í#é╖╦⌐Uì/*******************************************************************************
* FILE NAME: PgHndler.cpp                                                      *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Class implementation of the class:                                         *
*     APageHandler- Notebook page handler                                      *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef _INOTIFEV_
#include <inotifev.hpp>
#endif

#ifndef _IOBSERVR_
#include <iobservr.hpp>
#endif

#ifndef _ISTDNTFY_
#include <istdntfy.hpp>
#endif

#ifndef _APAGEHANDLER_
#include "PgHndler.hpp"
#endif

#ifndef _IVBDEFS_
#include <ivbdefs.h>
#endif

#ifndef _ITRACE_
#include <itrace.hpp>
#endif


#pragma export (APageHandler::readyId)
const INotificationId APageHandler::readyId = "APageHandler::readyId";

//------------------------------------------------------------------------------
// APageHandler :: APageHandler
//------------------------------------------------------------------------------
#pragma export (APageHandler::APageHandler())
APageHandler::APageHandler()
{

   initialize();
}     //end constructor


//------------------------------------------------------------------------------
// APageHandler :: ~APageHandler
//------------------------------------------------------------------------------
#pragma export (APageHandler::~APageHandler())
APageHandler::~APageHandler()
{

}

//------------------------------------------------------------------------------
// APageHandler :: initializePart
//------------------------------------------------------------------------------
#pragma export (APageHandler::initializePart())
APageHandler & APageHandler::initializePart()
{
   makeConnections();
   notifyObservers(INotificationEvent(readyId, *this));
   return *this;
}


//------------------------------------------------------------------------------
// APageHandler :: makeConnections
//------------------------------------------------------------------------------
#pragma export (APageHandler::makeConnections())
Boolean APageHandler::makeConnections()
{
   this->enableNotification();

   return true;
}


#include "PgHndler.cpv"


// Feature source code generation begins here...
INotificationId APageHandler::previousPageNumberId = "APageHandler::previousPageNumber";
INotificationId APageHandler::currentPageNumberId = "APageHandler::currentPageNumber";

INotificationId APageHandler::page1SelectedEventId = "APageHandler::page1SelectedEvent";
INotificationId APageHandler::page2SelectedEventId = "APageHandler::page2SelectedEvent";
INotificationId APageHandler::page3SelectedEventId = "APageHandler::page3SelectedEvent";
INotificationId APageHandler::anyPageSelectedEventId = "APageHandler::anyPageSelectedEvent";

int APageHandler::previousPageNumber() const
{
  return iPreviousPageNumber;
}

APageHandler& APageHandler::setPreviousPageNumber(int aPreviousPageNumber)
{
  if (!(iPreviousPageNumber == aPreviousPageNumber))
  {
    iPreviousPageNumber = aPreviousPageNumber;
    notifyObservers(INotificationEvent(APageHandler::previousPageNumberId, *this));
  } // endif
  return *this;
}

int APageHandler::currentPageNumber() const
{
  return iCurrentPageNumber;
}

APageHandler& APageHandler::setCurrentPageNumber(int aCurrentPageNumber)
{
  if (!(iCurrentPageNumber == aCurrentPageNumber))
  {

    ITRACE_DEVELOP(" aCurrentPAgeNumber " + IString(aCurrentPageNumber));

    iCurrentPageNumber = aCurrentPageNumber;
    notifyObservers(INotificationEvent(APageHandler::currentPageNumberId, *this));
    notifyObservers(INotificationEvent(APageHandler::anyPageSelectedEventId, *this,
                                       true, (void*) iCurrentPageNumber ));
    switch (currentPageNumber()) {
       case 1:
          notifyObservers(INotificationEvent(APageHandler::page1SelectedEventId, *this));
          break;

       case 2:
          notifyObservers(INotificationEvent(APageHandler::page2SelectedEventId, *this));
          break;

       case 3:
          notifyObservers(INotificationEvent(APageHandler::page3SelectedEventId, *this));
          break;

    } // end switch

  } // endif
  return *this;
}

APageHandler& APageHandler::handleFor(INotebook* notebk)
{
  nbPageHandler.IPageHandler::handleEventsFor(notebk)  ;
  return *this;
}

APageHandler& APageHandler::stopHandleFor(INotebook* notebk)
{
  nbPageHandler.IPageHandler::stopHandlingEventsFor(notebk);
  return *this;
}

// Feature source code generation ends here.



// added code starts here ****************


Boolean APageHandler::MyPageHandler::select( IPageSelectEvent& pageevent)
 {

   int bothfound = 0;
   int i =1;
   INotebook::Cursor cursor(*(pageevent.notebook()));

  // walk thru all pages in the notebook to find the previous page and the selected page

   for (cursor.setToFirst();cursor.isValid();cursor.setToNext()) {


   // find the page number for the previous page
      if (pageevent.previousSelectedPageHandle() == cursor.current() ){
         outerPgHandlerNv->setPreviousPageNumber( i );
         bothfound += 1;
      }

   // find the page number for the current page

      if (pageevent.pageHandle() == cursor.current()) {
         outerPgHandlerNv->setCurrentPageNumber( i );
         bothfound += 1;
      }

    // if both previous and current page are found, exit the for loop

      if ( bothfound == 2 )
         break;
      else
         i += 1;

    } // end for(cursor)

   return false;   // pass the PM page selected message up the owner chain ,
                   // just in case there is a handler that wants to process this message

 } //   APageHandler::MyPageHandler::select


// added code ends here *************

/*******************************************************************************
* FILE NAME: PgHndler.h                                                        *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Constant declarations for class:                                           *
*     APageHandler- Notebook page handler                                      *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef _ICCONST_
#include <icconst.h>
#endif

#ifndef _IVBDEFS_
#include <ivbdefs.h>
#endif

#ifndef WND_APageHandler
#define WND_APageHandler  VBBASEWINDOWID
#endif


/*******************************************************************************
* FILE NAME: PgHndler.hpp                                                      *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Declaration of the class:                                                  *
*     APageHandler- Notebook page handler                                      *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef _APAGEHANDLER_
#define _APAGEHANDLER_

class APageHandler;

#ifndef _ISTDNTFY_
#include <istdntfy.hpp>
#endif

#ifndef _IPAGEHDR_
#include <ipagehdr.hpp>
#endif

#ifndef _IPAGEEVT_
#include <ipageevt.hpp>
#endif

#ifndef _INOTEBK_
#include <inotebk.hpp>
#endif

#ifndef _ITRACE_
#include <itrace.hpp>
#endif

#include "PgHndler.h"


/*----------------------------------------------------------------------------*/
/* Align classes on four byte boundary.                                       */
/*----------------------------------------------------------------------------*/
#pragma pack(4)

//*****************************************************************************
// Class definition for APageHandler
//*****************************************************************************
class APageHandler : public IStandardNotifier {
public:
   //---------------------------------------------------------------------------
   // Constructors / destructors
   //---------------------------------------------------------------------------
   APageHandler();

   virtual  ~APageHandler();

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   virtual APageHandler & initializePart();

   //---------------------------------------------------------------------------
   // public member data
   //---------------------------------------------------------------------------
   static const INotificationId readyId;

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   Boolean makeConnections();

private:

#include "PgHndler.hpv"
};   //APageHandler


/*----------------------------------------------------------------------------*/
/* Resume compiler default packing.                                           */
/*----------------------------------------------------------------------------*/
#pragma pack()

#endif

// Feature source code generation begins here...
public:
  virtual int previousPageNumber() const;
  virtual APageHandler& setPreviousPageNumber(int aPreviousPageNumber);
  virtual int currentPageNumber() const;
  virtual APageHandler& setCurrentPageNumber(int aCurrentPageNumber);
  APageHandler& handleFor(INotebook* notebk);
  APageHandler& stopHandleFor(INotebook* notebk);

  static INotificationId previousPageNumberId;
  static INotificationId currentPageNumberId;
  static INotificationId page1SelectedEventId;
  static INotificationId page2SelectedEventId;
  static INotificationId page3SelectedEventId;
  static INotificationId anyPageSelectedEventId;

private:
  int iPreviousPageNumber;
  int iCurrentPageNumber;
// Feature source code generation ends here.

//*** added code starts here ******

public:
  static INotificationId selectedPageTempId;

protected:

  // **** PageHandler nested class *****
   class MyPageHandler : public IPageHandler  {
     public:
       void setOuterPgHandlerNv(APageHandler * nvPageHdler) {
        outerPgHandlerNv = nvPageHdler;
        }
     protected:
       virtual Boolean select( IPageSelectEvent & event);
     private:
       APageHandler* outerPgHandlerNv;
   };

private:

  MyPageHandler nbPageHandler;
  void initialize() { nbPageHandler.setOuterPgHandlerNv(this); }

// ** added code stops here **

Ç.\PgHndler.cppê¼TIS
êǃCPPOM30I.LIBêǃOS2386.LIBê»DEMANGLêǃCPPOOC3I.LIBêÇáreadyId__12APageHandlerê!Çá/*******************************************************************************
* FILE NAME: PgHndler.rci                                                      *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Resource include file for class:                                           *
*     APageHandler- Notebook page handler                                      *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef vbinclude
#define vbinclude  #include
#endif

#include "PgHndler.h"

vbinclude <os2.h>

#ifndef MAIN_RESOURCES_INCLUDED
#define MAIN_RESOURCES_INCLUDED

HELPTABLE WND_APageHandler
   BEGIN
   END

#define APageHandler_WINDOWRESOURCES
#define APageHandler_NONWINDOWRESOURCES
STRINGTABLE
   BEGIN
      1,  "Visual Builder 3.0"
   END

#endif

#ifdef APageHandler_NONWINDOWRESOURCES
#ifndef APageHandler_NONWINDOWRESOURCES_INCLUDED
#define APageHandler_NONWINDOWRESOURCES_INCLUDED
#endif
#endif

#ifdef APageHandler_WINDOWRESOURCES
#define APageHandler_WINDOWRESOURCES_INCLUDING

#undef APageHandler_WINDOWRESOURCES_INCLUDING
#endif

#ifdef APageHandler_HELPITEMRESOURCES
#endif

#ifdef APageHandler_HELPSUBITEMRESOURCES
#endif

MZ      @Ç║┤    ═!╕
L═!This program cannot be run in a DOS session.
$LX

xT`·    Φ──l
╠
÷
¼ 
(\t¥╨ÆVf·ΣX
 
┤! 
Ç     
╕     
`·

49 
) 
$,4
9
=>
4ÿ:
ÿ:TARGET!makeConnections__12APageHandlerFv
 initializePart__12APageHandlerFvreadyId__12APageHandler__dt__4testFvC__ct__4testFUlP7IWindowT2RC10IRectangleRCQ2_12IFrameWindow5StylePCcreadyId__4test/*******************************************************************************
* FILE NAME: test.cpp                                                          *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Class implementation of the class:                                         *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef _IFRAME_
#include <iframe.hpp>
#endif

#ifndef _ICANVAS_
#include <icanvas.hpp>
#endif

#ifndef _INOTEBK_
#include <inotebk.hpp>
#endif

#ifndef _IPOINT_
#include <ipoint.hpp>
#endif

#ifndef _IRECT_
#include <irect.hpp>
#endif

#ifndef _IVBNBKPG_
#include <ivbnbkpg.hpp>
#endif

#ifndef _IENTRYFD_
#include <ientryfd.hpp>
#endif

#ifndef _IPUSHBUT_
#include <ipushbut.hpp>
#endif

#ifndef _ISTATTXT_
#include <istattxt.hpp>
#endif

#ifndef _APAGEHANDLER_
#include "PgHndler.hpp"
#endif

#ifndef _INOTIFEV_
#include <inotifev.hpp>
#endif

#ifndef _IOBSERVR_
#include <iobservr.hpp>
#endif

#ifndef _ISTDNTFY_
#include <istdntfy.hpp>
#endif

#ifndef _TEST_
#include "test.hpp"
#endif

#ifndef _IVBDEFS_
#include <ivbdefs.h>
#endif

#ifndef _ITRACE_
#include <itrace.hpp>
#endif


//*****************************************************************************
// Class definition for testConn0
//*****************************************************************************
class testConn0 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn0(){};

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   void initialize(IPushButton * aSource, APageHandler * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn0 & setNotebk(INotebook * aSelf) {iNotebk = aSelf; return *this;};

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == IPushButton::buttonClickId)
         {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : PushButton1(buttonClickEvent) to APageHandler1(startHandleFor))");
         try {target->handleFor(iNotebk);}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   IPushButton * source;
   APageHandler * target;
   INotebook * iNotebk;


};   //testConn0


//*****************************************************************************
// Class definition for testConn2
//*****************************************************************************
class testConn2 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn2(){};

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   void initialize(IPushButton * aSource, APageHandler * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn2 & setNotebk(INotebook * aSelf) {iNotebk = aSelf; return *this;};

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == IPushButton::buttonClickId)
         {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : PushButton2(buttonClickEvent) to APageHandler1(stopHandleFor))");
         try {target->stopHandleFor(iNotebk);}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   IPushButton * source;
   APageHandler * target;
   INotebook * iNotebk;


};   //testConn2


//*****************************************************************************
// Class definition for testConn4
//*****************************************************************************
class testConn4 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn4(){};

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn4 & setNewValue(APageHandler * aSelf) {iNewValue = aSelf; return *this;};

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == APageHandler::page3SelectedEventId)
         {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : APageHandler1(page3SelectedEvent) to EntryField3(valueAsInt))");
         try {target->VBSETTEXTFROMVALUE(iNewValue->currentPageNumber());}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   APageHandler * source;
   IEntryField * target;
   APageHandler * iNewValue;


};   //testConn4


//*****************************************************************************
// Class definition for testConn6
//*****************************************************************************
class testConn6 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn6(){};

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn6 & setNewValue(APageHandler * aSelf) {iNewValue = aSelf; return *this;};

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == APageHandler::page1SelectedEventId)
         {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : APageHandler1(page1SelectedEvent) to EntryField4(valueAsInt))");
         try {target->VBSETTEXTFROMVALUE(iNewValue->currentPageNumber());}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   APageHandler * source;
   IEntryField * target;
   APageHandler * iNewValue;


};   //testConn6


//*****************************************************************************
// Class definition for testConn8
//*****************************************************************************
class testConn8 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn8(){};

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn8 & setNewValue(APageHandler * aSelf) {iNewValue = aSelf; return *this;};

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == APageHandler::page2SelectedEventId)
         {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : APageHandler1(page2SelectedEvent) to EntryField5(valueAsInt))");
         try {target->VBSETTEXTFROMVALUE(iNewValue->currentPageNumber());}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   APageHandler * source;
   IEntryField * target;
   APageHandler * iNewValue;


};   //testConn8


//*****************************************************************************
// Class definition for testConn10
//*****************************************************************************
class testConn10 : public IObserver {
public:
   virtual  ~testConn10(){};

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; aligning = false; };
   void setSource()
      {
      if (aligning==false) {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : APageHandler1(currentPageNumber) to EntryField1(valueAsInt))");
         ITRACE_DEVELOP(" setting source from target ");
         aligning = true;
         try {source->setCurrentPageNumber(target->VBINTVALUEFROMTEXT());}
         catch (IException& exc) {};
         aligning = false;
         }
      };
   void setTarget()
      {
      if (aligning==false) {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : APageHandler1(currentPageNumber) to EntryField1(valueAsInt))");
         ITRACE_DEVELOP(" setting target from source ");
         aligning = true;
         try {target->VBSETTEXTFROMVALUE(source->currentPageNumber());}
         catch (IException& exc) {};
         aligning = false;
         }
      };

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == VBINITIALIZEID) setTarget();
      if ((anEvent.notificationId() == APageHandler::currentPageNumberId) && (source == &anEvent.notifier()))
         setTarget();  /* set target to source value */
      else
      if ((anEvent.notificationId() == IEntryField::textId) && (target == &anEvent.notifier()))
         setSource();  /* set source to target value */
      return(*this);
      };

private:
   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   APageHandler * source;
   IEntryField * target;
   Boolean aligning;


};   //testConn10


//*****************************************************************************
// Class definition for testConn11
//*****************************************************************************
class testConn11 : public IObserver {
public:
   virtual  ~testConn11(){};

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; aligning = false; };
   void setSource()
      {
      if (aligning==false) {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : APageHandler1(previousPageNumber) to EntryField2(valueAsInt))");
         ITRACE_DEVELOP(" setting source from target ");
         aligning = true;
         try {source->setPreviousPageNumber(target->VBINTVALUEFROMTEXT());}
         catch (IException& exc) {};
         aligning = false;
         }
      };
   void setTarget()
      {
      if (aligning==false) {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : APageHandler1(previousPageNumber) to EntryField2(valueAsInt))");
         ITRACE_DEVELOP(" setting target from source ");
         aligning = true;
         try {target->VBSETTEXTFROMVALUE(source->previousPageNumber());}
         catch (IException& exc) {};
         aligning = false;
         }
      };

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == VBINITIALIZEID) setTarget();
      if ((anEvent.notificationId() == APageHandler::previousPageNumberId) && (source == &anEvent.notifier()))
         setTarget();  /* set target to source value */
      else
      if ((anEvent.notificationId() == IEntryField::textId) && (target == &anEvent.notifier()))
         setSource();  /* set source to target value */
      return(*this);
      };

private:
   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   APageHandler * source;
   IEntryField * target;
   Boolean aligning;


};   //testConn11


//*****************************************************************************
// Class definition for testConn12
//*****************************************************************************
class testConn12 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn12(){};

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == APageHandler::anyPageSelectedEventId)
         {
         IFUNCTRACE_DEVELOP();
         ITRACE_DEVELOP(" firing connection : APageHandler1(anyPageSelectedEvent) to EntryField6(customLogic, \"set ef to the selected page number\"))");
         try {codeSnippet(&anEvent);}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
   //---------------------------------------------------------------------------
   // private member functions
   //---------------------------------------------------------------------------
   void codeSnippet(const INotificationEvent* event)
      {
      // get page number from IEventData object.
      // event->eventData returns en IEventData object.

      target->VBSETTEXTFROMVALUE(event->eventData().asLong());
      };

   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   APageHandler * source;
   IEntryField * target;


};   //testConn12


#pragma export (test::readyId)
const INotificationId test::readyId = "test::readyId";

#pragma export (test::partWindowId)
unsigned long test::partWindowId = 0;

//------------------------------------------------------------------------------
// test :: defaultFramingSpec
//------------------------------------------------------------------------------
#pragma export (test::defaultFramingSpec())
const IRectangle test::defaultFramingSpec()
{
   return(IRectangle(IPoint(30, IWindow::desktopWindow()->size().height() - -2 - 416),ISize(545, 416)));
}


//------------------------------------------------------------------------------
// test :: defaultTitle
//------------------------------------------------------------------------------
#pragma export (test::defaultTitle())
IString test::defaultTitle()
{
   return("IPageHandler example");
}


//------------------------------------------------------------------------------
// test :: test
//------------------------------------------------------------------------------
#pragma export (test::test(unsigned long, IWindow*, IWindow*, const IRectangle&, const IFrameWindow::Style&, const char*))
test::test(
      unsigned long id,
      IWindow* parent,
      IWindow* owner,
      const IRectangle& rect,
      const IFrameWindow::Style& style,
      const char* title)
   : IFrameWindow((partWindowId) ? partWindowId : id, parent, owner, rect, style, title)
{
   partWindowId = (partWindowId) ? partWindowId : id;
   iCanvas = new ICanvas(
      IC_FRAME_CLIENT_ID,
      this,
      this,
      IRectangle());
   iNotebook1 = new INotebook(
      partWindowId+WNDOFFSET_test_Notebook1,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(18,136),ISize(438, 220)));
   iCanvas2 = new ICanvas(
      partWindowId+WNDOFFSET_test_Canvas2,
      iNotebook1,
      iNotebook1,
      IRectangle());
   iEntryField4 = new IEntryField(
      partWindowId+WNDOFFSET_test_EntryField4,
      iCanvas2,
      iCanvas2,
      IRectangle(IPoint(54,93),ISize(200, 25)));
   iVBNotebookPage = new IVBNotebookPage(iNotebook1, INotebook::PageSettings::majorTab | INotebook::PageSettings::autoPageSize, iCanvas2);
   iCanvas1 = new ICanvas(
      partWindowId+WNDOFFSET_test_Canvas1,
      iNotebook1,
      iNotebook1,
      IRectangle());
   iEntryField5 = new IEntryField(
      partWindowId+WNDOFFSET_test_EntryField5,
      iCanvas1,
      iCanvas1,
      IRectangle(IPoint(54,97),ISize(237, 26)));
   iVBNotebookPage1 = new IVBNotebookPage(iNotebook1, INotebook::PageSettings::majorTab | INotebook::PageSettings::autoPageSize, iCanvas1);
   iCanvas3 = new ICanvas(
      partWindowId+WNDOFFSET_test_Canvas3,
      iNotebook1,
      iNotebook1,
      IRectangle());
   iEntryField3 = new IEntryField(
      partWindowId+WNDOFFSET_test_EntryField3,
      iCanvas3,
      iCanvas3,
      IRectangle(IPoint(65,111),ISize(235, 25)));
   iVBNotebookPage2 = new IVBNotebookPage(iNotebook1, INotebook::PageSettings::majorTab | INotebook::PageSettings::autoPageSize, iCanvas3);
   iEntryField1 = new IEntryField(
      partWindowId+WNDOFFSET_test_EntryField1,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(19,74),ISize(161, 26)));
   iPushButton1 = new IPushButton(
      partWindowId+WNDOFFSET_test_PushButton1,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(85,25),ISize(124, 34)));
   iPushButton2 = new IPushButton(
      partWindowId+WNDOFFSET_test_PushButton2,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(268,24),ISize(121, 34)));
   iEntryField2 = new IEntryField(
      partWindowId+WNDOFFSET_test_EntryField2,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(205,71),ISize(148, 27)));
   iStaticText1 = new IStaticText(
      partWindowId+WNDOFFSET_test_StaticText1,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(19,102),ISize(158, 25)));
   iStaticText2 = new IStaticText(
      partWindowId+WNDOFFSET_test_StaticText2,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(205,102),ISize(138, 25)));
   iEntryField6 = new IEntryField(
      partWindowId+WNDOFFSET_test_EntryField6,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(392,72),ISize(129, 24)));
   iAPageHandler1 = new APageHandler();

   conn0 = new testConn0();
   conn2 = new testConn2();
   conn4 = new testConn4();
   conn6 = new testConn6();
   conn8 = new testConn8();
   conn10 = new testConn10();
   conn11 = new testConn11();
   conn12 = new testConn12();

   this->setFocus();
   this->setClient(iCanvas);
   iNotebook1->setMinorTabSize(ISize(0, 0));
   iVBNotebookPage->setTabText("Tab1");
   iCanvas2->setMinimumSize(ISize(100, 100));
   iVBNotebookPage1->setTabText("Tab2");
   iCanvas1->setMinimumSize(ISize(100, 100));
   iVBNotebookPage2->setTabText("Tab3");
   iCanvas3->setMinimumSize(ISize(100, 100));
   iPushButton1->setText("start handle");
   iPushButton2->setText("stop handle");
   iStaticText1->setText("current pg number");
   iStaticText2->setText("previous page #");
}     //end constructor


//------------------------------------------------------------------------------
// test :: ~test
//------------------------------------------------------------------------------
#pragma export (test::~test())
test::~test()
{
   conn0->stopHandlingNotificationsFor(*iPushButton1);
   conn2->stopHandlingNotificationsFor(*iPushButton2);
   conn4->stopHandlingNotificationsFor(*iAPageHandler1);
   conn6->stopHandlingNotificationsFor(*iAPageHandler1);
   conn8->stopHandlingNotificationsFor(*iAPageHandler1);
   conn10->stopHandlingNotificationsFor(*iAPageHandler1);
   conn10->stopHandlingNotificationsFor(*iEntryField1);
   conn11->stopHandlingNotificationsFor(*iAPageHandler1);
   conn11->stopHandlingNotificationsFor(*iEntryField2);
   conn12->stopHandlingNotificationsFor(*iAPageHandler1);

   delete conn0;
   delete conn2;
   delete conn4;
   delete conn6;
   delete conn8;
   delete conn10;
   delete conn11;
   delete conn12;


   delete iCanvas;
   delete iNotebook1;
   delete iVBNotebookPage;
   delete iCanvas2;
   delete iEntryField4;
   delete iVBNotebookPage1;
   delete iCanvas1;
   delete iEntryField5;
   delete iVBNotebookPage2;
   delete iCanvas3;
   delete iEntryField3;
   delete iEntryField1;
   delete iPushButton1;
   delete iPushButton2;
   delete iEntryField2;
   delete iStaticText1;
   delete iStaticText2;
   delete iEntryField6;
   delete iAPageHandler1;
}

//------------------------------------------------------------------------------
// test :: initializePart
//------------------------------------------------------------------------------
#pragma export (test::initializePart())
test & test::initializePart()
{
   makeConnections();
   notifyObservers(INotificationEvent(readyId, *this));
   return *this;
}


//------------------------------------------------------------------------------
// test :: makeConnections
//------------------------------------------------------------------------------
#pragma export (test::makeConnections())
Boolean test::makeConnections()
{
   this->enableNotification();
   iCanvas->enableNotification();
   iNotebook1->enableNotification();
   iVBNotebookPage->enableNotification();
   iCanvas2->enableNotification();
   iEntryField4->enableNotification();
   iVBNotebookPage1->enableNotification();
   iCanvas1->enableNotification();
   iEntryField5->enableNotification();
   iVBNotebookPage2->enableNotification();
   iCanvas3->enableNotification();
   iEntryField3->enableNotification();
   iEntryField1->enableNotification();
   iPushButton1->enableNotification();
   iPushButton2->enableNotification();
   iEntryField2->enableNotification();
   iStaticText1->enableNotification();
   iStaticText2->enableNotification();
   iEntryField6->enableNotification();
   iAPageHandler1->enableNotification();

   conn0->initialize(iPushButton1, iAPageHandler1);
   conn0->handleNotificationsFor(*iPushButton1);
   conn0->setNotebk(iNotebook1);
   conn2->initialize(iPushButton2, iAPageHandler1);
   conn2->handleNotificationsFor(*iPushButton2);
   conn2->setNotebk(iNotebook1);
   conn4->initialize(iAPageHandler1, iEntryField3);
   conn4->handleNotificationsFor(*iAPageHandler1);
   conn4->setNewValue(iAPageHandler1);
   conn6->initialize(iAPageHandler1, iEntryField4);
   conn6->handleNotificationsFor(*iAPageHandler1);
   conn6->setNewValue(iAPageHandler1);
   conn8->initialize(iAPageHandler1, iEntryField5);
   conn8->handleNotificationsFor(*iAPageHandler1);
   conn8->setNewValue(iAPageHandler1);
   conn10->initialize(iAPageHandler1, iEntryField1);
   conn10->handleNotificationsFor(*iAPageHandler1);
   conn10->handleNotificationsFor(*iEntryField1);
   conn11->initialize(iAPageHandler1, iEntryField2);
   conn11->handleNotificationsFor(*iAPageHandler1);
   conn11->handleNotificationsFor(*iEntryField2);
   conn12->initialize(iAPageHandler1, iEntryField6);
   conn12->handleNotificationsFor(*iAPageHandler1);

   conn10->setTarget();
   conn11->setTarget();
   return true;
}



/*******************************************************************************
* FILE NAME: test.h                                                            *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Constant declarations for class:                                           *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef _ICCONST_
#include <icconst.h>
#endif

#ifndef _IVBDEFS_
#include <ivbdefs.h>
#endif

#ifndef WND_test
#define WND_test  VBBASEWINDOWID
#endif

#define WNDOFFSET_test_FrameWindow  0
#define WND_test_FrameWindow  WND_test

#define WND_test_Canvas  IC_FRAME_CLIENT_ID

#define WNDOFFSET_test_Notebook1  1
#define WND_test_Notebook1  WND_test + WNDOFFSET_test_Notebook1


#define WNDOFFSET_test_Canvas2  2
#define WND_test_Canvas2  WND_test + WNDOFFSET_test_Canvas2

#define WNDOFFSET_test_EntryField4  3
#define WND_test_EntryField4  WND_test + WNDOFFSET_test_EntryField4


#define WNDOFFSET_test_Canvas1  4
#define WND_test_Canvas1  WND_test + WNDOFFSET_test_Canvas1

#define WNDOFFSET_test_EntryField5  5
#define WND_test_EntryField5  WND_test + WNDOFFSET_test_EntryField5


#define WNDOFFSET_test_Canvas3  6
#define WND_test_Canvas3  WND_test + WNDOFFSET_test_Canvas3

#define WNDOFFSET_test_EntryField3  7
#define WND_test_EntryField3  WND_test + WNDOFFSET_test_EntryField3

#define WNDOFFSET_test_EntryField1  8
#define WND_test_EntryField1  WND_test + WNDOFFSET_test_EntryField1

#define WNDOFFSET_test_PushButton1  9
#define WND_test_PushButton1  WND_test + WNDOFFSET_test_PushButton1

#define WNDOFFSET_test_PushButton2  10
#define WND_test_PushButton2  WND_test + WNDOFFSET_test_PushButton2

#define WNDOFFSET_test_EntryField2  11
#define WND_test_EntryField2  WND_test + WNDOFFSET_test_EntryField2

#define WNDOFFSET_test_StaticText1  12
#define WND_test_StaticText1  WND_test + WNDOFFSET_test_StaticText1

#define WNDOFFSET_test_StaticText2  13
#define WND_test_StaticText2  WND_test + WNDOFFSET_test_StaticText2

#define WNDOFFSET_test_EntryField6  14
#define WND_test_EntryField6  WND_test + WNDOFFSET_test_EntryField6



/*******************************************************************************
* FILE NAME: test.hpp                                                          *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Declaration of the class:                                                  *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef _TEST_
#define _TEST_

class test;

#ifndef _IFRAME_
#include <iframe.hpp>
#endif

class ICanvas;
class INotebook;
class IVBNotebookPage;
class IEntryField;
class IPushButton;
class IStaticText;
class APageHandler;
#ifndef _IRECT_
#include <irect.hpp>
#endif

#ifndef _ISTRING_
#include <istring.hpp>
#endif

#ifndef _IEVTDATA_
#include <ievtdata.hpp>
#endif

class testConn0;
class testConn2;
class testConn4;
class testConn6;
class testConn8;
class testConn10;
class testConn11;
class testConn12;
#include "test.h"


/*----------------------------------------------------------------------------*/
/* Align classes on four byte boundary.                                       */
/*----------------------------------------------------------------------------*/
#pragma pack(4)

//*****************************************************************************
// Class definition for test
//*****************************************************************************
class test : public IFrameWindow {
public:
   //---------------------------------------------------------------------------
   // Constructors / destructors
   //---------------------------------------------------------------------------
   test(
      unsigned long id = WND_test,
      IWindow* parent = IWindow::desktopWindow(),
      IWindow* owner = 0,
      const IRectangle& rect = defaultFramingSpec(),
      const IFrameWindow::Style& style = IFrameWindow::defaultStyle ( ),
      const char* title = defaultTitle());

   virtual  ~test();

   //---------------------------------------------------------------------------
   // public member functions
   //---------------------------------------------------------------------------
   static const IRectangle defaultFramingSpec();
   static IString defaultTitle();
   virtual test & initializePart();
   test * getFrameWindow() { return this; };

   //---------------------------------------------------------------------------
   // public member data
   //---------------------------------------------------------------------------
   static const INotificationId readyId;

protected:
   //---------------------------------------------------------------------------
   // protected member functions
   //---------------------------------------------------------------------------
   Boolean makeConnections();

private:
   //---------------------------------------------------------------------------
   // private member data
   //---------------------------------------------------------------------------
   ICanvas * iCanvas;
   INotebook * iNotebook1;
   IVBNotebookPage * iVBNotebookPage;
   ICanvas * iCanvas2;
   IEntryField * iEntryField4;
   IVBNotebookPage * iVBNotebookPage1;
   ICanvas * iCanvas1;
   IEntryField * iEntryField5;
   IVBNotebookPage * iVBNotebookPage2;
   ICanvas * iCanvas3;
   IEntryField * iEntryField3;
   IEntryField * iEntryField1;
   IPushButton * iPushButton1;
   IPushButton * iPushButton2;
   IEntryField * iEntryField2;
   IStaticText * iStaticText1;
   IStaticText * iStaticText2;
   IEntryField * iEntryField6;
   APageHandler * iAPageHandler1;
   testConn0 * conn0;
   testConn2 * conn2;
   testConn4 * conn4;
   testConn6 * conn6;
   testConn8 * conn8;
   testConn10 * conn10;
   testConn11 * conn11;
   testConn12 * conn12;
   static unsigned long partWindowId;

friend class testConn12;

};   //test


/*----------------------------------------------------------------------------*/
/* Resume compiler default packing.                                           */
/*----------------------------------------------------------------------------*/
#pragma pack()

#endif
#line 20 "F:\vacpp\INCLUDE\imsgtext.hpp"
#pragma info (none)
#pragma pack (4)
#line 24
class IMessageText {
public:

  IMessageText  ( unsigned long messageId,
                  const char*   messageFileName,
                  const char*   textInsert1 = 0,
                  const char*   textInsert2 = 0,
                  const char*   textInsert3 = 0,
                  const char*   textInsert4 = 0,
                  const char*   textInsert5 = 0,
                  const char*   textInsert6 = 0,
                  const char*   textInsert7 = 0,
                  const char*   textInsert8 = 0,
                  const char*   textInsert9 = 0 );

  IMessageText ( const IMessageText& text );

  ~IMessageText ( );
#line 44
  operator const char*  () const;

const char*
  text ( ) const;

IMessageText
 &setDefaultText ( const char*         text ),
 &operator=      ( const IMessageText& text );

private:
#line 56
char
 *pClText;
int
  bClSuccess;

};
#line 64
#pragma info (restore)
#pragma pack ()
#line 35 "F:\vacpp\INCLUDE\iexcbase.hpp"
class IExcText;

class IExceptionLocation {
public:
#line 41
  IExceptionLocation ( const char*   fileName = 0,
                       const char*   functionName = 0,
                       unsigned long lineNumber = 0 );
#line 46
const char
 *fileName     ( ) const,
 *functionName ( ) const;

unsigned long
  lineNumber ( ) const;

private:

const char
 *pClFile,
 *pClFunction;
unsigned long
  ulClLineNo;
};

class IException {
public:

enum Severity { unrecoverable, recoverable };
#line 68
  IException ( const char*       errorText,
               unsigned long     errorId = 0,
               Severity          severity = IException::unrecoverable );
  IException ( const IException& exception );

virtual
 ~IException ( );

class TraceFn {
public:

virtual void
  write   ( const char* buffer ),
  logData ( IException& exception );

protected:

  TraceFn ( );
#line 88
virtual void
  exceptionLogged ( );

};
#line 94
typedef const char* ErrorCodeGroup;

static ErrorCodeGroup const
  baseLibrary,
  CLibrary,
  operatingSystem,
  presentationSystem,
  other;

IException&
  setErrorCodeGroup ( ErrorCodeGroup errorGroup );

ErrorCodeGroup
  errorCodeGroup ( ) const;
#line 110
IException
 &appendText  ( const char*   errorText ),
 &setText     ( const char*   errorText );

const char
 *text ( unsigned long indexFromTop = 0 ) const;

unsigned long
  textCount     ( ) const;
#line 121
IException
 &setSeverity ( Severity      severity );

virtual int
 isRecoverable ( ) const;
#line 128
IException
 &setErrorId  ( unsigned long errorId );

unsigned long
  errorId       ( ) const;
#line 135
virtual IException
 &addLocation      ( const IExceptionLocation& location );

unsigned long
  locationCount ( ) const;

const IExceptionLocation
 *locationAtIndex ( unsigned long locationIndex ) const;
#line 145
virtual const char
 *name ( ) const;
#line 149
static IException::TraceFn
 *setTraceFunction ( IException::TraceFn& traceFunction );

virtual IException
 &logExceptionData ( );
#line 156
virtual void
  terminate ( );
#line 160
static void
  assertParameter ( const char*        exceptionText,
                    IExceptionLocation location );

private:

IException
 &operator= ( const IException& exc );
#line 170
friend class IException::TraceFn;

Severity
  exsevCl;
unsigned long
  ulClErrorId;
IExceptionLocation
  exlocClArray[5];
unsigned long
  ulexlocClCount,
  ulClTxtLvlCount;
IExcText
 *msgtxtClTop;
ErrorCodeGroup
  fErrorGroup;
};
#line 251
class IAccessError : public IException {public: IAccessError(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IAccessError(); IAccessError(const IAccessError &);private: operator = ( const IAccessError & );};
class IAssertionFailure : public IException {public: IAssertionFailure(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IAssertionFailure(); IAssertionFailure(const IAssertionFailure &);private: operator = ( const IAssertionFailure & );};
class IDeviceError : public IException {public: IDeviceError(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IDeviceError(); IDeviceError(const IDeviceError &);private: operator = ( const IDeviceError & );};
class IInvalidParameter : public IException {public: IInvalidParameter(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IInvalidParameter(); IInvalidParameter(const IInvalidParameter &);private: operator = ( const IInvalidParameter & );};
class IInvalidRequest : public IException {public: IInvalidRequest(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IInvalidRequest(); IInvalidRequest(const IInvalidRequest &);private: operator = ( const IInvalidRequest & );};
class IResourceExhausted : public IException {public: IResourceExhausted(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IResourceExhausted(); IResourceExhausted(const IResourceExhausted &);private: operator = ( const IResourceExhausted & );};
  class IOutOfMemory : public IResourceExhausted {public: IOutOfMemory(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IOutOfMemory(); IOutOfMemory(const IOutOfMemory &);private: operator = ( const IOutOfMemory & );};
  class IOutOfSystemResource : public IResourceExhausted {public: IOutOfSystemResource(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IOutOfSystemResource(); IOutOfSystemResource(const IOutOfSystemResource &);private: operator = ( const IOutOfSystemResource & );};
  class IOutOfWindowResource : public IResourceExhausted {public: IOutOfWindowResource(const char* a, unsigned long b = 0, Severity c = IException::unrecoverable); virtual const char* name() const; virtual ~IOutOfWindowResource(); IOutOfWindowResource(const IOutOfWindowResource &);private: operator = ( const IOutOfWindowResource & );};
#line 20 "F:\vacpp\INCLUDE\ibase.hpp"
#pragma pack(4)

class ostream;
class IString;

class IBase {
public:
#line 29
typedef int
  Boolean;

enum BooleanConstants {
  false = 0,
  true  = 1
  };
#line 38
static char
 *messageFile    ( );

static void
  setMessageFile ( const char *msgFileName );

static IMessageText
  messageText    ( unsigned long messageId,
                   const char*   textInsert1 = 0,
                   const char*   textInsert2 = 0,
                   const char*   textInsert3 = 0,
                   const char*   textInsert4 = 0,
                   const char*   textInsert5 = 0,
                   const char*   textInsert6 = 0,
                   const char*   textInsert7 = 0,
                   const char*   textInsert8 = 0,
                   const char*   textInsert9 = 0 );
#line 57
friend ostream
 &operator <<    ( ostream     &aStream,
                   const IBase &anObject );

IString
  asString       ( ) const,
  asDebugInfo    ( ) const;

struct Version   {
unsigned short
  major,
  minor;
  };

static Version
  version        ( );

protected:

static IException::Severity
  unrecoverable,
  recoverable;

private:

static char
 *msgFile;
};
#line 137
extern "C" {
#line 140
typedef void * _System
  IWinProc ( unsigned long, unsigned long, void *, void * );

}
#line 222
       #pragma library("CPPOOC3.LIB")
#line 226
#pragma pack()
#line 31 "F:\vacpp\INCLUDE\isynonym.hpp"
typedef int Boolean;
#line 35
typedef int IBoolean;
#line 40
   enum {
      false = 0,
      False = 0,
      true  = 1,
      True  = 1
   };
#line 20 "F:\vacpp\INCLUDE\ivbase.hpp"
#pragma pack(4)

class ostream;
class IString;

class IVBase : public IBase {
public:

virtual
 ~IVBase         ( );
#line 32
friend ostream
 &operator <<    ( ostream      &aStream,
                   const IVBase &anObject );

virtual IString
  asString       ( ) const,
  asDebugInfo    ( ) const;

};

#pragma pack()
#line 21 "F:\vacpp\INCLUDE\inotify.hpp"
class IObserver;
class IObserverList;
class INotificationEvent;
class IEventData;

#pragma pack(4)

typedef const char
 *INotificationId;

class INotifier : public IVBase {
typedef IVBase
  Inherited;

public:

  INotifier  ( );
virtual
  ~INotifier ( );
#line 42
virtual INotifier
 &enableNotification        ( Boolean enable=true ) = 0,
 &disableNotification       ( ) = 0;

virtual Boolean
  isEnabledForNotification  ( ) const = 0;
#line 50
virtual INotifier
 ¬ifyObservers       ( const INotificationEvent& event ) = 0;

protected:

virtual INotifier
 &addObserver           ( IObserver&        observer,
                          const IEventData& userData ) = 0,
 &removeObserver        ( IObserver&  observer ) = 0,
 &removeAllObservers    ( ) = 0;

virtual IObserverList
 &observerList          ( ) const = 0;
#line 65
virtual INotifier
  ¬ifyObservers      ( const INotificationId& id ) = 0;

private:

friend class IObserver;
};

#pragma pack()
#line 28 "F:\vacpp\INCLUDE\ibitflag.hpp"
#pragma pack(4)
#line 31
class IBitFlag : public IBase {
typedef IBase
  Inherited;
public:

unsigned long
  asUnsignedLong         ( ) const,
  asExtendedUnsignedLong ( ) const;
#line 41
Boolean
  operator ==    ( const IBitFlag &rhs ) const,
  operator !=    ( const IBitFlag &rhs ) const;

protected:

  IBitFlag       ( unsigned long value,
                   unsigned long extendedValue = 0 );
#line 51
IBitFlag
 &setValue       ( unsigned long value ,
                   unsigned long extendedValue = 0 );

private:

unsigned long
  ulClValue,
  ulClExtValue;
};
#line 279
#pragma pack()
#line 28 "F:\vacpp\INCLUDE\ibitflag.inl"
inline IBitFlag :: IBitFlag ( unsigned long value,
                              unsigned long extValue )
       : ulClValue( value ),
         ulClExtValue( extValue )
{}

inline unsigned long  IBitFlag :: asUnsignedLong ( ) const
{
  return( this->ulClValue );
}

inline unsigned long  IBitFlag :: asExtendedUnsignedLong ( ) const
{
  return( this->ulClExtValue );
}

inline IBitFlag  &IBitFlag :: setValue ( unsigned long value,
                                         unsigned long extValue )
{
  this->ulClValue = value;
  this->ulClExtValue = extValue;
  return( *this );
}

inline IBase::Boolean  IBitFlag :: operator == ( const IBitFlag &rhs ) const
{
  return( (this->asUnsignedLong() == rhs.asUnsignedLong())  &
          (this->asExtendedUnsignedLong() == rhs.asExtendedUnsignedLong()) );
}

inline IBase::Boolean  IBitFlag :: operator != ( const IBitFlag &rhs ) const
{
  return( (this->asUnsignedLong() != rhs.asUnsignedLong())  |
          (this->asExtendedUnsignedLong() != rhs.asExtendedUnsignedLong()) );
}
#line 25 "F:\vacpp\INCLUDE\ievtdata.hpp"
#pragma pack(4)

class IEventData : public IBase {
typedef IBase
  Inherited;
public:

  IEventData ( );
  IEventData ( void*            value );
  IEventData ( unsigned long    value );
  IEventData ( int              value );
  IEventData ( BooleanConstants value );

  IEventData ( unsigned short   lowValue,
               unsigned short   hiValue );

  IEventData ( unsigned short   lowValue,
               char             lowByte,
               char             hiByte );
#line 46
unsigned short
  lowNumber    ( ) const,
  highNumber   ( ) const,
  number1      ( ) const,
  number2      ( ) const;

char
  lowLowByte   ( ) const,
  lowHighByte  ( ) const,
  highLowByte  ( ) const,
  highHighByte ( ) const,
  char1        ( ) const,
  char2        ( ) const,
  char3        ( ) const,
  char4        ( ) const;
#line 63
unsigned long
  asUnsignedLong         ( ) const;
long
  asLong                 ( ) const;

  operator char*         ( ) const;
  operator unsigned long ( ) const;

private:

void
 *pvClMsg;
};

typedef IEventData IEventParameter1;
typedef IEventData IEventParameter2;
typedef IEventData ILowEventParameter;
typedef IEventData IHighEventParameter;
typedef IEventData IEventResult;

#pragma pack()
#line 28 "F:\vacpp\INCLUDE\ievtdata.inl"
inline IEventData :: IEventData ( )
  : pvClMsg ( 0 )
  { }
inline IEventData :: IEventData ( void* value )
  {
  pvClMsg = value;
  }
inline IEventData :: IEventData ( unsigned long value )
  {
  pvClMsg = (void*)value;
  }
inline IEventData :: IEventData ( int value )
  {
  pvClMsg = (void*)((unsigned long)value);
  }
inline IEventData :: IEventData ( BooleanConstants value )
  {
  pvClMsg = (void*)((unsigned long)value);
  }
inline IEventData :: IEventData ( unsigned short lowValue,
                                  unsigned short hiValue )
  {
  pvClMsg = (void*)(lowValue | (unsigned long)hiValue << 16);
  }
inline IEventData :: IEventData ( unsigned short lowValue,
                                  char lowByte, char hiByte )
  {
  unsigned short hiValue = (unsigned short)(lowByte | (unsigned short)hiByte <<
  8); pvClMsg = (void*)(lowValue | (unsigned long)hiValue << 16);
  }
inline char  IEventData :: lowLowByte ( ) const
  {
  return (char)(unsigned long)pvClMsg;
  }
inline char  IEventData :: lowHighByte ( ) const
  {
  return (char)((unsigned long)pvClMsg >> 8);
  }
inline char  IEventData :: highLowByte ( ) const
  {
  return (char)((unsigned long)pvClMsg >> 16);
  }
inline char  IEventData :: highHighByte ( ) const
  {
  return (char)((unsigned long)pvClMsg >> 24);
  }
inline char  IEventData :: char1 ( ) const
  {
  return lowLowByte();
  }
inline char  IEventData :: char2 ( ) const
  {
  return lowHighByte();
  }
inline char  IEventData :: char3 ( ) const
  {
  return highLowByte();
  }
inline char  IEventData :: char4 ( ) const
  {
  return highHighByte();
  }
inline unsigned short  IEventData :: lowNumber ( ) const
  {
  return (unsigned short)(unsigned long)pvClMsg;
  }
inline unsigned short  IEventData :: highNumber ( ) const
  {
  return (unsigned short)((unsigned long)pvClMsg >> 16);
  }
inline unsigned short  IEventData :: number1 ( ) const
  {
  return lowNumber();
  }
inline unsigned short  IEventData :: number2 ( ) const
  {
  return highNumber();
  }
inline unsigned long  IEventData :: asUnsignedLong ( ) const
  {
  return (unsigned long)pvClMsg;
  }
inline long  IEventData :: asLong ( ) const
  {
  return (long)pvClMsg;
  }
inline IEventData :: operator char* ( ) const
  {
  return (char*)pvClMsg;
  }
inline IEventData :: operator unsigned long ( ) const
  {
  return (unsigned long)pvClMsg;
  }
#line 22 "F:\vacpp\INCLUDE\ibhandle.hpp"
class ostream;
class IString;

#pragma pack(4)

class IHandle : public IBase {
typedef IBase
  Inherited;
public:

typedef unsigned long
  Value;
#line 36
  IHandle ( Value value );
#line 40
IString
  asString    ( ) const,
  asDebugInfo ( ) const;

friend ostream
 &operator << ( ostream&       aStream,
                const IHandle& aHandle );

unsigned long
  asUnsigned  ( ) const;
#line 52
  operator Value ( ) const;

protected:

Value
  handle;
};
#line 61
class ISemaphoreHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  ISemaphoreHandle ( Value hsem = 0 );
};

#pragma pack()
#line 28 "F:\vacpp\INCLUDE\ibhandle.inl"
inline IHandle :: IHandle ( Value value )
  : handle( value )
  {
  }

inline unsigned long IHandle :: asUnsigned ( ) const
  {
  return (unsigned long) this->handle;
  }

inline IHandle :: operator Value ( ) const
  {
  return this->handle;
  }

inline ISemaphoreHandle :: ISemaphoreHandle ( Value value )
  : IHandle( value )
  {
  }
#line 40 "F:\vacpp\INCLUDE\ihandle.hpp"
struct _WidgetRec;
struct _XtAppStruct;
struct _XGC;
struct _XDisplay;
struct _XrmHashBucketRec;

#pragma pack(4)

class IWindowHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IWindowHandle ( Value hwnd = 0 );
#line 58
Boolean
  isValid ( ) const;
#line 62
enum BroadcastTo {
  descendants,
  frames,
  frameDescendants
  };

IEventResult
  sendEvent  ( unsigned long           eventId,
               const IEventParameter1& parm1 = 0ul,
               const IEventParameter2& parm2 = 0ul ) const;

void
  sendEvents ( unsigned long           eventId,
               const IEventParameter1& parm1 = 0ul,
               const IEventParameter2& parm2 = 0ul,
               BroadcastTo             value = descendants ) const;

void
  postEvent  ( unsigned long           eventId,
               const IEventParameter1& parm1 = 0ul,
               const IEventParameter2& parm2 = 0ul ) const,

  postEvents ( unsigned long           eventId,
               const IEventParameter1& parm1 = 0ul,
               const IEventParameter2& parm2 = 0ul,
               BroadcastTo             value = descendants ) const;

};

class IAnchorBlockHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IAnchorBlockHandle ( Value hab = 0 );

};
#line 101
class IModuleHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IModuleHandle ( Value hmod = 0 );

};
#line 112
class IPointerHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IPointerHandle ( Value                 hpointer = 0 );
  IPointerHandle ( const IPointerHandle& aHandle );
 ~IPointerHandle ( );

IPointerHandle
 &operator =     ( const IPointerHandle& aHandle );

};

class ISystemPointerHandle : public IPointerHandle {
typedef IPointerHandle
  Inherited;
public:

enum Identifier {
  arrow,
  text,
  wait,
  move,
  sizeNWSE,
  sizeNESW,
  sizeHorizontal,
  sizeVertical,
  standardApplication,
  information,
  question,
  error,
  warning,
  illegalOperation,
  singleFile,
  multipleFile,
  folder,
  program,
  dragFade
  };
#line 154
  ISystemPointerHandle ( Identifier pointerId,
                         Boolean    makeCopy = false );
 ~ISystemPointerHandle ( );

};

class IStringHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IStringHandle ( Value hstr = 0 );

};
#line 170
class IPresSpaceHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IPresSpaceHandle ( Value hps = 0 );
};

class IBitmapHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IBitmapHandle ( Value value = 0 );
  IBitmapHandle ( const IBitmapHandle& aHandle );
 ~IBitmapHandle ( );

IBitmapHandle
 &operator =    ( const IBitmapHandle& aHandle );

};

class ISystemBitmapHandle : public IBitmapHandle {
typedef IBitmapHandle
  Inherited;
public:

enum Identifier {
  systemMenu,
  systemMenuPressed,
  scrollBarUpArrow,
  scrollBarUpArrowPressed,
  scrollBarUpArrowDisabled,
  scrollBarDownArrow,
  scrollBarDownArrowPressed,
  scrollBarDownArrowDisabled,
  scrollBarRightArrow,
  scrollBarRightArrowPressed,
  scrollBarRightArrowDisabled,
  scrollBarLeftArrow,
  scrollBarLeftArrowPressed,
  scrollBarLeftArrowDisabled,
  menuCheckMark,
  menuAttached,
  checkBoxCheck,
  comboBoxDownArrow,
  pushButtonCorners,
  minimizeButton,
  minimizeButtonPressed,
  maximizeButton,
  maximizeButtonPressed,
  restoreButton,
  restoreButtonPressed,
  childSystemMenu,
  childSystemMenuPressed,
  drive,
  file,
  folder,
  collapsedTree,
  expandedTree,
  program,
  sizeBox,
  smallSystemMenu
  };
#line 236
  ISystemBitmapHandle ( Identifier bitmapId );
 ~ISystemBitmapHandle ( );

};

class IProfileHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IProfileHandle ( Value hini = 0 );
#line 249
};

class IMessageQueueHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IMessageQueueHandle ( Value hmq = 0 );
#line 259
void
  postEvent  ( unsigned long           eventId,
               const IEventParameter1& parm1 = 0ul,
               const IEventParameter2& parm2 = 0ul ) const;
static void
  postEvent  ( const IMessageQueueHandle&    handle,
               unsigned long           eventId,
               const IEventParameter1& parm1 = 0ul,
               const IEventParameter2& parm2 = 0ul ),

  postEvents ( unsigned long           eventId,
               const IEventParameter1& parm1 = 0ul,
               const IEventParameter2& parm2 = 0ul );
};

class IAccelTblHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IAccelTblHandle ( Value haccel = 0 );

};

class IThreadId : public IHandle {
typedef IHandle
  Inherited;
public:

  IThreadId ( Value tid = 0 );

};

class IProcessId : public IHandle {
typedef IHandle
  Inherited;
public:

  IProcessId ( Value pid = 0 );

};

class IEnumHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IEnumHandle ( Value henum = 0 );

};

class IRegionHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IRegionHandle ( Value hregion = 0 );

};
#line 321
typedef IWindowHandle IMenuHandle;

#pragma pack()
#line 40 "F:\vacpp\INCLUDE\ihandle.inl"
inline IWindowHandle :: IWindowHandle ( Value value )
  : IHandle( value )
  {
  }

inline IAnchorBlockHandle :: IAnchorBlockHandle ( Value value )
  : IHandle( value )
  {
  }

inline IModuleHandle :: IModuleHandle ( Value value )
  : IHandle( value )
  {
  }

inline IStringHandle :: IStringHandle ( Value value )
  : IHandle( value )
  {
  }
#line 71
inline IPresSpaceHandle :: IPresSpaceHandle ( Value value )
  : IHandle( value )
  {
  }
#line 88
inline IProfileHandle :: IProfileHandle ( Value value )
  : IHandle( value )
  {
  }

inline IMessageQueueHandle :: IMessageQueueHandle ( Value value )
  : IHandle( value )
  {
  }

inline IAccelTblHandle :: IAccelTblHandle ( Value value )
  : IHandle( value )
  {
  }

inline IProcessId :: IProcessId ( Value value )
  : IHandle( value )
  {
  }

inline IThreadId :: IThreadId ( Value value )
  : IHandle( value )
  {
  }

inline IEnumHandle :: IEnumHandle ( Value value )
  : IHandle( value )
  {
  }

inline IRegionHandle :: IRegionHandle ( Value value )
  : IHandle( value )
  {
  }
#line 22 "F:\vacpp\INCLUDE\ievent.hpp"
class IEventPrivateData;
class IWindow;

#pragma pack(4)

class IEvent : public IVBase {
typedef IVBase
  Inherited;
public:

  IEvent    ( const IWindowHandle&    handle,
              unsigned long           eventId,
              const IEventParameter1& parameter1,
              const IEventParameter2& parameter2 );

  IEvent    ( IWindow*                window,
              unsigned long           eventId,
              const IEventParameter1& parameter1,
              const IEventParameter2& parameter2 );

  IEvent    ( const IEvent&           event );

IEvent
 &operator= ( const IEvent&           event );

virtual
 ~IEvent    ( );
#line 51
unsigned long
  eventId    ( ) const;

IEventParameter1
  parameter1 ( ) const;

IEventParameter2
  parameter2 ( ) const;

IEventResult
  result     ( ) const;

IEvent
 &setResult  ( const IEventResult& eventResult ),
 &setResult  ( Boolean             eventResult );
#line 69
virtual IWindow
 *window               ( ) const,
 *dispatchingWindow    ( ) const,
 *controlWindow        ( ) const;

IWindowHandle
  handle               ( ) const,
  controlHandle        ( ) const;

IEvent
 &setHandle            ( const IWindowHandle& handle ),
 &setDispatchingHandle ( const IWindowHandle& handle ),
 &setControlHandle     ( const IWindowHandle& handle );

private:

friend class IWindow;
IWindowHandle
  hCl,
  p_dispatchingHandle,
  p_controlHandle;
unsigned long
  ulClEvtId;
IEventData
  epCl1,
  epCl2;
IEventResult
  erCl;
IEventPrivateData
 *pData;
};

#pragma pack()
#line 29 "F:\vacpp\INCLUDE\ievent.inl"
inline  IWindowHandle IEvent::handle() const
{ return hCl; }

inline  IWindowHandle IEvent::controlHandle() const
{ return p_controlHandle; }

inline  IEvent& IEvent::setHandle  ( const IWindowHandle& handle )
{
  hCl = handle;
  return *this;
}

inline  IEvent& IEvent::setDispatchingHandle  ( const IWindowHandle& handle )
{
  p_dispatchingHandle = handle;
  return *this;
}

inline  IEvent& IEvent::setControlHandle  ( const IWindowHandle& handle )
{
  p_controlHandle = handle;
  return *this;
}

inline unsigned long IEvent::eventId() const
{ return ulClEvtId; }

inline  IEventParameter1 IEvent::parameter1() const
{ return epCl1; }

inline IEventParameter2 IEvent::parameter2() const
{ return epCl2; }

inline IEvent& IEvent::setResult(const IEventResult& er)
{
  erCl = er;
  return *this;
}

inline IEvent& IEvent::setResult(Boolean er)
{
  erCl = (IEventResult)er;
  return *this;
}

inline IEventResult IEvent::result() const
{ return erCl; }
#line 23 "F:\vacpp\INCLUDE\ipoint.hpp"
#pragma pack(4)

struct _POINTL;
struct _RECTL;
struct _SIZEL;
struct tagPOINT;
struct tagSIZE;
class  ISize;
class  IWindowHandle;
typedef struct _SIZEL SIZEL;

class IPair : public IBase {
typedef IBase
  Inherited;
public:

typedef long Coord;
#line 42
  IPair ( );
  IPair ( Coord init );
  IPair ( Coord coord1,
          Coord coord2 );
#line 48
Coord
  coord1 ( )  const,
  coord2 ( )  const;

IPair
 &setCoord1 ( Coord coord1 ),
 &setCoord2 ( Coord coord2 );
#line 57
IPair
  minimum ( const IPair& aPair ) const,
  maximum ( const IPair& aPair ) const;
#line 62
IPair
  operator - ( ) const;
#line 66
Boolean
  operator == ( const IPair& aPair ) const,
  operator != ( const IPair& aPair ) const,
  operator <  ( const IPair& aPair ) const,
  operator >  ( const IPair& aPair ) const,
  operator <= ( const IPair& aPair ) const,
  operator >= ( const IPair& aPair ) const;
#line 75
friend IPair
  operator +  ( const IPair& pair1,  const IPair& pair2       ),
  operator *  ( const IPair& pair1,  const IPair& pair2       ),
  operator *  ( const IPair& pair1,  double       multiplier  ),
  operator -  ( const IPair& pair1,  const IPair& pair2       ),
  operator /  ( const IPair& pair1,  const IPair& pair2       ),
  operator /  ( const IPair& pair1,  double       divisor     ),
  operator %  ( const IPair& pair1,  const IPair& pair2       ),
  operator %  ( const IPair& aPair1, long         divisor     );

IPair
 &operator += ( const IPair& aPair ),
 &operator -= ( const IPair& aPair ),
 &operator *= ( const IPair& aPair ),
 &operator *= ( double multiplier ),
 &operator /= ( const IPair& aPair ),
 &operator /= ( double divisor ),
 &operator %= ( const IPair& aPair ),
 &operator %= ( long  divisor );
#line 96
IPair
 &scaleBy  ( double xFactor, double yFactor ),
  scaledBy ( double xFactor, double yFactor ) const;
#line 101
double
  distanceFrom ( const IPair& aPair ) const;

long
  dotProduct ( const IPair& aPair ) const;

IPair
 &transpose ( );

friend IPair
  transpose ( const IPair& aPair );
#line 114
IString
  asString ( ) const,
  asDebugInfo ( ) const;
#line 119
friend ostream
 &operator << ( ostream&          aStream,
                const IPair&      aRectangle );

private:

Coord
  coordCl1,
  coordCl2;
};

class IPoint : public IPair {
typedef IPair
  Inherited;

public:

  IPoint ( );
  IPoint ( const IPair& pair );
  IPoint ( Coord x, Coord y );
  IPoint ( const struct _POINTL& ptl );
#line 142
Coord
  x      ( ) const,
  y      ( ) const;

IPoint
 &setX ( Coord X ),
 &setY ( Coord Y );
#line 151
struct _POINTL
  asPOINTL ( ) const;
};

class ISize  : public IPair {
typedef IPair
  Inherited;
public:

  ISize ( );
  ISize ( const IPair& pair );
  ISize ( Coord width, Coord height );
  ISize ( const SIZEL& sizl );
  ISize ( const struct _RECTL& rcl );
#line 167
Coord
  width  ( ) const,
  height ( ) const;

ISize
 &setWidth  ( Coord cx ),
 &setHeight ( Coord cy );
#line 176
SIZEL
  asSIZEL ( ) const;
};

class IRange : public IPair {
typedef IPair
  Inherited;

public:

  IRange ( );
  IRange ( const IPair& aPair );
  IRange ( Coord lower, Coord upper );
#line 191
Coord
  lowerBound ( ) const,
  upperBound ( ) const;

IRange
 &setUpperBound ( Coord upper ),
 &setLowerBound ( Coord lower );
#line 200
Boolean
  includes ( Coord aValue ) const;
};

#pragma pack()
#line 29 "F:\vacpp\INCLUDE\ipoint.inl"
inline IPair::IPair ( )
  : coordCl1( 0 ), coordCl2( 0 )
  {
  }
inline IPair::IPair ( Coord init )
  : coordCl1( init ), coordCl2( init )
  {
  }
inline IPair::IPair ( Coord coord1, Coord coord2 )
  : coordCl1( coord1 ), coordCl2( coord2 )
  {
  }
inline IPair::Coord  IPair::coord1 ( )  const
  {
  return coordCl1;
  }
inline IPair::Coord  IPair::coord2 ( )  const
  {
  return coordCl2;
  }
inline IPair& IPair::setCoord1 ( Coord coord1 )
  {
  coordCl1 = coord1;
  return *this;
  }
inline IPair& IPair::setCoord2 ( Coord coord2 )
  {
  coordCl2 = coord2;
  return *this;
  }
inline IPair IPair::operator - ( ) const
  {
  return IPair( -coordCl1, -coordCl2 );
  }
inline IBase::Boolean IPair::operator == ( const IPair& pair ) const
  {
  return ( coordCl1 == pair.coordCl1 && coordCl2 == pair.coordCl2);
  }
inline IBase::Boolean IPair::operator != ( const IPair& pair ) const
  {
  return !( *this == pair );
  }
inline IBase::Boolean IPair::operator <  ( const IPair& pair ) const
  {
  return ( coordCl1 < pair.coordCl1 && coordCl2 < pair.coordCl2 );
  }
inline IBase::Boolean IPair::operator >  ( const IPair& pair ) const
  {
  return ( coordCl1 > pair.coordCl1 && coordCl2 > pair.coordCl2 );
  }
inline IBase::Boolean IPair::operator <= (const IPair& pair ) const
  {
  return ( coordCl1 <= pair.coordCl1 && coordCl2 <= pair.coordCl2);
  }
inline IBase::Boolean IPair::operator >= ( const IPair& pair ) const
  {
  return ( coordCl1 >= pair.coordCl1 && coordCl2 >= pair.coordCl2);
  }
inline IPair operator +  ( const IPair& pair1, const IPair& pair2 )
  {
  return IPair( pair1.coordCl1 + pair2.coordCl1,
                pair1.coordCl2 + pair2.coordCl2 );
  }
inline IPair operator *  ( const IPair& pair1, const IPair& pair2 )
  {
  return IPair( pair1.coordCl1 * pair2.coordCl1,
                pair1.coordCl2 * pair2.coordCl2 );
  }
inline IPair operator *  ( const IPair& pair1, double d )
  {
  return IPair( (IPair::Coord)(d * pair1.coordCl1),
                (IPair::Coord)(d * pair1.coordCl2));
  }
inline IPair operator -  ( const IPair& pair1, const IPair& pair2 )
  {
  return IPair( pair1.coordCl1 - pair2.coordCl1,
                pair1.coordCl2 - pair2.coordCl2);
  }
inline IPair operator / ( const IPair& pair1, const IPair& pair2 )
  {
  return IPair( pair1.coordCl1 / pair2.coordCl1,
                pair1.coordCl2 / pair2.coordCl2);
  }
inline IPair operator /  ( const IPair& pair1, double d )
  {
  return IPair( (IPair::Coord)(pair1.coordCl1 / d),
                (IPair::Coord)(pair1.coordCl2 / d) );
  }
inline IPair operator %  ( const IPair& pair1, const IPair& pair2 )
  {
  return IPair( pair1.coordCl1 % pair2.coordCl1,
                pair1.coordCl2 % pair2.coordCl2 );
  }
inline IPair operator %  ( const IPair& pair1, IPair::Coord d )
  {
  return IPair( pair1.coordCl1 % d,
                pair1.coordCl2 % d );
  }
inline IPair& IPair::operator += ( const IPair &aPair )
  {
  return (*this).setCoord1( coordCl1 + aPair.coordCl1 ).
                 setCoord2( coordCl2 + aPair.coordCl2 );
  }
inline IPair& IPair::operator -= ( const IPair &aPair )
  {
  return (*this).setCoord1( coordCl1 - aPair.coordCl1 ).
                 setCoord2( coordCl2 - aPair.coordCl2 );
  }
inline IPair& IPair::operator *= ( const IPair &aPair )
  {
  return (*this).setCoord1( coordCl1 * aPair.coordCl1 ).
                 setCoord2( coordCl2 * aPair.coordCl2 );
  }
inline IPair& IPair::operator *= ( double d )
  {
  return (*this).setCoord1( (Coord)(coordCl1 * d) ).
                 setCoord2( (Coord)(coordCl2 * d) );
  }
inline IPair& IPair::operator /= ( const IPair &aPair )
  {
  return (*this).setCoord1( coordCl1 / aPair.coordCl1 ).
                 setCoord2( coordCl2 / aPair.coordCl2 );
  }
inline IPair& IPair::operator /= ( double d )
  {
  return (*this).setCoord1( (Coord)(coordCl1 / d) ).
                 setCoord2( (Coord)(coordCl2 / d) );
  }
inline IPair& IPair::operator %= ( const IPair &aPair )
  {
  return (*this).setCoord1( coordCl1 % aPair.coordCl1 ).
                 setCoord2( coordCl2 % aPair.coordCl2 );
  }
inline IPair& IPair::operator %= ( Coord d )
  {
  return (*this).setCoord1( coordCl1 % d ).
                 setCoord2( coordCl2 % d );
  }
inline long IPair::dotProduct( const IPair &aPair ) const
  {
  return coordCl1 * aPair.coordCl1 + coordCl2 * aPair.coordCl2;
  }
inline IPair transpose ( const IPair &aPair )
  {
  return IPair( aPair.coordCl2, aPair.coordCl1 );
  }
inline IPair& IPair::transpose ( )
  {
  *this = ::transpose( *this );
  return *this;
  }
inline IPair& IPair :: scaleBy ( double xfact, double yfact )
  {
  setCoord1( (Coord)(coordCl1 * xfact) ).setCoord2( (Coord)(coordCl2 * yfact) );
  return *this;
  }
inline IPair IPair :: scaledBy ( double xfact, double yfact ) const
  {
  IPair result( *this );
  return result.scaleBy( xfact, yfact );
  }

inline IPoint::IPoint ( )
  {
  }
inline IPoint::IPoint ( const IPair& pair )
  : IPair( pair )
  {
  }
inline IPoint::IPoint ( Coord x, Coord y )
  : IPair( x, y )
  {
  }
#line 214
inline IPair::Coord IPoint::x ( ) const
  {
  return coord1();
  }
inline IPair::Coord IPoint::y ( ) const
  {
  return coord2();
  }
inline IPoint& IPoint::setX ( Coord x )
  {
  setCoord1( x );
  return *this;
  }
inline IPoint& IPoint::setY ( Coord y )
  {
  setCoord2( y );
  return *this;
  }
#line 234
inline ISize::ISize ( )
  {
  }
inline ISize::ISize ( const IPair& pair )
  : IPair( pair )
  {
  }
inline ISize::ISize ( Coord width, Coord height )
  : IPair( width, height )
  {
  }
#line 263
inline IPair::Coord ISize::width ( ) const
  {
  return  coord1();
  }
inline IPair::Coord ISize::height ( ) const
  {
  return  coord2();
  }
inline ISize& ISize::setWidth ( Coord cx )
  {
  setCoord1( cx );
  return *this;
  }
inline ISize& ISize::setHeight ( Coord cy )
  {
  setCoord2( cy );
  return *this;
  }
#line 283
inline IRange::IRange ( )
  : IPair( 0, 0 )
  {
  }
inline IRange::IRange ( const IPair& pair )
  : IPair( pair )
  {
  }
inline IRange::IRange ( Coord lowerBound, Coord upperBound )
  : IPair( lowerBound, upperBound )
  {
  }
inline IPair::Coord IRange::lowerBound ( ) const
  {
  return coord1();
  }
inline IPair::Coord IRange::upperBound ( ) const
  {
  return coord2();
  }
inline IRange& IRange::setLowerBound ( Coord lowerBound )
  {
  setCoord1( lowerBound );
  return *this;
  }
inline IRange& IRange::setUpperBound ( Coord upperBound )
  {
  setCoord2( upperBound );
  return *this;
  }
inline IBase::Boolean IRange::includes ( Coord aValue ) const
  {
  return ( aValue >= lowerBound() && aValue <= upperBound() );
  }
#line 25 "F:\vacpp\INCLUDE\iwindow.hpp"
extern "C" {
  extern void* _System _pfnwpICWinProc ( unsigned long,
                                         unsigned long,
                                         void*,
                                         void* );
}

class IColor;
class IDMItemProvider;
class IException;
class IFont;
class IHandler;
class INotificationEvent;
class IRectangle;
class IString;
class IBidiSettingsData;
class IChildCursorData;
class IWindowBidiData;
class IWindowData;
class IWindowNotifyHandler;
class IGraphicContext;

#pragma pack(4)

class IWindow : public INotifier {
typedef INotifier
  Inherited;

public:

  IWindow ( unsigned long        identifier,
            IWindow*             parent );
  IWindow ( const IWindowHandle& handle );

virtual
 ~IWindow ( );
#line 63
class Style : public IBitFlag{friend class IWindow;public: class NegatedStyle : public IBitFlag { friend class Style; public: NegatedStyle operator & ( const NegatedStyle &aFlag ) const { NegatedStyle aResult ( asUnsignedLong() & aFlag.asUnsignedLong(), asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong() ); return aResult; } protected: NegatedStyle ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Style& operator |= ( const Style &aFlag ) { Style tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedStyle operator ~ ( ) const { NegatedStyle aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Style& operator &= ( const NegatedStyle &aFlag ) { Style tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Style operator | ( const Style &aFlag ) const { Style aResult ( asUnsignedLong() | aFlag.asUnsignedLong(), asExtendedUnsignedLong() | aFlag.asExtendedUnsignedLong() ); return aResult; } Style operator & ( const NegatedStyle &aFlag ) const { Style aResult ( asUnsignedLong() & aFlag.asUnsignedLong(), asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong() ); return aResult; } unsigned long operator & ( const Style &aFlag ) const { unsigned long ulResult = asUnsignedLong() & aFlag.asUnsignedLong(); return ( ulResult | (asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong()) ); }protected: Style ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};
static const Style
  noStyle,
  visible,
  disabled,
  clipChildren,
  clipSiblings,
  clipToParent,
  saveBits,
  synchPaint;

virtual unsigned long
  convertToGUIStyle ( const IBitFlag& style,
                      Boolean         extendedOnly = false ) const;
#line 79
virtual IWindow
 &moveTo     ( const IPoint& newPosition ),
 &sizeTo     ( const ISize& newSize ),
 &moveSizeTo ( const IRectangle& newSizeAndPosition );

virtual IPoint
  position   ( ) const;

virtual ISize
  parentSize ( ) const,
  size       ( ) const;

virtual IRectangle
  nativeRect ( ) const,
  rect       ( ) const;

static ISize
  parentSize ( const IWindowHandle& windowHandle );
#line 99
virtual IWindow
 &setOwner                  ( const IWindow* newOwner ),
 &setParent                 ( const IWindow* newParent ),
 &setId                     ( unsigned long  newIdentifier ),
 &enable                    ( Boolean        enableWindow = true ),
 &disable                   ( ),
 &setFocus                  ( );

IWindow
 *parent                    ( ) const,
 *owner                     ( ) const;

Boolean
  isEnabled                 ( ) const,
  hasFocus                  ( ) const,
  isValid                   ( ) const;

virtual Boolean
  isGroup                   ( ) const,
  isTabStop                 ( ) const,
  isFrameWindow             ( ) const;

static IWindow
 *desktopWindow             ( );

static IWindow
 *objectWindow              ( );

virtual IWindowHandle
  handle                    ( ) const;

static IWindow
 *windowWithHandle          ( const IWindowHandle& windowHandle,
                              Boolean              allThreads = true ),
 *windowWithOwner           ( unsigned long        identifier,
                              const IWindow*       owner,
                              Boolean              allThreads = true ),
 *windowWithParent          ( unsigned long        identifier,
                              const IWindow*       parent,
                              Boolean              allThreads = true );

static IWindowHandle
  handleWithParent          ( unsigned long        identifier,
                              const IWindowHandle& parent );

static Boolean
  isWindowValid             ( const IWindow*       window );

static IWindowHandle
  handleWithPointerCaptured ( );

unsigned long
  id                        ( ) const;

IMessageQueueHandle
  messageQueue              ( ) const;
#line 157
virtual IWindow
 &capturePointer     ( Boolean capture = true ),
 &releasePointer     ( );

virtual Boolean
  hasPointerCaptured ( ) const;
#line 165
static void
  movePointerTo   ( const IPoint& position );

static IPoint
  pointerPosition ( );
#line 172
enum SiblingOrder {
  onTopOfSiblings,
  behindSiblings
  };

virtual IWindow
 &positionBehindSiblings ( ),
 &positionOnSiblings     ( ),
 &positionBehindSibling  ( const IWindowHandle& siblingWindow );

static void
 setDefaultOrdering      ( SiblingOrder         order );
static SiblingOrder
 defaultOrdering         ( );
#line 188
enum EventType {
  command=1,
  systemCommand,
  control,
  help,
  character
  };

virtual const IWindow
 &postEvent ( unsigned long           eventId,
              const IEventParameter1& parm1 = 0,
              const IEventParameter2& parm2 = 0 ) const,
 &postEvent ( const IEvent&           event )     const,
 &postEvent ( EventType               eventType,
              const IEventParameter1& parm1 = 0,
              const IEventParameter2& parm2 = 0 ) const;

virtual IEventResult
  sendEvent ( unsigned long           eventId,
              const IEventParameter1& parm1 = 0,
              const IEventParameter2& parm2 = 0 ) const,
  sendEvent ( const IEvent&           event )     const,
  sendEvent ( EventType               eventType,
              const IEventParameter1& parm1 = 0,
              const IEventParameter2& parm2 = 0 ) const;
#line 215
enum RefreshType {
  paintAll,
  immediate,
  paintAllImmediate
  };

virtual IWindow
 &show               ( Boolean           showWindow = true ),
 &hide               ( ),
 &enableUpdate       ( Boolean           enableWindow = true ),
 &disableUpdate      ( ),
 &refresh            ( RefreshType       type=paintAll ),
 &refresh            ( const IRectangle& invalidRectangle,
                       Boolean           immediate=false ),
 &showSourceEmphasis ( Boolean           show = true ),
 &hideSourceEmphasis ( );

Boolean
  isVisible          ( ) const,
  isShowing          ( ) const;

virtual IPresSpaceHandle
  presSpace          ( ) const;

virtual void
  releasePresSpace   ( const IPresSpaceHandle& presentationSpaceHandle ) const;
#line 245
IWindow
 &setAutoDeleteObject  ( Boolean autoDelete = true ),
 &setAutoDestroyWindow ( Boolean autoDestroy = false );

Boolean
  isAutoDeleteObject   ( ) const,
  isAutoDestroyWindow  ( ) const;
#line 254
IDMItemProvider
 *itemProvider    ( ) const;

IWindow
 &setItemProvider ( IDMItemProvider* dragProvider );

class ChildCursor : public IVBase {
typedef IVBase
  Inherited;
public:

  ChildCursor ( IWindow& parent );
virtual
 ~ChildCursor ( );
#line 270
virtual Boolean
  setToFirst ( ),
  setToNext  ( ),
  isValid    ( ) const;

virtual void
  invalidate ( );

private:

ChildCursor
 &operator =  ( const ChildCursor& cursor );
  ChildCursor ( const ChildCursor& cursor );
#line 285
friend class IWindow;

IChildCursorData
 *pCursorData;

IEnumHandle
  enumHandle;
#line 294
IWindowHandle
  hwnd,
  hwndParent;
};
#line 300
IWindowHandle
  childAt ( const ChildCursor& cursor ) const;
#line 304
virtual IWindowHandle
  defaultPushButton  ( ) const,
  matchForMnemonic   ( unsigned short character ) const;

enum Layout {
  windowCreated=1,
  colorChanged=2,
  sizeChanged=4,
  minimumSizeChanged=8,
  childMinimumSizeChanged=16,
  fontChanged=32,
  fontPropogated=64,
  layoutChanged=128,
  immediateUpdate=256,
  childWindowCreated=512,
  windowDestroyed=1024,
  childWindowDestroyed=2048
  };

virtual IWindow
 &setLayoutDistorted ( unsigned long layoutAttributesOn,
                       unsigned long layoutAttributesOff );

virtual Boolean
  isLayoutDistorted  ( unsigned long layoutAttribute ) const;

IWindow
 &resetMinimumSize   ( ),
 &setMinimumSize     ( const ISize& size );

ISize
  minimumSize        ( Boolean windowCalculatedSize = false ) const;

virtual IRectangle
  layoutAdjustment   ( ) const,
  visibleRectangle   ( ) const;
#line 342
static IPoint
  mapPoint ( const IPoint&        point,
             const IWindowHandle& from,
             const IWindowHandle& to );
#line 348
virtual IString
  asString    ( ) const,
  asDebugInfo ( ) const;

class ExceptionFn : public IVBase {
typedef IVBase
  Inherited;
public:

virtual
 ~ExceptionFn ( );
#line 361
virtual Boolean
  handleException ( IException& dispatcherException,
                    IEvent&     exceptionEvent ) = 0;
};
#line 368
static IWindow::ExceptionFn
 *setExceptionFunction ( IWindow::ExceptionFn* exceptionFunction ),
 *exceptionFunction    ( );

virtual Boolean
  handleException      ( IException& dispatcherException,
                         IEvent&     exceptionEvent );
#line 377
virtual IColor
  foregroundColor              ( ) const,
  backgroundColor              ( ) const,
  borderColor                  ( ) const;

virtual IWindow
 &setForegroundColor           ( const IColor& color ),
 &setBackgroundColor           ( const IColor& color ),
 &setBorderColor               ( const IColor& color );

virtual IColor
  shadowColor                  ( ) const,
  disabledForegroundColor      ( ) const,
  disabledBackgroundColor      ( ) const,
  hiliteForegroundColor        ( ) const,
  hiliteBackgroundColor        ( ) const,
  activeColor                  ( ) const,
  inactiveColor                ( ) const;

virtual IWindow
 &setShadowColor               ( const IColor& color ),
 &setDisabledForegroundColor   ( const IColor& color ),
 &setDisabledBackgroundColor   ( const IColor& color ),
 &setHiliteForegroundColor     ( const IColor& color ),
 &setHiliteBackgroundColor     ( const IColor& color ),
 &setActiveColor               ( const IColor& color ),
 &setInactiveColor             ( const IColor& color ),
 &resetForegroundColor         ( ),
 &resetBackgroundColor         ( ),
 &resetBorderColor             ( ),
 &resetShadowColor             ( ),
 &resetDisabledForegroundColor ( ),
 &resetDisabledBackgroundColor ( ),
 &resetHiliteForegroundColor   ( ),
 &resetHiliteBackgroundColor   ( ),
 &resetActiveColor             ( ),
 &resetInactiveColor           ( );
#line 416
virtual IWindow
 &setFont       ( const IFont& font );

virtual IWindow
 &resetFont     ( );

virtual IFont
  font          ( ) const;

ISize
  characterSize ( ) const;
#line 429
virtual IWindow
 &enableNotification       ( Boolean enable = true ),
 &disableNotification      ( );

virtual Boolean
  isEnabledForNotification ( ) const;

virtual IWindow
 ¬ifyObservers          ( const INotificationEvent& event );
#line 440
static INotificationId const
  sizeId,
  positionId,
  visibleId,
  enableId,
  deleteId,
  focusId,
  foregroundColorId,
  backgroundColorId,
  borderColorId,
  shadowColorId,
  disabledForegroundColorId,
  disabledBackgroundColorId,
  activeColorId,
  inactiveColorId,
  hiliteForegroundColorId,
  hiliteBackgroundColorId,
  fontId,
  commandId,
  systemCommandId;
#line 462
Boolean
  dispatchRemainingHandlers ( IEvent& event, Boolean callDefProc = true );
#line 466
class BidiSettings;

Boolean
  isBidiSupported ( ) const;

enum BidiTextType {
  visual,
  implicit
  };

enum BidiTextOrientation {
  textLeftToRight,
  textRightToLeft,
  textContextual
  };

enum BidiLayout {
  layoutLeftToRight,
  layoutRightToLeft
  };

enum BidiNumeralType {
  arabic,
  asStored,
  national,
  contextual
  };

enum BidiTextShape {
  displayShaped,
  saveShaped,
  nominalShape,
  initialShape,
  middleShape,
  finalShape,
  isolatedShape
  };

virtual IWindow
 &applyBidiSettings ( const BidiSettings& settings,
                      Boolean             childInherit = true,
                      Boolean             refresh      = true );

class BidiSettings : public IVBase {
typedef IVBase
  Inherited;
public:

  BidiSettings ( const IWindow& window );

virtual
 ~BidiSettings ( );
#line 520
virtual BidiSettings
 &setTextType                   ( BidiTextType        textType ),
 &setTextOrientation            ( BidiTextOrientation textOrientation ),
 &setWindowLayout               ( BidiLayout          windowLayout ),
 &setNumeralDisplay             ( BidiNumeralType     numeralDisplay ),
 &enableSymmetricSwapping       ( Boolean             enable = true ),
 &disableSymmetricSwapping      ( ),
 &enableWordByWordReordering    ( Boolean             enable = true ),
 &disableWordByWordReordering   ( ),
 &setTextShape                  ( BidiTextShape       textShape );

BidiTextType
  textType                      ( ) const;
BidiTextOrientation
  textOrientation               ( ) const;
BidiLayout
  windowLayout                  ( ) const;
BidiNumeralType
  numeralDisplay                ( ) const;
Boolean
  isSymmetricSwappingEnabled    ( ) const;
Boolean
  isWordByWordReorderingEnabled ( ) const;
BidiTextShape
  textShape                     ( ) const;

private:

friend class IWindow;
  BidiSettings ( const BidiSettings& settings );
BidiSettings
 &operator=    ( const BidiSettings& settings );
#line 554
IBidiSettingsData
 *fBidiSettingsData;
};
#line 559
protected:

virtual IWindowHandle
 create            ( unsigned long         id,
                     const char*           text,
                     unsigned long         style,
                     const char*           windowClass,
                     const IWindowHandle&  parent,
                     const IWindowHandle&  owner,
                     const IRectangle&     initRect,
                     const void*           ctlData,
                     const void*           presParams,
                     IWindow::SiblingOrder ordering = defaultOrdering() );
#line 574
IWindow
 &addHandler       ( IHandler* newHandler ),
 &removeHandler    ( IHandler* oldHandler );

Boolean
  isPrimaryWindow  ( ) const;

IWindow
 &setColor         ( unsigned long colorArea,
                     const IColor& color ),
 &resetColor       ( unsigned long colorArea );

virtual IWindow
 &setStyle         ( unsigned long style ),
 &setExtendedStyle ( unsigned long extendedStyle );

virtual unsigned long
  style            ( ) const,
  extendedStyle    ( ) const;

IColor
  color            ( unsigned long colorArea ) const,
  color            ( unsigned long colorArea,
                     const IColor& defaultColor ) const;
unsigned short
  windowUShort     ( long index ) const;

unsigned long
  windowULong      ( long index ) const;

IWindow
 &setWindowData    ( long           index,
                     unsigned short ushort ),
 &setWindowData    ( long           index,
                     unsigned long  ulong );
#line 613
  IWindow ( );
#line 616
virtual ISize
  calcMinimumSize  ( ) const;
IWindow
 &saveMinimumSize  ( const ISize& size );
ISize
  savedMinimumSize ( ) const;
#line 624
IWindow
 &startHandlingEventsFor ( const IWindowHandle& windowHandle ),
 &startHandlingEventsFor ( unsigned long        identifier,
                           IWindow*             parent );
static void
  addToWindowSet         ( IWindow*             window,
                           const IWindowHandle& windowHandle ),
  removeFromWindowSet    ( IWindow*             window );
#line 634
Boolean
  dispatch               ( IEvent& event );

IWindow
 &defaultProcedure       ( IEvent& event );

Boolean
  deleteIsInProcess      ( ) const;
#line 645
virtual IWindow
 &addObserver            ( IObserver&            observer,
                           const IEventData&     userData = IEventData(0) ),
 &removeObserver         ( IObserver&            observer ),
 &removeAllObservers     ( );

IObserverList
 &observerList           ( ) const;

IWindow
 &setNotificationHandler ( IWindowNotifyHandler* notifyHandler );

IWindowNotifyHandler
 *notificationHandler    ( ) const;

virtual IWindow
  ¬ifyObservers ( const INotificationId& notification );

private:

IWindow     ( const IWindow& window );
IWindow
 &operator= ( const IWindow& window );
#line 670
friend class IHandle;
friend class IHandler;
friend class IFileDialog;
friend class IFontDialog;
friend class IWindow::BidiSettings;
#line 677
enum State {
  autoDeleteObject=1,
  autoDestroyWindow=2,
  deleteInProcess=4,
  primaryWindow=8,
  addedToList=16,
  dispatchInProcess=32,
  needsDelete=64,
  updateRHtInProgress=128,
  neverBeenShown=256,
  forgetBitGravity=512
  };

friend unsigned long const
 &key             ( IWindow* const& window );

friend void* _System
  _pfnwpICWinProc ( unsigned long hwnd,
                    unsigned long ulMsg,
                    void*         mp1,
                    void*         mp2 );
#line 701
static void
  cleanUpHandler          ( IHandler& handler );
#line 706
IWindow
 &setDeleteInProcess  ( ),
 &cleanUp             ( );

IWinProc
 *setDefaultProcedure ( IWinProc* newDefProc );

static IWindowBidiData
 *fgBidiData;

IWindowData
 *pWindowData;

unsigned long
  hwnd;
#line 724
public:
static IWindow
 *windowWithId ( unsigned long        identifier,
                 const IWindow*       owner,
                 Boolean              allThreads = true );
Boolean
  isDisabled   ( ) const;
static IWindowHandle
  handleWithId ( unsigned long        identifier,
                 const IWindowHandle& parent );
virtual IWindow
 &refresh      ( Boolean              refreshChildren );

};
#line 740
class IBidiSettings : public IVBase {
typedef IVBase
  Inherited;
public:

  IBidiSettings ( const IWindow&         window );
  IBidiSettings ( const IWindowHandle    windowHandle );
  IBidiSettings ( const IGraphicContext& graphicContext );
  IBidiSettings ( const IPresSpaceHandle presSpace );

virtual
 ~IBidiSettings ( );
#line 754
static Boolean
  isBidiSupported ( );

virtual IBidiSettings
 &apply ( const IWindow&         window,
          Boolean                childInherit = true,
          Boolean                refresh      = true ),
 &apply ( const IWindowHandle    windowHandle,
          Boolean                childInherit = true,
          Boolean                refresh      = true ),
 &apply ( const IGraphicContext& graphicContext ),
 &apply ( const IPresSpaceHandle presSpace );
#line 768
enum BidiTextType {
  visual,
  implicit
  };

enum BidiTextOrientation {
  textLeftToRight,
  textRightToLeft,
  textContextual
  };

enum BidiLayout {
  layoutLeftToRight,
  layoutRightToLeft
  };

enum BidiNumeralType {
  arabic,
  asStored,
  national,
  contextual
  };

enum BidiTextShape {
  displayShaped,
  saveShaped,
  nominalShape,
  initialShape,
  middleShape,
  finalShape,
  isolatedShape
  };

virtual IBidiSettings
 &setTextType                   ( BidiTextType        textType ),
 &setTextOrientation            ( BidiTextOrientation textOrientation ),
 &setWindowLayout               ( BidiLayout          windowLayout ),
 &setNumeralDisplay             ( BidiNumeralType     numeralDisplay ),
 &enableSymmetricSwapping       ( Boolean             enable = true ),
 &disableSymmetricSwapping      ( ),
 &enableWordByWordReordering    ( Boolean             enable = true ),
 &disableWordByWordReordering   ( ),
 &setTextShape                  ( BidiTextShape       textShape );

BidiTextType
  textType                      ( ) const;
BidiTextOrientation
  textOrientation               ( ) const;
BidiLayout
  windowLayout                  ( ) const;
BidiNumeralType
  numeralDisplay                ( ) const;
Boolean
  isSymmetricSwappingEnabled    ( ) const;
Boolean
  isWordByWordReorderingEnabled ( ) const;
BidiTextShape
  textShape                     ( ) const;

private:

  IBidiSettings ( const IBidiSettings& settings );
IBidiSettings
 &operator=    ( const IBidiSettings& settings );
#line 834
IBidiSettingsData
 *fBidiSettingsData;
};
#line 839
#pragma pack()
#line 28 "F:\vacpp\INCLUDE\iwindow.inl"
inline unsigned long const& key (IWindow* const& k)
{
  return k->hwnd;
}
#line 20 "F:\vacpp\INCLUDE\icmdevt.hpp"
#pragma pack(4)

class ICommandEvent : public IEvent {
typedef IEvent
  Inherited;
public:

  ICommandEvent ( const IEvent& event );
virtual
 ~ICommandEvent ( );
#line 32
enum Source {
  pushButton,
  menu,
  accelerator,
  unknown
};

Source
  source      ( ) const;
unsigned long
  commandId   ( ) const;

Boolean
  isFromFrame ( ) const;
};

#pragma pack()
#line 28 "F:\vacpp\INCLUDE\icmdevt.inl"
inline unsigned long  ICommandEvent :: commandId ( ) const
  {
  return parameter1().number1();
  }
inline IBase::Boolean  ICommandEvent :: isFromFrame ( ) const
  {

  return (parameter2().number1() & 0x8000) ? true : false;
#line 40
  }
#line 22 "F:\vacpp\INCLUDE\irect.hpp"
#pragma pack(4)

struct _RECTL;
struct tagRECT;
#line 28
class IRectangle : public IBase {
typedef IBase
  Inherited;
public:

 typedef IPair::Coord Coord;
#line 36
  IRectangle ( );

  IRectangle ( const IPoint& point1,
               const IPoint& point2 );

  IRectangle ( const IPoint& point,
               const ISize&  size );

  IRectangle ( Coord point1X,
               Coord point1Y,
               Coord point2X,
               Coord point2Y );

  IRectangle ( const struct _RECTL& rectl);

  IRectangle ( Coord width,
               Coord height      );
  IRectangle ( const IPair& pair );
#line 56
IPoint
  minXMinY        ( ) const,
  minXCenterY     ( ) const,
  minXMaxY        ( ) const,
  centerXMinY     ( ) const,
  centerXCenterY  ( ) const,
  centerXMaxY     ( ) const,
  maxXMinY        ( ) const,
  maxXCenterY     ( ) const,
  maxXMaxY        ( ) const;
#line 69
ISize
  size   ( ) const;

Coord
  area   ( ) const,
  height ( ) const,
  minX   ( ) const,
  minY   ( ) const,
  maxX   ( ) const,
  maxY   ( ) const,
  width  ( ) const;
#line 82
struct _RECTL
  asRECTL ( ) const;

IString
  asString    ( ) const,
  asDebugInfo ( ) const;
#line 90
Boolean
  operator == ( const IRectangle& rectangle ) const,
  operator != ( const IRectangle& rectangle ) const;
#line 95
IRectangle
  operator &  ( const IRectangle& rectangle ) const,
 &operator &= ( const IRectangle& rectangle ),
  operator |  ( const IRectangle& rectangle ) const,
 &operator |= ( const IRectangle& rectangle );
#line 102
IRectangle
  ¢erAt   ( const IPoint& point    ),
   centeredAt ( const IPoint& point    ) const,
  &expandBy   ( const IPair&  pair     ),
  &expandBy   ( Coord         coord    ),
   expandedBy ( const IPair&  pair     ) const,
   expandedBy ( Coord         coord    ) const,
  &moveBy     ( const IPair&  pair     ),
   movedBy    ( const IPair&  pair     ) const,
  &moveTo     ( const IPoint& point    ),
   movedTo    ( const IPoint& point    ) const,
  &scaleBy    ( const IPair&  pair     ),
  &scaleBy    ( Coord         coord    ),
  &scaleBy    ( double        factor   ),
  &scaleBy    ( double        xfactor,
                double        yfactor  ),
   scaledBy   ( const IPair&  pair     ) const,
   scaledBy   ( Coord         coord    ) const,
   scaledBy   ( double        factor   ) const,
   scaledBy   ( double        xfactor,
                double        yfactor  ) const,
  &shrinkBy   ( const IPair&  pair     ),
  &shrinkBy   ( Coord         coord    ),
   shrunkBy   ( const IPair&  pair     ) const,
   shrunkBy   ( Coord         coord    ) const,
  &sizeTo     ( const IPair&  pair     ),
   sizedTo    ( const IPair&  pair     ) const,
  &sizeBy     ( const IPair&  pair     ),
  &sizeBy     ( Coord         factor   ),
  &sizeBy     ( double        factor   ),
  &sizeBy     ( double        xfactor,
                double        yfactor  ),
   sizedBy    ( const IPair&  pair     ) const,
   sizedBy    ( Coord         factor   ) const,
   sizedBy    ( double        factor   ) const,
   sizedBy    ( double        xfactor,
                double        yfactor  ) const;
#line 141
Boolean
  contains   ( const IPoint&     point     ) const,
  contains   ( const IRectangle& rectangle ) const,
  intersects ( const IRectangle& rectangle ) const;
#line 147
IPoint
  bottomLeft   ( ) const,
  bottomCenter ( ) const,
  bottomRight  ( ) const,
  center       ( ) const,
  leftCenter   ( ) const,
  rightCenter  ( ) const,
  topLeft      ( ) const,
  topCenter    ( ) const,
  topRight     ( ) const;

Coord
  bottom ( ) const,
  left   ( ) const,
  right  ( ) const,
  top    ( ) const;
#line 165
friend ostream
 &operator << ( ostream&          stream,
                const IRectangle& rectangle );

protected:

IRectangle
 &validate ( );

private:

IPoint
  origin,
  corner;
};

#pragma pack()
#line 29 "F:\vacpp\INCLUDE\irect.inl"
inline IRectangle :: IRectangle ( )
  : origin( 0, 0 ), corner( 0, 0 )
  {
  }
inline IRectangle :: IRectangle ( const IPoint &point1,
                                  const IPoint &point2 )
  : origin( point1.minimum( point2 ) ), corner( point1.maximum( point2 ) )
  {
  }
inline IRectangle :: IRectangle ( const IPoint &aPoint,
                                  const ISize  &aSize )
  : origin( aPoint.minimum( aPoint+aSize ) ),
    corner( aPoint.maximum( aPoint+aSize ) )
  {
  }
inline IRectangle :: IRectangle ( Coord x1,
                                  Coord y1,
                                  Coord x2,
                                  Coord y2 )
   : origin( IPair( x1, y1 ).minimum( IPair( x2, y2 ) ) ),
     corner( IPair( x1, y1 ).maximum( IPair( x2, y2 ) ) )
  {
  }
#line 77
inline IRectangle :: IRectangle ( Coord width,
                                  Coord height )
  : origin( IPair( width, height ).minimum( IPair() ) ),
    corner( IPair( width, height ).maximum( IPair() ) )
  {
  }
inline IRectangle :: IRectangle ( const IPair &aPair )
  : origin( aPair.minimum( IPair() ) ),
    corner( aPair.maximum( IPair() ) )
  {
  }

inline IRectangle::Coord IRectangle :: minY ( ) const
  {
  return origin.y();
  }
inline IRectangle::Coord IRectangle :: bottom ( ) const
  {
  return minY();
  }
inline IRectangle::Coord IRectangle :: height ( ) const
  {
  return corner.y() - origin.y();
  }
inline IRectangle::Coord IRectangle :: minX ( ) const
  {
  return origin.x();
  }
inline IRectangle::Coord IRectangle :: left ( ) const
  {
  return minX();
  }
inline IRectangle::Coord IRectangle :: maxX ( ) const
  {
  return corner.x();
  }
inline IRectangle::Coord IRectangle :: right ( ) const
  {
  return maxX();
  }
inline IRectangle::Coord IRectangle :: maxY ( ) const
  {
  return corner.y();
  }
inline IRectangle::Coord IRectangle :: top ( ) const
  {
  return maxY();
  }
inline IRectangle::Coord IRectangle :: width ( ) const
  {
  return corner.x() - origin.x();
  }
inline IPoint IRectangle :: centerXMinY ( ) const
  {
  return IPoint( ( maxX() + minX() ) / 2,
                   minY() );
  }
inline IPoint IRectangle :: bottomCenter ( ) const
  {
  return centerXMinY( );
  }
inline IPoint IRectangle :: minXMinY ( ) const
  {
  return origin;
  }
inline IPoint IRectangle :: bottomLeft ( ) const
  {
  return minXMinY();
  }
inline IPoint IRectangle :: maxXMinY ( ) const
  {
  return IPoint( maxX(),
                 minY() );
  }
inline IPoint IRectangle :: bottomRight ( ) const
  {
  return maxXMinY( );
  }
inline IPoint IRectangle :: centerXCenterY ( ) const
  {
  return ( origin + corner ) / 2;
  }
inline IPoint IRectangle :: center ( ) const
  {
  return centerXCenterY( );
  }
inline IPoint IRectangle :: minXCenterY ( ) const
  {
  return IPoint( minX(),
                 ( minY() + maxY() ) / 2 );
  }
inline IPoint IRectangle :: leftCenter ( ) const
  {
  return minXCenterY( );
  }
inline IPoint IRectangle :: maxXCenterY ( ) const
  {
  return IPoint( maxX(),
                 ( minY() + maxY() ) / 2 );
  }
inline IPoint IRectangle :: rightCenter ( ) const
  {
  return maxXCenterY();
  }
inline IPoint IRectangle :: centerXMaxY ( ) const
  {
  return IPoint( ( minX() + maxX() ) / 2,
                 maxY() );
  }
inline IPoint IRectangle :: topCenter ( ) const
  {
  return centerXMaxY();
  }
inline IPoint IRectangle :: minXMaxY ( ) const
  {
  return IPoint( minX(),
                 maxY() );
  }
inline IPoint IRectangle :: topLeft ( ) const
  {
  return minXMaxY( );
  }
inline IPoint IRectangle :: maxXMaxY ( ) const
  {
  return corner;
  }
inline IPoint IRectangle :: topRight ( ) const
  {
  return maxXMaxY( );
  }
inline ISize IRectangle :: size ( ) const
  {
  return corner - origin;
  }
inline IRectangle::Coord IRectangle :: area ( ) const
  {
  return height() * width();
  }

inline IBase::Boolean IRectangle :: operator == ( const IRectangle &aRect ) const
  {
  return ( origin == aRect.origin
           &&
           corner == aRect.corner );
  }
inline IBase::Boolean IRectangle :: operator != ( const IRectangle& aRect ) const
  {
  return !( *this == aRect );
  }

inline IRectangle &IRectangle :: validate ( )
  {
  if ( (corner.coord1() < origin.coord1()) ||
       (corner.coord2() < origin.coord2()) )
  {
    origin = corner = IPoint( 0, 0 );
  }
  return *this;
  }

inline IRectangle &IRectangle :: operator &= ( const IRectangle &aRect )
  {
  origin = origin.maximum( aRect.origin );
  corner = corner.minimum( aRect.corner );
  return validate();
  }
inline IRectangle IRectangle :: operator &  ( const IRectangle &aRect ) const
  {
  IRectangle result( *this );
  return ( result &= aRect );
  }
inline IRectangle &IRectangle :: operator |= ( const IRectangle &aRect )
  {
  origin = origin.minimum( aRect.origin ),
  corner = corner.maximum( aRect.corner );
  return *this;
  }
inline IRectangle IRectangle :: operator |  ( const IRectangle &aRect ) const
  {
  IRectangle result( *this );
  return result |= aRect;
  }

inline IRectangle &IRectangle :: moveBy ( const IPair &aPair )
  {
  origin += aPair;
  corner += aPair;
  return *this;
  }
inline IRectangle &IRectangle :: centerAt ( const IPoint &aPoint )
  {
  return moveBy( aPoint - centerXCenterY() );
  }
inline IRectangle IRectangle :: centeredAt ( const IPoint &aPoint ) const
  {
  IRectangle result( *this );
  return result.centerAt( aPoint );
  }
inline IRectangle &IRectangle :: expandBy ( const IPair &aPair )
  {
  origin -= aPair;
  corner += aPair;
  return validate();
  }
inline IRectangle &IRectangle :: expandBy ( Coord coord )
  {
  origin -= coord,
  corner += coord;
  return validate();
  }
inline IRectangle IRectangle :: expandedBy ( const IPair &aPair ) const
  {
  IRectangle result( *this );
  return result.expandBy( aPair );
  }
inline IRectangle IRectangle :: expandedBy ( Coord coord ) const
  {
  IRectangle result( *this );
  return result.expandBy( coord );
  }
inline IRectangle IRectangle :: movedBy ( const IPair &aPair ) const
  {
  IRectangle result( *this );
  return result.moveBy( aPair );
  }
inline IRectangle &IRectangle :: moveTo ( const IPoint &aPoint )
  {
  return moveBy( aPoint - origin );
  }
inline IRectangle IRectangle :: movedTo ( const IPoint &aPoint ) const
  {
  IRectangle result( *this );
  return result.moveTo( aPoint );
  }
inline IRectangle &IRectangle :: scaleBy ( const IPair &aPair )
  {
  origin *= aPair;
  corner *= aPair;
  return *this;
  }
inline IRectangle &IRectangle :: scaleBy ( Coord coord )
  {
  origin *= coord,
  corner *= coord;
  return *this;
  }
inline IRectangle &IRectangle :: scaleBy ( double amt )
  {
  origin *= amt;
  corner *= amt;
  return *this;
  }
inline IRectangle &IRectangle :: scaleBy ( double xamt, double yamt )
  {
  origin.scaleBy( xamt, yamt );
  corner.scaleBy( xamt, yamt );
  return *this;
  }
inline IRectangle IRectangle :: scaledBy ( const IPair &aPair ) const
  {
  IRectangle result( *this );
  return result.scaleBy( aPair );
  }
inline IRectangle IRectangle :: scaledBy ( Coord coord ) const
  {
  IRectangle result( *this );
  return result.scaleBy( coord );
  }
inline IRectangle IRectangle :: scaledBy ( double amt ) const
  {
  IRectangle result( *this );
  return result.scaleBy( amt );
  }
inline IRectangle IRectangle :: scaledBy ( double xamt, double yamt ) const
  {
  IRectangle result( *this );
  return result.scaleBy( xamt, yamt );
  }
inline IRectangle &IRectangle :: shrinkBy ( const IPair &aPair )
  {
  return expandBy( -aPair );
  }
inline IRectangle &IRectangle :: shrinkBy ( Coord coord )
  {
  return expandBy( -coord );
  }
inline IRectangle IRectangle :: shrunkBy ( const IPair &aPair ) const
  {
  return expandedBy( -aPair );
  }
inline IRectangle IRectangle :: shrunkBy ( Coord coord ) const
  {
  return expandedBy( -coord );
  }
inline IRectangle &IRectangle :: sizeTo ( const IPair &aPair )
  {
  corner = origin + aPair;
  return *this;
  }
inline IRectangle IRectangle :: sizedTo ( const IPair &aPair ) const
  {
  IRectangle result( *this );
  return result.sizeTo( aPair );
  }
inline IRectangle &IRectangle :: sizeBy ( Coord factor )
  {
  IPoint save( minXMinY() );
  moveTo( IPoint(0,0) ).scaleBy( factor ).moveTo( save );
  return *this;
  }
inline IRectangle &IRectangle :: sizeBy ( const IPair &aPair )
  {
  IPoint save( minXMinY() );
  moveTo( IPoint(0,0) ).scaleBy( aPair ).moveTo( save );
  return *this;
  }
inline IRectangle &IRectangle :: sizeBy ( double factor )
  {
  IPoint save( minXMinY() );
  moveTo( IPoint(0,0) ).scaleBy( factor ).moveTo( save );
  return *this;
  }
inline IRectangle &IRectangle :: sizeBy ( double xfact, double yfact )
  {
  IPoint save( minXMinY() );
  moveTo( IPoint(0,0) ).scaleBy( xfact, yfact ).moveTo( save );
  return *this;
  }
inline IRectangle IRectangle :: sizedBy ( Coord factor ) const
  {
  IRectangle result( *this );
  return result.sizeBy( factor );
  }
inline IRectangle IRectangle :: sizedBy ( const IPair &aPair ) const
  {
  IRectangle result( *this );
  return result.sizeBy( aPair );
  }
inline IRectangle IRectangle :: sizedBy ( double factor ) const
  {
  IRectangle result( *this );
  return result.sizeBy( factor );
  }
inline IRectangle IRectangle :: sizedBy ( double xfact, double yfact ) const
  {
  IRectangle result( *this );
  return result.sizeBy( xfact, yfact );
  }

inline IBase::Boolean IRectangle :: contains ( const IRectangle &aRect ) const
  {
  return ( origin <= aRect.origin
           &&
           aRect.corner <= corner );
  }
inline IBase::Boolean IRectangle :: contains ( const IPoint &aPoint ) const
  {
  return ( aPoint >= origin
           &&
           aPoint < corner );
  }
inline IBase::Boolean IRectangle :: intersects ( const IRectangle &aRect ) const
  {
  return ( origin < aRect.corner
           &&
           aRect.origin < corner );
  }
#line 23 "F:\vacpp\INCLUDE\ireslib.hpp"
class IString;
class IDLLModule;
class ISize;
class IWindow;
class IMenu;
class IResLibPrivateData;

#pragma pack(4)

class IResourceLibrary  : public IVBase {
typedef IVBase
  Inherited;
public:

  IResourceLibrary   ( );
  IResourceLibrary   ( const IResourceLibrary& resLibrary );
virtual
 ~IResourceLibrary   ( );

IResourceLibrary
 &operator=           ( const IResourceLibrary& resLibrary );
#line 46
virtual IString
  fileName           ( ) const;

virtual Boolean
  isOpen             ( ) const;

virtual IModuleHandle
  handle             ( ) const;
#line 56
virtual IString
  asString           ( ) const,
  asDebugInfo        ( ) const;
#line 62
virtual IString
  loadString      ( unsigned long stringId  ) const,
  loadMessage     ( unsigned long messageId ) const;
#line 67
virtual IMenuHandle
  loadMenu        ( unsigned long menuId,
                    IWindow*      menuOwner ) const;

virtual IWindowHandle
  loadDialog      ( unsigned long dialogId,
                    IWindow*      dialogParent,
                    IWindow*      dialogOwner,
                    IWinProc*     dialogProcedure,
                    void*         dialogCreateParameters ) const;
#line 79
virtual IAccelTblHandle
  loadAccelTable  ( unsigned long accelTableId ) const;

virtual IResourceLibrary
 &loadHelpTable   ( IWindow*      helpInstance,
                    unsigned long helpTableId ) const;

virtual IPointerHandle
  loadIcon        ( unsigned long iconId,
                    Boolean       cached = true ) const,
  loadPointer     ( unsigned long iconId,
                    Boolean       cached = true ) const;

virtual IBitmapHandle
  loadBitmap      ( unsigned long bitmapId,
                    Boolean       cached = true ) const,
  loadBitmap      ( unsigned long bitmapId,
                    const ISize&  bitmapSize,
                    Boolean       cached = true ) const;
#line 100
virtual IString
  tryToLoadString      ( unsigned long stringId  ) const,
  tryToLoadMessage     ( unsigned long messageId ) const;

virtual IPointerHandle
  tryToLoadIcon        ( unsigned long iconId,
                         Boolean       cached = true ) const;

virtual IBitmapHandle
  tryToLoadBitmap     ( unsigned long bitmapId,
                        Boolean       cached = true ) const,
  tryToLoadBitmap     ( unsigned long bitmapId,
                        const ISize&  bitmapSize,
                        Boolean       cached = true ) const;

private:

char
 *loadText       ( Boolean       isString,
                   unsigned long stringID,
                   char*         buffer = 0,
                   unsigned long length = 0,
                   Boolean       throwException = true ) const;
#line 125
static unsigned long
  addRef          ( const IPointerHandle& pointerHandle ),
  addRef          ( const IBitmapHandle&  bitmapHandle ),
  removeRef       ( const IPointerHandle& pointerHandle ),
  removeRef       ( const IBitmapHandle&  bitmapHandle );

static unsigned long
  systemPointer ( unsigned long systemPointerId,
                  Boolean       fCopy = false,
                  Boolean       fIconApi = false );
static unsigned long
  systemBitmap  ( unsigned long systemBitmapId);

IResLibPrivateData
 *ppd;

IModuleHandle
  hInstance;

friend class IPointerHandle;
friend class IBitmapHandle;
friend class ISystemPointerHandle;
friend class ISystemBitmapHandle;
friend class ICnrObjPrivateData;
};
#line 152
class IDynamicLinkLibrary : public IResourceLibrary
{
typedef IResourceLibrary
  Inherited;
public:

  IDynamicLinkLibrary   ( const char*                resourceFileName );
  IDynamicLinkLibrary   ( const IModuleHandle&       moduleHandle );
  IDynamicLinkLibrary   ( const IDynamicLinkLibrary& dllLibrary );

virtual
  ~IDynamicLinkLibrary  ( );

IDynamicLinkLibrary
 &operator=             ( const IDynamicLinkLibrary& dllLibrary );
#line 169
virtual IDynamicLinkLibrary
 &open                ( ),
 &close               ( );
#line 174
void
 *procAddress       ( const char*   procedureName ) const,
 *procAddress       ( unsigned long procedureOrdinal ) const;

Boolean
  isEntryPoint32Bit ( const char*   procedureName ) const,
  isEntryPoint32Bit ( unsigned long procedureOrdinal ) const;
#line 183
virtual Boolean
  isOpen           ( ) const;

virtual IString
  fileName         ( ) const;

virtual IModuleHandle
  handle           ( ) const;
#line 193
virtual IString
  asString         ( ) const,
  asDebugInfo      ( ) const;
#line 198
private:

static unsigned long
  addRef          ( const IModuleHandle& moduleHandle ),
  removeRef       ( const IModuleHandle& moduleHandle );

IDLLModule
 *pmodClResource;
};
#line 209
class IResourceId  : public IBase
{
typedef IBase
  Inherited;
public:

  IResourceId      ( unsigned long              resourceId,
                     const IResourceLibrary&    resourceLibrary );
  IResourceId      ( unsigned long              resourceId,
                     const IDynamicLinkLibrary& dllLibrary );

  IResourceId      ( unsigned long              resourceId );
#line 223
unsigned long
  id                    ( ) const;

operator unsigned long  ( ) const;

const IResourceLibrary
 &resourceLibrary       ( ) const;
#line 232
IString
  asString         ( ) const,
  asDebugInfo      ( ) const;
#line 237
private:

IResourceId
  &operator=    ( const IResourceId& resourceId );
#line 243
unsigned long
  ulClId;

const IResourceLibrary
 &reslibCl;

};

#pragma pack()
#line 22 "F:\vacpp\INCLUDE\iapp.hpp"
struct pib_s;
class IResourceLibrary;
class IString;
class ICurrentApplication;
class ICurrentApplicationData;

#pragma pack(4)
#line 31
class IApplication : public IVBase {
typedef IVBase
  Inherited;
public:

virtual IString
  asString    ( ) const,
  asDebugInfo ( ) const;
#line 41
static IProcessId
  currentPID  ( );

virtual IProcessId
  id          ( ) const;

static ICurrentApplication
 ¤t     ( );
#line 51
enum PriorityClass {
  noChange,
  idleTime,
  regular,
  timeCritical,
  foregroundServer
};

virtual IApplication
 &adjustPriority ( long          adjustment,
                   Boolean       setDescendents = false ),
 &setPriority    ( PriorityClass priorityClass,
                   long          priorityLevel = 0,
                   Boolean       setDescendents = false );

protected:

  IApplication ( const IProcessId& id );
virtual
 ~IApplication ( );
#line 73
virtual IApplication
  &setId ( const IProcessId& id );

private:

static ICurrentApplication
 *pCurrent;
IProcessId
  pid;
};
#line 85
class ICurrentApplication : public IApplication {
typedef IApplication
  Inherited;
public:

virtual int
  argc    ( ) const;

virtual IString
  argv    ( int argumentNumber ) const;

virtual ICurrentApplication
 &setArgs ( int               argc,
            const char* const argv[] );
#line 101
virtual IResourceLibrary
 &userResourceLibrary    ( ) const,
 &resourceLibrary        ( ) const;

virtual ICurrentApplication
 &setUserResourceLibrary ( const char* resLibName ),
 &setResourceLibrary     ( const char* resLibName );
#line 110
virtual ICurrentApplication
 &run  ( ),
 &exit ( );
#line 115
virtual IString
  asDebugInfo ( ) const;

protected:

  ICurrentApplication ( );
virtual
 ~ICurrentApplication ( );
#line 125
struct pib_s
 &pib ( );

private:

friend class IApplication;

IResourceLibrary
 *icluiLib,
 *userLib;

Boolean
  exeResource;

int
  argCount;

IString
 *argValue;

struct pib_s
 *pPIB;

ICurrentApplicationData
 *pCurrentApplicationData;

};

#pragma pack()
#line 30 "F:\vacpp\INCLUDE\ireslib.inl"
inline IResourceId :: IResourceId(unsigned long resourceId, const IResourceLibrary& resourceLibrary)
                     : reslibCl(resourceLibrary), ulClId(resourceId)

{ }

inline IResourceId :: IResourceId(unsigned long resourceId, const IDynamicLinkLibrary& dllLibrary)
                     : reslibCl(dllLibrary), ulClId(resourceId)

{ }

inline IResourceId :: IResourceId(unsigned long resourceId)
                       : reslibCl ( IApplication::current().userResourceLibrary() ),
                         ulClId   ( resourceId )

{ }

inline const IResourceLibrary& IResourceId::resourceLibrary() const
{ return reslibCl; }

inline IResourceId::operator unsigned long( )   const
{ return this->ulClId; }

inline unsigned long IResourceId::id( )   const
{ return this->ulClId; }
#line 25 "F:\vacpp\INCLUDE\iframe.hpp"
class IColor;
class IFrameExtension;
class IFrameExtensions;
class IFrameHandler;
class IFrameWindowData;
class IFrameWindowNotifyHandler;
class IToolBarList;

#pragma pack(4)

class IFrameWindow : public IWindow {
typedef IWindow
  Inherited;
public:
class Style;
enum FrameSource {
  dialogResource,
  noDialogResource,
  tryDialogResource
  };

  IFrameWindow ( unsigned long id = 1000,
                 FrameSource   source = tryDialogResource );

  IFrameWindow ( const IResourceId& resId,
                 IWindow*           owner = 0,
                 FrameSource        source = tryDialogResource );

  IFrameWindow ( const IResourceId& resId,
                 IWindow*           parent,
                 IWindow*           owner,
                 FrameSource        source = tryDialogResource );

  IFrameWindow ( const IWindowHandle& hwnd );

  IFrameWindow ( const IResourceId&         resId,
                 const IFrameWindow::Style& style );

  IFrameWindow ( const IFrameWindow::Style& style,
                 const IResourceId&         resId = 1000 );

  IFrameWindow ( const char*                title,
                 const IResourceId&         resId = 1000,
                 const IFrameWindow::Style& style = defaultStyle() );

  IFrameWindow ( const IResourceId&         resId,
                 IWindow*                   parent,
                 IWindow*                   owner ,
                 const IRectangle&          initRect,
                 const IFrameWindow::Style& style = defaultStyle(),
                 const char*                title = 0 );

virtual
 ~IFrameWindow ( );
#line 81
class Style : public IBitFlag{friend class IFrameWindow;public: class NegatedStyle : public IBitFlag { friend class Style; public: NegatedStyle ( const IWindow::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline NegatedStyle operator & ( const NegatedStyle &lhs, const NegatedStyle &rhs ); friend inline Style operator & ( const NegatedStyle &lhs, const Style &rhs ); protected: NegatedStyle ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Style& operator |= ( const Style &aFlag ) { Style tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedStyle operator ~ ( ) const { NegatedStyle aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Style& operator &= ( const NegatedStyle &aFlag ) { Style tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Style ( const IWindow::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline Style operator | ( const Style &lhs, const Style &rhs ); friend inline Style operator & ( const Style &lhs, const NegatedStyle &rhs );protected: Style ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};

static const Style
  classDefaultStyle,
  accelerator,
  alignNoAdjust,
  animated,
  appDBCSStatus,
  border,
  dialogBackground,
  dialogBorder,
  hideButton,
  horizontalScroll,
  maximizeButton,
  maximized,
  menuBar,
  minimizeButton,
  minimized,
  minimizedIcon,
  noMoveWithOwner,
  shellPosition,
  sizingBorder,
  systemMenu,
  systemModal,
  titleBar,
  verticalScroll,
  windowList;

static Style
  defaultStyle      ( );

static void
  setDefaultStyle   ( const Style&    style );

virtual unsigned long
  convertToGUIStyle ( const IBitFlag& style,
                      Boolean         extendedOnly = false ) const;
#line 120
virtual IFrameWindow
 &close          ( ),
 &maximize       ( ),
 &restore        ( ),
 &setRestoreRect ( const IRectangle& rect ),
 &minimize       ( );

virtual IRectangle
  maximizeRect  ( ) const,
  minimizeRect  ( ) const,
  restoreRect   ( ) const;

static IRectangle
  nextShellRect ( );
#line 136
virtual IFrameWindow
 &moveSizeToClient ( const IRectangle& clientRect );

virtual IRectangle
  clientRectFor    ( const IRectangle& frameRect ) const,
  frameRectFor     ( const IRectangle& clientRect ) const;
#line 144
unsigned long
  borderWidth     ( ) const,
  borderHeight    ( ) const;

ISize
  borderSize      ( ) const;

IFrameWindow
 &setBorderWidth  ( unsigned long cx ),
 &setBorderHeight ( unsigned long cy ),
 &setBorderSize   ( const ISize&  size ),
 &setBorderSize   ( unsigned long cxcy ),
 &setBorderSize   ( unsigned long cx,
                    unsigned long cy );
#line 160
virtual unsigned long
  showModally ( ),
  result      ( ) const;

virtual IFrameWindow
 &dismiss     ( unsigned long result = 0 ),
 &setResult   ( unsigned long result ),

 ¬ifyOwner ( unsigned long         id,
                ICommandEvent::Source source = ICommandEvent::unknown,
                Boolean               pointerDevice = false );
#line 173
virtual IPointerHandle
  icon    ( ) const;

virtual IFrameWindow
 &setIcon ( const IPointerHandle& icon ),
 &setIcon ( const IResourceId&    iconResId ),
 &setIcon ( unsigned long         iconResId );
#line 182
virtual IPointerHandle
  mousePointer    ( ) const;

virtual IFrameWindow
 &setMousePointer ( const IPointerHandle& mousePointer );
#line 189
virtual IColor
  backgroundColor              ( ) const,
  disabledBackgroundColor      ( ) const;

virtual IFrameWindow
 &resetBackgroundColor         ( ),
 &resetDisabledBackgroundColor ( );

Boolean
  usesDialogBackground         ( ) const;
#line 201
virtual IWindowHandle
  clientHandle ( ) const;

virtual IWindow
 *client       ( ) const;

virtual IFrameWindow
 &setClient    ( IWindow* newClient );
#line 211
enum Location {
  leftOfTitleBar,
  rightOfTitleBar,
  leftOfMenuBar,
  rightOfMenuBar,
  leftOfClient,
  rightOfClient,
  aboveClient,
  belowClient
  };

enum SeparatorType {
  none,
  thinLine,
  thickLine
  };

virtual IFrameWindow
 &addExtension     ( IWindow*      newExtension,
                     Location      location,
                     unsigned long widthOrHeight,
                     SeparatorType separator = thinLine ),
 &addExtension     ( IWindow*      newExtension,
                     Location      location,
                     int           widthOrHeight,
                     SeparatorType separator = thinLine ),
 &addExtension     ( IWindow*      newExtension,
                     Location      location,
                     double        percentage,
                     SeparatorType separator = thinLine ),
 &addExtension     ( IWindow*      newExtension,
                     Location      location,
                     SeparatorType separator = thinLine ),

 &removeExtension  ( IWindow*      extension,
                     Boolean       updateDisplay = true ),

 &setExtensionSize ( IWindow*      extension,
                     unsigned long widthOrHeight ),
 &setExtensionSize ( IWindow*      extension,
                     int           widthOrHeight ),
 &setExtensionSize ( IWindow*      extension,
                     double        widthOrHeight ),
 &useExtensionMinimumSize ( IWindow* extension ),

 &update           ( );

virtual Boolean
  isAnExtension    ( const IWindow* window ) const;
#line 262
virtual IFrameWindow
 &show ( Boolean showWindow = true );
#line 266
virtual IFrameWindow
 &setDestroyOnClose  ( Boolean destroy = true );

Boolean
  willDestroyOnClose ( ) const;
#line 273
Boolean
  isFlashing  ( ) const,
  isMaximized ( ) const,
  isMinimized ( ) const,
  isModal     ( ) const;
#line 280
virtual IFrameWindow
 &addToWindowList      ( ),
 &removeFromWindowList ( );
#line 285
virtual IWindowHandle
  handleFor ( const Style& standardControl ) const;
#line 289
virtual IFrameWindow
 &beginFlashing ( ),
 &endFlashing   ( );
#line 294
virtual IFrameWindow
 &shareParentDBCSStatus ( );
#line 298
static void
  setDefaultOrdering ( IWindow::SiblingOrder ordering );
static IWindow::SiblingOrder
  defaultOrdering    ( );
#line 304
IFrameWindow
 &setLayoutDistorted ( unsigned long layoutAttributesOn,
                       unsigned long layoutAttributesOff );
#line 309
static INotificationId const
  closeId,
  activateId,
  deactivateId;
#line 315
virtual IFrameWindow
 &enableNotification ( Boolean enable = true );
#line 320
IFrameWindow
 &setToolBarList ( IToolBarList* toolBarList );
IToolBarList
 *toolBarList    ( ) const;

protected:

IFrameExtensions
 *extensions    ( ) const;

unsigned
  findExtension ( IWindow* window );

IFrameWindow
 &setExtensions ( IFrameExtensions* extensions );
#line 337
static const Style
  deferCreation;

IFrameWindow
 &tryToLoadDialog ( const IResourceId& resId,
                    IWindow*           parent = 0,
                    IWindow*           owner  = 0,
                    FrameSource        source = tryDialogResource );

IFrameWindow
 &initialize      ( const IResourceId& resId,
                    const Style&       style,
                    IWindow*           parent   = 0,
                    IWindow*           owner    = 0,
                    const IRectangle&  initRect = nextShellRect(),
                    const char*        title    = 0 );
#line 355
IWindowHandle
  create ( unsigned long         id,
           const char*           title,
           unsigned long         style,
           const char*           windowClass,
           const IWindowHandle&  parent,
           const IWindowHandle&  owner,
           const IRectangle&     initRect,
           const void*           ctlData,
           const void*           presParams,
           IWindow::SiblingOrder ordering = defaultOrdering() );

IFrameWindow
 &start  ( const IWindowHandle& hwnd );

IFrameWindow
 &addDefaultHandler    ( ),
 &removeDefaultHandler ( );
#line 375
private:

  IFrameWindow ( const IFrameWindow& frame );
IFrameWindow
 &operator=    ( const IFrameWindow& frame );
#line 382
friend class IFrameHandler;
friend class IFrameWindowNotifyHandler;
friend class IMenuBar;

IFrameWindow
 &addExtension ( IFrameExtension* extension );

static const Style
  styleBits;
static Style
  currentDefault;

static IWindow::SiblingOrder
  siblingCreateOrder;

IFrameWindowData
 *fFrameWindowData;
#line 401
public:

enum ColorArea {
  background,
  foreground,
  shadow,
  disableBackground,
  activeBorder,
  inactiveBorder,
  frameBorder
  };

IFrameWindow
 &setColor      ( ColorArea     value,
                  const IColor& color );
IColor
  color         ( ColorArea     value ) const;
virtual Boolean
  isAnExtension ( IWindow*      window );

protected:
static unsigned long
  flagsFrom ( const Style& style ),
  styleFrom ( const Style& style );

};

inline IFrameWindow::Style operator | ( const IFrameWindow::Style &lhs, const IFrameWindow::Style &rhs ){ IFrameWindow::Style aResult ( lhs.asUnsignedLong() | rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() | rhs.asExtendedUnsignedLong() ); return aResult;}inline IFrameWindow::Style operator & ( const IFrameWindow::Style &lhs, const IFrameWindow::Style::NegatedStyle &rhs ){ IFrameWindow::Style aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IFrameWindow::Style::NegatedStyle operator & ( const IFrameWindow::Style::NegatedStyle &lhs, const IFrameWindow::Style::NegatedStyle &rhs ){ IFrameWindow::Style::NegatedStyle aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IFrameWindow::Style operator & ( const IFrameWindow::Style::NegatedStyle &lhs, const IFrameWindow::Style &rhs ){ return rhs & lhs;}inline unsigned long operator & ( const IFrameWindow::Style &lhs, const IFrameWindow::Style &rhs ){ unsigned long ulResult = lhs.asUnsignedLong() & rhs.asUnsignedLong(); return ( ulResult | (lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong()) );} inline unsigned long operator & ( const IFrameWindow::Style &lhs, const IFrameWindow::Style &rhs );

#pragma pack()
#line 20 "F:\vacpp\INCLUDE\icontrol.hpp"
class IControlData;

#pragma pack(4)

class IControl : public IWindow  {
typedef IWindow
  Inherited;
public:

virtual
  ~IControl();
#line 33
class Style : public IBitFlag{friend class IControl;public: class NegatedStyle : public IBitFlag { friend class Style; public: NegatedStyle ( const IWindow::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline NegatedStyle operator & ( const NegatedStyle &lhs, const NegatedStyle &rhs ); friend inline Style operator & ( const NegatedStyle &lhs, const Style &rhs ); protected: NegatedStyle ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Style& operator |= ( const Style &aFlag ) { Style tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedStyle operator ~ ( ) const { NegatedStyle aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Style& operator &= ( const NegatedStyle &aFlag ) { Style tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Style ( const IWindow::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline Style operator | ( const Style &lhs, const Style &rhs ); friend inline Style operator & ( const Style &lhs, const NegatedStyle &rhs );protected: Style ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};
static const Style
  group,
  tabStop;
#line 39
virtual IControl
 &enableGroup    ( Boolean enable = true ),
 &disableGroup   ( );
virtual Boolean
  isGroup        ( ) const;
virtual IControl
 &enableTabStop  ( Boolean enable = true ),
 &disableTabStop ( );
virtual Boolean
  isTabStop      ( ) const;

protected:

  IControl();

private:

  IControl       ( const IControl& );
IControl
 &operator=      ( const IControl& );
#line 61
IControlData
 *fControlData;
};
inline IControl::Style operator | ( const IControl::Style &lhs, const IControl::Style &rhs ){ IControl::Style aResult ( lhs.asUnsignedLong() | rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() | rhs.asExtendedUnsignedLong() ); return aResult;}inline IControl::Style operator & ( const IControl::Style &lhs, const IControl::Style::NegatedStyle &rhs ){ IControl::Style aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IControl::Style::NegatedStyle operator & ( const IControl::Style::NegatedStyle &lhs, const IControl::Style::NegatedStyle &rhs ){ IControl::Style::NegatedStyle aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IControl::Style operator & ( const IControl::Style::NegatedStyle &lhs, const IControl::Style &rhs ){ return rhs & lhs;}inline unsigned long operator & ( const IControl::Style &lhs, const IControl::Style &rhs ){ unsigned long ulResult = lhs.asUnsignedLong() & rhs.asUnsignedLong(); return ( ulResult | (lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong()) );} inline unsigned long operator & ( const IControl::Style &lhs, const IControl::Style &rhs );

#pragma pack()
#line 23 "F:\vacpp\INCLUDE\icanvas.hpp"
class ICanvasHandler;
class IColor;
class IWindowPosBuffer;
class ICanvasData;

#pragma pack(4)

class ICanvas : public IControl {
typedef IControl
  Inherited;
public:
class Style;
#line 37
  ICanvas ( unsigned long     windowIdentifier,
            IWindow*          parent,
            IWindow*          owner,
            const IRectangle& initial = IRectangle(),
            const Style&      style = defaultStyle() );
virtual
 ~ICanvas ( );
#line 46
class Style : public IBitFlag{friend class ICanvas;public: class NegatedStyle : public IBitFlag { friend class Style; public: NegatedStyle ( const IWindow::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline NegatedStyle operator & ( const NegatedStyle &lhs, const NegatedStyle &rhs ); friend inline Style operator & ( const NegatedStyle &lhs, const Style &rhs ); protected: NegatedStyle ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Style& operator |= ( const Style &aFlag ) { Style tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedStyle operator ~ ( ) const { NegatedStyle aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Style& operator &= ( const NegatedStyle &aFlag ) { Style tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Style ( const IWindow::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline Style operator | ( const Style &lhs, const Style &rhs ); friend inline Style operator & ( const Style &lhs, const NegatedStyle &rhs );protected: Style ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};
static const Style
  classDefaultStyle;
static Style
  defaultStyle      ( );
static void
  setDefaultStyle   ( const Style&    style );

virtual unsigned long
  convertToGUIStyle ( const IBitFlag& style,
                      Boolean         extendedOnly = false ) const;
#line 59
virtual IColor
  backgroundColor ( ) const;
#line 63
virtual Boolean
  isTabStop               ( ) const;
IWindowHandle
  origDefaultButtonHandle ( ) const;
virtual IWindowHandle
  defaultPushButton       ( ) const,
  matchForMnemonic        ( unsigned short character ) const;
#line 72
virtual ICanvas
 &setLayoutDistorted ( unsigned long layoutAttributesOn,
                       unsigned long layoutAttributesOff );

protected:

  ICanvas ( );
#line 81
virtual ICanvas
 &layout              ( );
ISize
  layoutSize          ( ) const;
ICanvas
 &setLayoutSize       ( const ISize& size );
virtual IWindowPosBuffer
  fixupChildren       ( );
Boolean
  areChildrenReversed ( ) const;
virtual ISize
  calcMinimumSize     ( ) const;
#line 95
private:
#line 99
  ICanvas   ( const ICanvas& canvas );
ICanvas
 &operator= ( const ICanvas& canvas );

static Style
  currentDefaultStyle;
ISize
  sizClLayout;
IWindowHandle
  hwndClDefaultButton;
Boolean
  bClChildrenReversed,
  bClDefaultHandlerAdded;
ICanvasData
 *fCanvasData;
friend class ICanvasHandler;

public:
#line 119
enum ColorArea {
  background
};
ICanvas
 &setColor ( ColorArea     area,
             const IColor& color );
IColor
  color    ( ColorArea     area ) const;

};

inline ICanvas::Style operator | ( const ICanvas::Style &lhs, const ICanvas::Style &rhs ){ ICanvas::Style aResult ( lhs.asUnsignedLong() | rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() | rhs.asExtendedUnsignedLong() ); return aResult;}inline ICanvas::Style operator & ( const ICanvas::Style &lhs, const ICanvas::Style::NegatedStyle &rhs ){ ICanvas::Style aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline ICanvas::Style::NegatedStyle operator & ( const ICanvas::Style::NegatedStyle &lhs, const ICanvas::Style::NegatedStyle &rhs ){ ICanvas::Style::NegatedStyle aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline ICanvas::Style operator & ( const ICanvas::Style::NegatedStyle &lhs, const ICanvas::Style &rhs ){ return rhs & lhs;}inline unsigned long operator & ( const ICanvas::Style &lhs, const ICanvas::Style &rhs ){ unsigned long ulResult = lhs.asUnsignedLong() & rhs.asUnsignedLong(); return ( ulResult | (lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong()) );} inline unsigned long operator & ( const ICanvas::Style &lhs, const ICanvas::Style &rhs );

#pragma pack()
#line 29 "F:\vacpp\INCLUDE\icanvas.inl"
inline void  ICanvas::setDefaultStyle ( const ICanvas::Style& style )
  {
  currentDefaultStyle = style;
  }
inline ISize  ICanvas::layoutSize ( ) const
  {
  return sizClLayout;
  }
inline ICanvas  &ICanvas::setLayoutSize ( const ISize& size )
  {
  sizClLayout = size;
  return *this;
  }
inline IBase::Boolean  ICanvas::areChildrenReversed ( ) const
  {
  return bClChildrenReversed;
  }
#line 19 "F:\vacpp\INCLUDE\istrenum.hpp"
#pragma pack(4)

class IStringEnum {
public:

typedef enum {
  leading,
  trailing,
  both
  } StripMode;
#line 31
typedef enum {
  sbcs,
  dbcs1 = 1,
  mbcs1 = 1,
  dbcs2 = 2,
  mbcs2 = 2,
  mbcs3 = 3,
  mbcs4 = 4
  } CharType;
};

#pragma pack()
#line 24 "F:\vacpp\INCLUDE\istring.hpp"
#pragma pack(4)

extern "C"
  {
#line 2 "F:\vacpp\INCLUDE\limits.h"
#pragma info( none )

   #pragma info( none )

#pragma info( restore )
#line 13
      extern "C" {
#line 63
      }
#line 69
#pragma info( none )

   #pragma info( restore )

#pragma info( restore )
#line 29 "F:\vacpp\INCLUDE\istring.hpp"
  }

class IStringTest;
class IBuffer;
class ostream;
class istream;

class IString : public IBase {
public:

  IString           ( );
  IString           ( const IString &aString );

  IString           ( int );
  IString           ( unsigned );
  IString           ( long );
  IString           ( unsigned long );
  IString           ( short );
  IString           ( unsigned short );
  IString           ( double );

  IString           ( char );
  IString           ( unsigned char );
  IString           ( signed char );

  IString           ( const char * );
  IString           ( const unsigned char * );
  IString           ( const signed char * );

  IString           ( const void *pBuffer1,
                      unsigned    lenBuffer1,
                      char        padCharacter = ' ' );
  IString           ( const void *pBuffer1,
                      unsigned     lenBuffer1,
                      const void  *pBuffer2,
                      unsigned     lenBuffer2,
                      char         padCharacter = ' ' );
  IString           ( const void *pBuffer1,
                      unsigned     lenBuffer1,
                      const void  *pBuffer2,
                      unsigned     lenBuffer2,
                      const void  *pBuffer3,
                      unsigned     lenBuffer3,
                      char         padCharacter = ' ' );

  ~IString          ( );
#line 77
IString
  asString          ( ) const,
  asDebugInfo       ( ) const;

friend ostream
 &operator <<       ( ostream       &aStream,
                      const IString &aString );
#line 86
friend istream
 &operator >>       ( istream &aStream,
                      IString &aString );

static IString
  lineFrom          ( istream &aStream,
                      char     delim = '\n' );
#line 95
Boolean
  isAlphanumeric    ( ) const,
  isAlphabetic      ( ) const,
  isASCII           ( ) const,
  isBinaryDigits    ( ) const,
  isControl         ( ) const,
  isDigits          ( ) const,
  isGraphics        ( ) const,
  isHexDigits       ( ) const,
  isLowerCase       ( ) const,
  isPrintable       ( ) const,
  isPunctuation     ( ) const,
  isUpperCase       ( ) const,
  isWhiteSpace      ( ) const;
#line 111
Boolean
  isMBCS            ( ) const,
  isDBCS            ( ) const,
  isSBCS            ( ) const,
  isValidMBCS       ( ) const,
  isValidDBCS       ( ) const,
  includesMBCS      ( ) const,
  includesDBCS      ( ) const,
  includesSBCS      ( ) const;
#line 123
Boolean
  isLike            ( const IString &aPattern,
                      char           zeroOrMore = '*',
                      char           anyChar    = '?' ) const,
  isLike            ( const char    *pPattern,
                      char           zeroOrMore = '*',
                      char           anyChar    = '?' ) const,

  isAbbreviationFor ( const IString &fullString,
                      unsigned       minAbbrevLength = 0 ) const,
  isAbbreviationFor ( const char    *pFullString,
                      unsigned       minAbbrevLength = 0 ) const,

  includes          ( const IString     &aString ) const,
  includes          ( const char        *pString ) const,
  includes          ( char               aChar   ) const,
  includes          ( const IStringTest &aTest   ) const;
#line 142
friend Boolean
  operator ==      ( const IString &string1,
                     const IString &string2  ),
  operator ==      ( const IString &string1,
                     const char    *pString2 ),
  operator ==      ( const char    *pString1,
                     const IString &string2  ),

  operator !=      ( const IString &string1,
                     const IString &string2  ),
  operator !=      ( const IString &string1,
                     const char    *pString2 ),
  operator !=      ( const char    *pString1,
                     const IString &string2  ),

  operator <       ( const IString &string1,
                     const IString &string2  ),
  operator <       ( const IString &string1,
                     const char    *pString2 ),
  operator <       ( const char    *pString1,
                     const IString &string2  ),

  operator <=      ( const IString &string1,
                     const IString &string2  ),
  operator <=      ( const IString &string1,
                     const char    *pString2 ),
  operator <=      ( const char    *pString1,
                     const IString &string2  ),

  operator >       ( const IString &string1,
                     const IString &string2  ),
  operator >       ( const IString &string1,
                     const char    *pString2 ),
  operator >       ( const char    *pString1,
                     const IString &string2  ),

  operator >=      ( const IString &string1,
                     const IString &string2  ),
  operator >=      ( const IString &string1,
                     const char    *pString2 ),
  operator >=      ( const char    *pString1,
                     const IString &string2  );
#line 186
  operator char*          ( ) const;
  operator unsigned char* ( ) const;
  operator signed char*   ( ) const;
#line 191
long
  asInt                   ( ) const;

unsigned long
  asUnsigned              ( ) const;

double
  asDouble                ( ) const;
#line 201
IString
 &b2c              ( ),
 &b2d              ( ),
 &b2x              ( );

static IString
  b2c              ( const IString &aString ),
  b2d              ( const IString &aString ),
  b2x              ( const IString &aString );
#line 212
IString
 &c2b              ( ),
 &c2d              ( ),
 &c2x              ( );

static IString
  c2b              ( const IString &aString ),
  c2d              ( const IString &aString ),
  c2x              ( const IString &aString );
#line 223
IString
 &d2b              ( ),
 &d2c              ( ),
 &d2x              ( );

static IString
  d2b              ( const IString &aString ),
  d2c              ( const IString &aString ),
  d2x              ( const IString &aString );
#line 234
IString
 &x2b              ( ),
 &x2c              ( ),
 &x2d              ( );

static IString
  x2b              ( const IString &aString ),
  x2c              ( const IString &aString ),
  x2d              ( const IString &aString );
#line 246
IString
 &operator =       ( const IString &aString ),
  operator ~       (                        ) const,
  operator +       ( const IString &aString ) const,
  operator +       ( const char    *pString ) const,
 &operator +=      ( const IString &aString ),
 &operator +=      ( const char    *pString ),
  operator &       ( const IString &aString ) const,
  operator &       ( const char    *pString ) const,
 &operator &=      ( const IString &aString ),
 &operator &=      ( const char    *pString ),
  operator |       ( const IString &aString ) const,
  operator |       ( const char    *pString ) const,
 &operator |=      ( const IString &aString ),
 &operator |=      ( const char    *pString ),
  operator ^       ( const IString &aString ) const,
  operator ^       ( const char    *pString ) const,
 &operator ^=      ( const IString &aString ),
 &operator ^=      ( const char    *pString );

friend IString
  operator +       ( const char    *pString,
                     const IString &aString ),
  operator &       ( const char    *pString,
                     const IString &aString ),
  operator |       ( const char    *pString,
                     const IString &aString ),
  operator ^       ( const char    *pString,
                     const IString &aString );
#line 277
unsigned
  size              ( ) const,
  length            ( ) const;

IString
  subString         ( unsigned startPos ) const,
  subString         ( unsigned startPos,
                      unsigned length,
                      char     padCharacter = ' ' ) const;

char
 &operator []       ( unsigned index );

const char
 &operator []       ( unsigned index ) const;

IStringEnum::CharType
  charType          ( unsigned index ) const;
#line 297
unsigned
  indexOf           ( const IString     &aString,
                      unsigned           startPos = 1 ) const,
  indexOf           ( const char        *pString,
                      unsigned           startPos = 1 ) const,
  indexOf           ( char              aCharacter,
                      unsigned           startPos = 1 ) const,
  indexOf           ( const IStringTest &aTest,
                      unsigned           startPos = 1 ) const,

  indexOfAnyBut     ( const IString     &validChars,
                      unsigned           startPos = 1 ) const,
  indexOfAnyBut     ( const char        *pValidChars,
                      unsigned           startPos = 1 ) const,
  indexOfAnyBut     ( char               validChar,
                     unsigned           startPos = 1 ) const,
  indexOfAnyBut     ( const IStringTest &aTest,
                      unsigned           startPos = 1 ) const,

  indexOfAnyOf      ( const IString     &searchChars,
                      unsigned           startPos = 1 ) const,
  indexOfAnyOf      ( const char        *pSearchChars,
                      unsigned           startPos = 1 ) const,
  indexOfAnyOf      ( char               searchChar,
                      unsigned           startPos = 1 ) const,
  indexOfAnyOf      ( const IStringTest &aTest,
                      unsigned           startPos = 1 ) const,

  occurrencesOf     ( const IString     &aString,
                      unsigned           startPos = 1 ) const,
  occurrencesOf     ( const char        *pString,
                      unsigned           startPos = 1 ) const,
  occurrencesOf     ( char              aCharacter,
                      unsigned           startPos = 1 ) const,
  occurrencesOf     ( const IStringTest &aTest,
                      unsigned           startPos = 1 ) const;
#line 336
unsigned
  lastIndexOf       ( const IString &aString,
                      unsigned       startPos = (unsigned)0xffffffff ) const,
  lastIndexOf       ( const char    *pString,
                      unsigned       startPos = (unsigned)0xffffffff ) const,
  lastIndexOf       ( char          aCharacter,
                      unsigned       startPos = (unsigned)0xffffffff ) const,
  lastIndexOf       ( const IStringTest &aTest,
                      unsigned           startPos = (unsigned)0xffffffff ) const,

  lastIndexOfAnyBut ( const IString     &validChars,
                      unsigned           startPos = (unsigned)0xffffffff ) const,
  lastIndexOfAnyBut ( const char        *pValidChars,
                      unsigned           startPos = (unsigned)0xffffffff ) const,
  lastIndexOfAnyBut ( char               validChar,
                      unsigned           startPos = (unsigned)0xffffffff ) const,
  lastIndexOfAnyBut ( const IStringTest &aTest,
                      unsigned           startPos = (unsigned)0xffffffff ) const,

  lastIndexOfAnyOf  ( const IString     &searchChars,
                      unsigned           startPos = (unsigned)0xffffffff ) const,
  lastIndexOfAnyOf  ( const char        *pSearchChars,
                      unsigned           startPos = (unsigned)0xffffffff ) const,
  lastIndexOfAnyOf  ( char               searchChar,
                      unsigned           startPos = (unsigned)0xffffffff ) const,
  lastIndexOfAnyOf  ( const IStringTest &aTest,
                      unsigned           startPos = (unsigned)0xffffffff ) const;
#line 365
IString
 ¢er            ( unsigned length,
                      char     padCharacter = ' ' ),

 &change            ( const IString &inputString,
                      const IString &outputString,
                      unsigned       startPos = 1,
                      unsigned       numChanges = (unsigned)0xffffffff ),
 &change            ( const IString &inputString,
                      const char    *pOutputString,
                      unsigned       startPos = 1,
                      unsigned       numChanges = (unsigned)0xffffffff ),
 &change            ( const char    *pInputString,
                      const IString &outputString,
                      unsigned       startPos = 1,
                      unsigned       numChanges = (unsigned)0xffffffff ),
 &change            ( const char    *pInputString,
                      const char    *pOutputString,
                      unsigned       startPos = 1,
                      unsigned       numChanges = (unsigned)0xffffffff ),

 ©              ( unsigned numCopies ),

 &insert            ( const IString &aString,
                      unsigned       index = 0,
                      char           padCharacter = ' ' ),
 &insert            ( const char    *pString,
                      unsigned       index = 0,
                      char           padCharacter = ' ' ),

 &leftJustify       ( unsigned length,
                      char     padCharacter = ' ' ),

 &lowerCase         ( ),

 &overlayWith       ( const IString &aString,
                      unsigned       index        = 1,
                      char           padCharacter = ' ' ),
 &overlayWith       ( const char    *pString,
                      unsigned       index        = 1,
                      char           padCharacter = ' ' ),

 &remove            ( unsigned startPos ),
 &remove            ( unsigned startPos,
                      unsigned numChars ),

 &reverse           ( ),

 &rightJustify      ( unsigned length,
                      char     padCharacter = ' ' ),

 &strip             ( ),
 &strip             ( char               aCharacter ),
 &strip             ( const IString     &aString ),
 &strip             ( const char        *pString ),
 &strip             ( const IStringTest &aTest ),

 &stripLeading      ( ),
 &stripLeading      ( char               aCharacter ),
 &stripLeading      ( const IString     &aString ),
 &stripLeading      ( const char        *pString ),
 &stripLeading      ( const IStringTest &aTest ),

 &stripTrailing     ( ),
 &stripTrailing     ( char               aCharacter ),
 &stripTrailing     ( const IString     &aString ),
 &stripTrailing     ( const char        *pString ),
 &stripTrailing     ( const IStringTest &aTest ),

 &translate         ( const IString &inputChars,
                      const IString &outputChars,
                      char           padCharacter = ' ' ),
 &translate         ( const IString &inputChars,
                      const char    *pOutputChars,
                      char           padCharacter = ' ' ),
 &translate         ( const char    *pInputChars,
                      const IString &outputChars,
                      char           padCharacter = ' ' ),
 &translate         ( const char    *pInputChars,
                      const char    *pOutputChars,
                      char           padCharacter = ' ' ),

 &upperCase         ( );

static IString
  center            ( const IString &aString,
                      unsigned       length,
                      char           padCharacter = ' ' ),

  change            ( const IString &aString,
                      const IString &inputString,
                      const IString &outputString,
                      unsigned       startPos = 1,
                      unsigned       numChanges = (unsigned)0xffffffff ),
  change            ( const IString &aString,
                      const IString &inputString,
                      const char    *pOutputString,
                      unsigned       startPos = 1,
                      unsigned       numChanges = (unsigned)0xffffffff ),
  change            ( const IString &aString,
                      const char    *pInputString,
                      const IString &outputString,
                      unsigned       startPos = 1,
                      unsigned       numChanges = (unsigned)0xffffffff ),
  change            ( const IString &aString,
                      const char    *pInputString,
                      const char    *pOutputString,
                      unsigned       startPos = 1,
                      unsigned       numChanges = (unsigned)0xffffffff ),

  copy              ( const IString &aString,
                      unsigned       numCopies ),

  insert            ( const IString &aString,
                      const IString &anInsert,
                      unsigned       index = 0,
                      char           padCharacter = ' ' ),
  insert            ( const IString &aString,
                      const char    *pInsert,
                      unsigned       index = 0,
                      char           padCharacter = ' ' ),

  leftJustify       ( const IString &aString,
                      unsigned       length,
                      char           padCharacter = ' ' ),

  lowerCase         ( const IString &aString ),

  overlayWith       ( const IString &aString,
                      const IString &anOverlay,
                      unsigned       index        = 1,
                      char           padCharacter = ' ' ),
  overlayWith       ( const IString &aString,
                      const char    *pOverlay,
                      unsigned       index        = 1,
                      char           padCharacter = ' ' ),

  remove            ( const IString &aString,
                      unsigned       startPos ),
  remove            ( const IString &aString,
                      unsigned       startPos,
                      unsigned       numChars ),

  reverse           ( const IString &aString ),

  rightJustify      ( const IString &aString,
                      unsigned       length,
                      char           padCharacter = ' ' ),

  stripBlanks       ( const IString &aString ),
  strip             ( const IString &aString,
                      char           aChar ),
  strip             ( const IString &aString,
                      const IString &aStringOfChars ),
  strip             ( const IString &aString,
                      const char    *pStringOfChars ),
  strip             ( const IString &aString,
                      const IStringTest &aTest ),

  stripLeadingBlanks ( const IString &aString ),
  stripLeading      ( const IString &aString,
                      char           aChar ),
  stripLeading      ( const IString &aString,
                      const IString &aStringOfChars ),
  stripLeading      ( const IString &aString,
                      const char    *pStringOfChars ),
  stripLeading      ( const IString &aString,
                      const IStringTest &aTest ),

  stripTrailingBlanks ( const IString &aString ),
  stripTrailing     ( const IString &aString,
                      char           aChar ),
  stripTrailing     ( const IString &aString,
                      const IString &aStringOfChars ),
  stripTrailing     ( const IString &aString,
                      const char    *pStringOfChars ),
  stripTrailing     ( const IString &aString,
                      const IStringTest &aTest ),

  translate         ( const IString &aString,
                      const IString &inputChars,
                      const IString &outputChars,
                      char           padCharacter = ' ' ),
  translate         ( const IString &aString,
                      const IString &inputChars,
                      const char    *pOutputChars,
                      char           padCharacter = ' ' ),
  translate         ( const IString &aString,
                      const char    *pInputChars,
                      const IString &outputChars,
                      char           padCharacter = ' ' ),
  translate         ( const IString &aString,
                      const char    *pInputChars,
                      const char    *pOutputChars,
                      char           padCharacter = ' ' ),

  upperCase         ( const IString &aString );
#line 564
IString
 &removeWords       ( unsigned firstWord ),
 &removeWords       ( unsigned firstWord,
                      unsigned numWords ),

 &space             ( unsigned numSpaces = 1,
                      char     spaceChar = ' ' ),

  word              ( unsigned  wordNumber ) const,

  words             ( unsigned  firstWord ) const,
  words             ( unsigned  firstWord,
                      unsigned  numWords  ) const;

unsigned
  indexOfPhrase     ( const IString &wordString,
                      unsigned       startWord = 1 ) const,

  indexOfWord       ( unsigned wordNumber ) const,

  lengthOfWord      ( unsigned wordNumber ) const,

  numWords          ( ) const,

  wordIndexOfPhrase ( const IString &aPhrase,
                      unsigned       startWord = 1 ) const;

static IString
  space             ( const IString &aString,
                      unsigned       numSpaces = 1,
                      char           spaceChar = ' ' ),

  removeWords       ( const IString &aString,
                      unsigned       startWord ),
  removeWords       ( const IString &aString,
                      unsigned       startWord,
                      unsigned       numWords  );
#line 604
protected:

static const char
 *null,
 *zero,
 *maxLong;

static char
 *nullBuffer;
#line 615
IString
 &setBuffer         ( IBuffer *ibuff ),

 &initBuffer        ( const void *p1,
                      unsigned    len1,
                      const void *p2      = 0,
                      unsigned    len2    = 0,
                      const void *p3      = 0,
                      unsigned    len3    = 0,
                      char        padChar = 0 ),
 &initBuffer        ( long n ),
 &initBuffer        ( unsigned long n ),
 &initBuffer        ( double d );
#line 631
char
 *data              ( ) const;

IBuffer
 *buffer            ( ) const;

static unsigned
  lengthOf          ( const char *p );

static char
 *defaultBuffer     ( );
#line 645
typedef enum {
  charIndex,
  wordIndex
  } IndexType;

unsigned
  indexOfWord       ( unsigned wordNumber,
                      unsigned startPos,
                      unsigned numWords ) const,

  occurrencesOf     ( const char *pSearchString,
                      unsigned    searchLen,
                      unsigned    startPos ) const,
#line 660
  findPhrase        ( const IString &aPhrase,
                      unsigned       startWord,
                      IndexType      charOrWord ) const;

Boolean
  isLike            ( const char *pPattern,
                      unsigned    patternLen,
                      char        zeroOrMore,
                      char        anyChar ) const,

  isAbbrevFor       ( const char *pFullString,
                      unsigned    fullLen,
                      unsigned    minLen ) const;
#line 675
IString
 &change            ( const char *pPattern,
                      unsigned    patternLen,
                      const char *pReplacement,
                      unsigned    replacementLen,
                      unsigned    startPos,
                      unsigned    numChanges ),

 &insert            ( const char *pInsert,
                      unsigned    insertLen,
                      unsigned    startPos,
                      char        padCharacter ),

 &overlayWith       ( const char *pOverlay,
                      unsigned    overlayLen,
                      unsigned    index,
                      char        padCharacter ),

 &strip             ( const char             *p,
                      unsigned                len,
                      IStringEnum::StripMode  mode ),

 &strip             ( const IStringTest      &aTest,
                      IStringEnum::StripMode  mode ),

 &translate         ( const char *pInputChars,
                      unsigned    inputLen,
                      const char *pOutputChars,
                      unsigned    outputLen,
                      char        padCharacter );
#line 708
typedef enum {
  and,
  or,
  exclusiveOr
  } BitOperator;

IString
 &applyBitOp        ( const char *pArg,
                      unsigned    argLen,
                      BitOperator op );
#line 721
private:

  IString           ( IBuffer *pBuffer );
void
  binaryMath        ( unsigned char newDigit ),
  decimalMath       ( unsigned char newDigit );
IString
 &prepareToChange   ( );
char
 *pBuffer;

static void
  setDefaultBuffer  ( char * );
friend class IBuffer;
};

#pragma pack()
#line 17 "F:\vacpp\INCLUDE\istring.inl"
extern "C"
  {
#line 2 "F:\vacpp\INCLUDE\ctype.h"
#pragma info( none )

   #pragma info( none )

#pragma info( restore )
#line 13
      extern "C" {
#line 34
   int _Optlink isalnum( int );
   int _Optlink isalpha( int );

     int _Optlink isblank( int );

   int _Optlink iscntrl( int );
   int _Optlink isdigit( int );
   int _Optlink isgraph( int );
   int _Optlink islower( int );
   int _Optlink isprint( int );
   int _Optlink ispunct( int );
   int _Optlink isspace( int );
   int _Optlink isupper( int );
   int _Optlink isxdigit( int );
   int _Optlink tolower( int );
   int _Optlink toupper( int );
#line 93
   extern const unsigned short *_ctype;
#line 96
      inline int isalnum ( int c )
                          { return _ctype[(c)] & 0x0800U; }
      inline int isalpha ( int c )
                          { return _ctype[(c)] & 0x0100U; }
      inline int iscntrl ( int c )
                          { return _ctype[(c)] & 0x0020U; }
      inline int isdigit ( int c )
                          { return _ctype[(c)] & 0x0002U; }
      inline int isgraph ( int c )
                          { return _ctype[(c)] & 0x0200U; }
      inline int islower ( int c )
                          { return _ctype[(c)] & 0x0040U; }
      inline int isprint ( int c )
                          { return _ctype[(c)] & 0x0400U; }
      inline int ispunct ( int c )
                          { return _ctype[(c)] & 0x0010U; }
      inline int isspace ( int c )
                          { return _ctype[(c)] & 0x0008U; }
      inline int isupper ( int c )
                          { return _ctype[(c)] & 0x0080U; }
      inline int isxdigit( int c )
                          { return _ctype[(c)] & 0x0001U; }
      inline int tolower ( int c )
                          { return (signed short)_ctype[(c) + 514]; }
      inline int toupper ( int c )
                          { return (signed short)_ctype[(c) + 257]; }
#line 146
      int _Optlink _tolower( int );
      int _Optlink _toupper( int );
      int _Optlink _isascii( int );
      int _Optlink _iscsymf( int );
      int _Optlink _iscsym( int );
      int _Optlink _toascii( int );
      int _Optlink isblank( int );
#line 155
      #pragma info( none )
#line 165
         inline int isascii( int c ) { return ( (unsigned)(c) < 0x80 ); }
         inline int iscsymf( int c ) { return ( isalpha( c ) || (c) == '_' ); }
         inline int iscsym ( int c ) { return ( isalnum( c ) || (c) == '_' ); }
         inline int toascii( int c ) { return ( (c) & 0x7f ); }
         inline int isblank ( int c )
                             { return _ctype[(c)] & 0x1000U; }
#line 179
      #pragma info( restore )
#line 185
      }
#line 191
#pragma info( none )

   #pragma info( restore )

#pragma info( restore )
#line 2 "F:\vacpp\INCLUDE\limits.h"
#pragma info( none )

   #pragma info( none )

#pragma info( restore )
#line 69
#pragma info( none )

   #pragma info( restore )

#pragma info( restore )
#line 2 "F:\vacpp\INCLUDE\string.h"
#pragma info( none )

   #pragma info( none )

#pragma info( restore )
#line 13
      extern "C" {
#line 44
      typedef unsigned int size_t;
#line 56
   char * _Builtin __strcat( char *, const char * );
   char * _Builtin __strchr( const char *, int );
   int    _Builtin __strcmp( const char *, const char * );
   char * _Builtin __strcpy( char*, const char * );
   size_t _Builtin __strlen( const char * );
   char * _Builtin __strncat( char *, const char *, size_t );
   int    _Builtin __strncmp( const char *, const char *, size_t );
   char * _Builtin __strncpy( char *, const char *, size_t );
   char * _Builtin __strrchr( const char *, int );
#line 67
   int     _Optlink strcoll( const char *, const char * );
   size_t  _Optlink strcspn( const char *, const char * );
   char *  _Optlink strerror( int );
   char *  _Optlink strpbrk( const char *, const char * );
   size_t  _Optlink strspn( const char *, const char * );
   char *  _Optlink strstr( const char *, const char * );
   char *  _Optlink strtok( char*, const char * );
   size_t  _Optlink strxfrm( char *, const char *, size_t );
#line 78
      inline char * _Optlink strcat( char * s1, const char * s2 )
                               { return __strcat( s1, s2 ); }
      inline char * _Optlink strchr( const char * s, int ch )
                               { return __strchr( s, ch ); }
      inline int    _Optlink strcmp( const char * s1, const char * s2 )
                               { return __strcmp( s1, s2 ); }
      inline char * _Optlink strcpy( char * s1, const char * s2 )
                               { return __strcpy( s1, s2 ); }
      inline size_t _Optlink strlen( const char * s )
                               { return __strlen( s ); }
      inline char * _Optlink strncat( char * s1, const char * s2, size_t len )
                               { return __strncat( s1, s2, len ); }
      inline int    _Optlink strncmp( const char * s1, const char * s2, size_t len )
                               { return __strncmp( s1, s2, len ); }
      inline char * _Optlink strncpy( char * s1, const char * s2, size_t len )
                               { return __strncpy( s1, s2, len ); }
      inline char * _Optlink strrchr( const char * s1, int ch )
                               { return __strrchr( s1, ch ); }
#line 137
      void * _Builtin __memcpy( void *, const void *, size_t );
      void * _Builtin __memchr( const void *, int, size_t );
      int    _Builtin __memcmp( const void *, const void *, size_t );
      void * _Builtin __memset( void *, int, size_t );
      void * _Builtin __memmove( void *, const void *, size_t );
#line 146
         inline void * _Optlink memcpy( void * m1, const void * m2, size_t len )
                                  { return __memcpy( m1, m2, len ); }
         inline void * _Optlink memchr( const void * m, int ch, size_t len )
                                  { return __memchr( m, ch, len ); }
         inline int    _Optlink memcmp( const void * m1, const void * m2, size_t len )
                                  { return __memcmp( m1, m2, len ); }
         inline void * _Optlink memset( void * m, int ch, size_t len )
                                  { return __memset( m, ch, len ); }
         inline void * _Optlink memmove( void * m1, const void * m2, size_t len )
                                  { return __memmove( m1, m2, len ); }
#line 183
         void *  _Optlink memccpy( void *, void *, int, unsigned int );
         int     _Optlink memicmp( void *, void *, unsigned int );
#line 199
      char *  _Optlink strdup( const char * );
      int     _Optlink stricmp( const char *, const char * );
      char *  _Optlink strlwr( char * );
      int     _Optlink strnicmp( const char *, const char *, size_t );
      char *  _Optlink strupr( char * );

      int     _Optlink strcmpi( const char *, const char * );
      char *  _Optlink strrev( char * );
      char *  _Optlink strset( char *, int );
      char *  _Optlink strnset( char *, int, size_t );
      char *  _Optlink _strerror( char * );
#line 222
      size_t  _Optlink _fstrcspn( const char *, const char * );
      char *  _Optlink _fstrdup( const char * );
      char *  _Optlink _nstrdup( const char * );
      int     _Optlink _fstricmp( const char *, const char * );
      char *  _Optlink _fstrlwr( char * );
      int     _Optlink _fstrnicmp( const char *, const char *, size_t );
      char *  _Optlink _fstrnset( char *, int, size_t );
      char *  _Optlink _fstrpbrk( const char *, const char * );
      char *  _Optlink _fstrrev( char * );
      char *  _Optlink _fstrset( char *, int );
      size_t  _Optlink _fstrspn( const char *, const char * );
      char *  _Optlink _fstrstr( const char *, const char * );
      char *  _Optlink _fstrtok( char*, const char * );
      char *  _Optlink _fstrupr( char * );
#line 238
      #pragma map( _fstrcspn , "strcspn"  )
      #pragma map( _fstrdup  , "strdup"   )
      #pragma map( _nstrdup  , "strdup"   )
      #pragma map( _fstricmp , "stricmp"  )
      #pragma map( _fstrlwr  , "strlwr"   )
      #pragma map( _fstrnicmp, "strnicmp" )
      #pragma map( _fstrnset , "strnset"  )
      #pragma map( _fstrpbrk , "strpbrk"  )
      #pragma map( _fstrrev  , "strrev"   )
      #pragma map( _fstrset  , "strset"   )
      #pragma map( _fstrspn  , "strspn"   )
      #pragma map( _fstrstr  , "strstr"   )
      #pragma map( _fstrtok  , "strtok"   )
      #pragma map( _fstrupr  , "strupr"   )
#line 272
      }
#line 278
#pragma info( none )

   #pragma info( restore )

#pragma info( restore )
#line 2 "F:\vacpp\INCLUDE\stdlib.h"
#pragma info( none )

   #pragma info( none )

#pragma info( restore )
#line 13
      extern "C" {
#line 49
     typedef unsigned short wchar_t;
#line 52
   typedef struct _div_t
       {
       int quot;
       int rem;
       } div_t;

   typedef struct _ldiv_t
       {
       long int quot;
       long int rem;
       } ldiv_t;
#line 85
      typedef unsigned long  _System  _EH_RTN(void *,void *,void *,void *);
#line 91
   extern int  _Optlink _eh_del(_EH_RTN *);
   extern int  _Optlink _eh_add(_EH_RTN *);
   extern int  _mb_cur_max;
#line 99
   int      _Builtin __abs( int );
   long int _Builtin __labs( long int );
#line 103
   double    _Optlink atof( const char * );
   int       _Optlink atoi( const char * );
   long int  _Optlink atol( const char * );
   double    _Optlink strtod( const char *, char ** );
   long int  _Optlink strtol( const char *, char **, int );
   unsigned long int  _Optlink strtoul( const char *, char **, int );
   int       _Optlink rand( void );
   void      _Optlink srand( unsigned int );
   void *   ( _Optlink calloc)( size_t, size_t );
   void     ( _Optlink free)( void * );
   void *   ( _Optlink malloc)( size_t );
   void *   ( _Optlink realloc)( void *, size_t );
   void      _Optlink abort( void );
   int       _Optlink atexit( void ( * )( void ) );
   void      _Optlink exit( int );
   char *    _Optlink getenv( const char * );
   int       _Optlink system( const char * );
   void *    _Optlink bsearch( const void *, const void *, size_t, size_t,
                              int ( * _Optlink __compare )( const void *, const void * ) );
   void      _Optlink qsort( void *, size_t, size_t,
                            int ( * _Optlink __compare )( const void *, const void * ) );
   div_t     _Optlink div( int, int );
   ldiv_t    _Optlink ldiv( long int, long int );
   int       _Optlink mblen( const char *, size_t );
   int       _Optlink mbtowc( wchar_t *, const char *, size_t );
   int       _Optlink wctomb( char *, wchar_t );
   size_t    _Optlink mbstowcs( wchar_t *, const char *, size_t );
   size_t    _Optlink wcstombs( char *, const wchar_t *, size_t );
#line 134
      inline int      _Optlink abs ( int x )      { return __abs ( x ); }
      inline long int _Optlink labs( long int l ) { return __labs( l ); }
#line 156
         void * _Builtin __alloca( size_t );
         #pragma info( none )
#line 160
         #pragma info( restore )
#line 163
      unsigned char _Builtin __parmdwords( void );
#line 166
      long double  _Optlink _atold( const char * );
      char *  _Optlink  ecvt( double, int, int *, int * );
      char *  _Optlink _ecvt( double, int, int *, int * );
      char *  _Optlink  fcvt( double, int, int *, int * );
      char *  _Optlink _fcvt( double, int, int *, int * );
      int     _Optlink _freemod( unsigned long );
      char *  _Optlink _fullpath(char *, char *, size_t);
      char *  _Optlink  gcvt( double, int, char * );
      char *  _Optlink _gcvt( double, int, char * );
      int    ( _Optlink _heapmin)( void );
      char *  _Optlink  itoa( int, char *, int );
      char *  _Optlink _itoa( int, char *, int );
      int     _Optlink _loadmod( char *, unsigned long * );
      char *  _Optlink  ltoa( long, char *, int );
      char *  _Optlink _ltoa( long, char *, int );
      size_t  _Optlink _msize(void *);
      int     _Optlink  putenv( const char * );
      int     _Optlink _putenv( const char * );
      long double  _Optlink  strtold( const char *, char ** );
      long double  _Optlink _strtold( const char *, char ** );
      char *  _Optlink  ultoa( unsigned long, char *, int );
      char *  _Optlink _ultoa( unsigned long, char *, int );
#line 190
      #pragma map( ecvt    , "_ecvt"    )
      #pragma map( fcvt    , "_fcvt"    )
      #pragma map( gcvt    , "_gcvt"    )
      #pragma map( itoa    , "_itoa"    )
      #pragma map( ltoa    , "_ltoa"    )
      #pragma map( ultoa   , "_ultoa"   )
      #pragma map( putenv  , "_putenv"  )
      #pragma map( _strtold, "strtold"  )
#line 301
         int   _Optlink _beginthread( void ( * _Optlink thread )( void * ), void *, unsigned, void * );
         void  _Optlink _endthread( void );
         void **  _Optlink _threadstore( void );
#line 307
      #pragma map( atof  , "_atofieee"   )
      #pragma map( strtod, "_strtodieee" )
#line 317
         void  _Builtin __enable( void );
         void  _Builtin __disable( void );
#line 326
               int *  _Optlink _errno( void );

               #pragma info( none )
#line 332
               #pragma info( restore )
#line 348
               int *  _Optlink __doserrno(void);

               #pragma info( none )
#line 354
               #pragma info( restore )
#line 368
         extern char **  _environ;
         extern unsigned char  _osmajor;
         extern unsigned char  _osminor;
         extern unsigned char  _osmode;
#line 378
         typedef int ( __onexit_t )( void );
         typedef __onexit_t * onexit_t;
#line 390
         void            _Optlink _exit( int );
         onexit_t        _Optlink  onexit( onexit_t );
         onexit_t        _Optlink _onexit( onexit_t );
#line 395
         unsigned long  _Builtin  __lrotl(unsigned long, int);
         unsigned long  _Builtin  __lrotr(unsigned long, int);
         unsigned short _Builtin  __srotl(unsigned short, int);
         unsigned short _Builtin  __srotr(unsigned short, int);
         unsigned char  _Builtin  __crotl(unsigned char, int);
         unsigned char  _Builtin  __crotr(unsigned char, int);
#line 420
         void            _Optlink _makepath( char *, char *, char *, char *, char * );
         void            _Optlink _splitpath( char *, char *, char *, char *, char * );
         void            _Optlink _searchenv( char *, char *, char *);
         void            _Optlink  swab( char *, char *, int );
         void            _Optlink _swab( char *, char *, int );
#line 427
         #pragma map( onexit , "_onexit"  )
         #pragma map( swab   , "_swab"    )
#line 434
         int            _Optlink rpmatch(const char *);
         int            _Optlink csid(const char *);
         int            _Optlink wcsid(const wchar_t);
#line 439
         #pragma map( rpmatch, "_rpmatch" )
         #pragma map( csid   , "_csid"    )
         #pragma map( wcsid  , "_wcsid"   )
#line 468
      }
#line 474
#pragma info( none )

   #pragma info( restore )

#pragma info( restore )
#line 23 "F:\vacpp\INCLUDE\istring.inl"
  }
#line 18 "F:\vacpp\INCLUDE\ibuffer.hpp"
extern "C" {
#line 2 "F:\vacpp\INCLUDE\stddef.h"
#pragma info( none )

   #pragma info( none )

#pragma info( restore )
#line 13
      extern "C" {
#line 42
   typedef int ptrdiff_t;
#line 86
         unsigned *  _Optlink __threadid( void );
#line 109
      }
#line 115
#pragma info( none )

   #pragma info( restore )

#pragma info( restore )
#line 20 "F:\vacpp\INCLUDE\ibuffer.hpp"
  }
#line 25
#pragma pack(4)

class IStringTest;

class IBuffer : public IVBase {
public:

IBuffer
 *newBuffer           ( const void* p1,
                        unsigned    len1,
                        const void* p2      = 0,
                        unsigned    len2    = 0,
                        const void* p3      = 0,
                        unsigned    len3    = 0,
                        char        padChar = 0 ) const;

static unsigned
  checkAddition       ( unsigned addend1,
                        unsigned addend2 ),
  checkMultiplication ( unsigned factor1,
                        unsigned factor2 ),
  overflow            ( );

static void
  setDefaultBuffer    ( IBuffer* newDefaultBuffer );
#line 52
static IBuffer
 *defaultBuffer ( ),
 *fromContents  ( const char *pBuffer );

IBuffer
 *null          ( ) const;

unsigned
  useCount      ( ) const,
  length        ( ) const;

const char
 *contents      ( ) const;

char
 *contents      ( );

virtual IStringEnum::CharType
  charType      ( unsigned index ) const;

virtual char
 *next          ( const char *prev );

virtual const char
 *next          ( const char *prev ) const;
#line 79
void
  addRef    ( ),
  removeRef ( );
#line 84
typedef enum {
  equal,
  greaterThan,
  lessThan
  } Comparison;

virtual Comparison
  compare ( const void* p,
            unsigned    len ) const;
#line 95
virtual IBuffer
 *subString ( unsigned startPos,
              unsigned len,
              char     padCharacter ) const;
#line 101
virtual IString
  asDebugInfo ( ) const;
#line 105
virtual Boolean
  isAlphanumeric ( ) const,
  isAlphabetic   ( ) const,
  isASCII        ( ) const,
  isControl      ( ) const,
  isDigits       ( ) const,
  isGraphics     ( ) const,
  isHexDigits    ( ) const,
  isLowerCase    ( ) const,
  isPrintable    ( ) const,
  isPunctuation  ( ) const,
  isUpperCase    ( ) const,
  isWhiteSpace   ( ) const;
#line 120
virtual Boolean
  isMBCS       ( ) const,
  isDBCS       ( ) const,
  isSBCS       ( ) const,
  isValidMBCS  ( ) const,
  isValidDBCS  ( ) const,
  includesMBCS ( ) const,
  includesDBCS ( ) const,
  includesSBCS ( ) const;
#line 131
virtual unsigned
  indexOf           ( const char*        pString,
                      unsigned           len,
                      unsigned           startPos = 1 ) const,
  indexOf           ( const IStringTest& aTest,
                      unsigned           startPos = 1 ) const,
  indexOfAnyBut     ( const char*        pString,
                      unsigned           len,
                      unsigned           startPos = 1 ) const,
  indexOfAnyBut     ( const IStringTest& aTest,
                      unsigned           startPos = 1 ) const,
  indexOfAnyOf      ( const char*        pString,
                      unsigned           len,
                      unsigned           startPos = 1 ) const,
  indexOfAnyOf      ( const IStringTest& aTest,
                      unsigned           startPos = 1 ) const,
  lastIndexOf       ( const char*        pString,
                      unsigned           len,
                      unsigned           startPos = 0 ) const,
  lastIndexOf       ( const IStringTest& aTest,
                      unsigned           startPos = 0 ) const,
  lastIndexOfAnyBut ( const char*        pString,
                      unsigned           len,
                      unsigned           startPos = 0 ) const,
  lastIndexOfAnyBut ( const IStringTest& aTest,
                      unsigned           startPos = 0 ) const,
  lastIndexOfAnyOf  ( const char*        pString,
                      unsigned           len,
                      unsigned           startPos = 0 ) const,
  lastIndexOfAnyOf  ( const IStringTest& aTest,
                      unsigned           startPos = 0 ) const;
#line 164
virtual IBuffer
 *center       ( unsigned newLen,
                 char     padCharacter ),
 *change       ( const char* pSource,
                 unsigned    sourceLen,
                 const char* pTarget,
                 unsigned    targetLen,
                 unsigned    startPos,
                 unsigned    numChanges ),
 *copy         ( unsigned numCopies ),
 *insert       ( const char* pInsert,
                 unsigned    insertLen,
                 unsigned    pos,
                 char        padCharacter ),
 *leftJustify  ( unsigned newLen,
                 char     padCharacter ),
 *lowerCase    ( ),
 *overlayWith  ( const char* overlay,
                 unsigned    len,
                 unsigned    pos,
                 char        padCharacter ),
 *remove       ( unsigned startPos,
                 unsigned numChars ),
 *reverse      ( ),
 *rightJustify ( unsigned newLen,
                 char     padCharacter ),
 *strip        ( const char*            pChars,
                 unsigned               len,
                 IStringEnum::StripMode mode ),
 *strip        ( const IStringTest&     aTest,
                 IStringEnum::StripMode mode ),
 *translate    ( const char* pInputChars,
                 unsigned    inputLen,
                 const char* pOutputChars,
                 unsigned    outputLen,
                 char        padCharacter ),
 *upperCase    ( );

protected:

virtual unsigned
  startSearch          ( unsigned startPos,
                         unsigned searchLen ) const,
  startBackwardsSearch ( unsigned startPos,
                         unsigned searchLen ) const;
#line 211
virtual IBuffer
 *allocate        ( unsigned bufLength ) const;
#line 225
void
 *operator new    ( size_t   t,
                    unsigned bufLen );
void
  operator delete ( void*    p );
#line 234
static char
  dbcsTable[ 256 ];
#line 239
static IBuffer
 *initialize ( );
#line 243
virtual const char
 *className ( ) const;
#line 247
  IBuffer ( unsigned newLen );
 ~IBuffer ( );

private:

unsigned
  refs,
  len;
char
  data[1];
static IBuffer
 *nullBuffer;

static IBuffer
 *nullIBuffer;
};

#pragma pack()
#line 24 "F:\vacpp\INCLUDE\ibuffer.inl"
extern "C" {
#line 2 "F:\vacpp\INCLUDE\limits.h"
#pragma info( none )

   #pragma info( none )

#pragma info( restore )
#line 69
#pragma info( none )

   #pragma info( restore )

#pragma info( restore )
#line 26 "F:\vacpp\INCLUDE\ibuffer.inl"
}
#line 34
#pragma info(nopar)
#line 37
inline unsigned IBuffer :: checkAddition ( unsigned addend1, unsigned addend2 )
  {
  return ( addend1 < 0xffffffff - addend2 ) ? addend1 + addend2 : overflow();
  }
inline unsigned IBuffer :: checkMultiplication ( unsigned factor1, unsigned factor2 )
  {
  return ( factor1 < 0xffffffff / factor2 ) ? factor1 * factor2 : overflow();
  }

inline void IBuffer :: addRef ( )
  {
  refs++;
  }
inline void IBuffer :: removeRef ( )
  {
#line 55
  if ( --refs == 0 )
    delete this;
  }

inline unsigned IBuffer :: useCount ( ) const
  {
  return refs;
  }
inline unsigned IBuffer :: length ( ) const
  {
  return len;
  }
inline const char *IBuffer :: contents ( ) const
  {
  return data;
  }
inline char *IBuffer :: contents ( )
  {
  return data;
  }
inline IBuffer *IBuffer :: fromContents ( const char *p )
  {
  return (IBuffer*)( p - __offsetof( IBuffer, data ) );
  }

#pragma info(restore)
#line 29 "F:\vacpp\INCLUDE\ibuffern.inl"
inline void* IBuffer::operator new ( size_t, unsigned realSize )
{
  void *p = ::new char[ checkAddition( sizeof( IBuffer ), realSize ) ];
  return p;
}

inline void IBuffer::operator delete ( void *p )
{
  ::delete [] (char*)p;
}
#line 20 "F:\vacpp\INCLUDE\istrtest.hpp"
#pragma pack(4)

extern "C"
  {
  typedef IBase::Boolean _Optlink ICStrTestFn( int );
  }

class IStringTest : public IVBase {
typedef IVBase
  Inherited;

public:
#line 34
typedef ICStrTestFn
  CFunction;
typedef Boolean
  CPPFunction( int );
#line 40
  IStringTest ( CFunction   &cFunc );
 ~IStringTest ( );
#line 44
virtual Boolean
  test        ( int c ) const;

protected:

enum FnType {
  user,
  c,
  cpp,
  memFn,
  cMemFn
  };

FnType
  type;

union { CFunction *cFn; void *user; } data;
#line 63
  IStringTest ( FnType  type,
                void   *userData );

};

template < class T >
class IStringTestMemberFn : public IStringTest {
public:

typedef Boolean
 ( T::*ConstFn )( int ) const;
typedef Boolean
 ( T::*NonconstFn )( int );
#line 78
  IStringTestMemberFn ( const T    &object,
                        ConstFn     constFn )
    : IStringTest ( user, (void*)&object ),
      cMF         ( constFn )
    {
    }
  IStringTestMemberFn ( T          &object,
                        NonconstFn  nonconstFn )
    : IStringTest ( user, (void*)&object ),
      ncMF        ( nonconstFn )
    {
    }
#line 92
virtual Boolean
  test                ( int c ) const
    {
    if ( this->type == cMemFn )
      return ((const T*)data.user->*cMF)( c );
    else
      return ((T*)data.user->*ncMF)( c );
    }

private:

union { ConstFn cMF; NonconstFn ncMF; };

};

#pragma pack()
#line 36 "F:\vacpp\INCLUDE\istrtest.inl"
inline IStringTest :: IStringTest ( FnType typ, void *p )
  : type( typ )
  {
  data.user = p;
  }
#line 48 "F:\vacpp\INCLUDE\istring.inl"
inline IBuffer *IString :: buffer( ) const
  {
#line 53
  return IBuffer::fromContents( pBuffer );
  }
inline char *IString::defaultBuffer ( )
  {
  return ( nullBuffer ) ?
           nullBuffer
           :
           ( nullBuffer = IBuffer::defaultBuffer()->contents() );
  }
inline char *IString :: data ( ) const
  {
  return pBuffer;
  }
inline unsigned IString :: lengthOf ( const char *p )
  {
  return p ? strlen( p ) : 0;
  }
inline IString &IString :: setBuffer( IBuffer *ibuff )
  {
#line 75
  pBuffer = ibuff->contents();
  return *this;
  }
inline void IString :: setDefaultBuffer ( char *newDefaultBuffer )
  {
  nullBuffer = newDefaultBuffer;
  }
inline void IBuffer :: setDefaultBuffer ( IBuffer *newDefaultBuffer )
  {
#line 87
  if ( IBuffer::nullBuffer )
    IBuffer::nullBuffer -> removeRef();
  IBuffer::nullBuffer = newDefaultBuffer;
  IString::setDefaultBuffer( newDefaultBuffer->data );
  }

inline unsigned IString :: length ( ) const
  {
  return this->buffer() -> length();
  }
inline unsigned IString :: size ( ) const
  {
  return this->buffer() -> length();
  }
inline IStringEnum::CharType IString :: charType ( unsigned index ) const
  {
  return this->buffer() -> charType( index );
  }

inline unsigned IString :: indexOf ( const IString &aString,
                                     unsigned       startPos ) const
  {
  return this->buffer()->indexOf( aString.data(),
                                  aString.length(),
                                  startPos );
  }
inline unsigned IString :: indexOf ( const char *pString,
                                     unsigned    startPos ) const
  {
  return this->buffer()->indexOf( pString,
                                  lengthOf( pString ),
                                  startPos );
  }
inline unsigned IString :: indexOf ( const IStringTest &aTest,
                                     unsigned           startPos ) const
  {
  return this->buffer()->indexOf( aTest,
                                  startPos );
  }
inline unsigned IString :: indexOfAnyBut ( const IString &aString,
                                           unsigned       startPos ) const
  {
  return this->buffer()->indexOfAnyBut( aString.data(),
                                        aString.length(),
                                        startPos );
  }
inline unsigned IString :: indexOfAnyBut ( const char *pValidChars,
                                           unsigned    startPos ) const
  {
  return this->buffer()->indexOfAnyBut( pValidChars,
                                        lengthOf( pValidChars ),
                                        startPos );
  }
inline unsigned IString :: indexOfAnyBut ( char     validChar,
                                           unsigned startPos ) const
  {
  return this->buffer()->indexOfAnyBut( &validChar,
                                        1,
                                        startPos );
  }
inline unsigned IString :: indexOfAnyBut ( const IStringTest &aTest,
                                           unsigned           startPos ) const
  {
  return this->buffer()->indexOfAnyBut( aTest,
                                        startPos );
  }
inline unsigned IString :: indexOfAnyOf ( const IString &aString,
                                          unsigned       startPos ) const
  {
  return this->buffer()->indexOfAnyOf( aString.data(),
                                       aString.length(),
                                       startPos );
  }
inline unsigned IString :: indexOfAnyOf ( const char *pSearchChars,
                                          unsigned    startPos ) const
  {
  return this->buffer()->indexOfAnyOf( pSearchChars,
                                       lengthOf( pSearchChars ),
                                       startPos );
  }
inline unsigned IString :: indexOfAnyOf ( char     searchChar,
                                          unsigned startPos ) const
  {
  return this->buffer()->indexOfAnyOf( &searchChar,
                                       1,
                                       startPos );
  }
inline unsigned IString :: indexOfAnyOf ( const IStringTest &aTest,
                                          unsigned           startPos ) const
  {
  return this->buffer()->indexOfAnyOf( aTest,
                                       startPos );
  }
inline unsigned IString :: lastIndexOf ( const IString &aString,
                                         unsigned       startPos ) const
  {
  return this->buffer()->lastIndexOf( aString.data(),
                                      aString.length(),
                                      startPos );
  }
inline unsigned IString :: lastIndexOf ( const char *pString,
                                         unsigned    startPos ) const
  {
  return this->buffer()->lastIndexOf( pString,
                                      lengthOf( pString ),
                                      startPos );
  }
inline unsigned IString :: lastIndexOf ( const IStringTest &aTest,
                                         unsigned           startPos ) const
  {
  return this->buffer()->lastIndexOf( aTest,
                                      startPos );
  }
inline unsigned IString :: lastIndexOfAnyBut ( const IString &aString,
                                               unsigned       startPos ) const
  {
  return this->buffer()->lastIndexOfAnyBut( aString.data(),
                                            aString.length(),
                                            startPos );
  }
inline unsigned IString :: lastIndexOfAnyBut ( const char *pValidChars,
                                               unsigned    startPos ) const
  {
  return this->buffer()->lastIndexOfAnyBut( pValidChars,
                                            lengthOf( pValidChars ),
                                            startPos );
  }
inline unsigned IString :: lastIndexOfAnyBut ( char     validChar,
                                               unsigned startPos ) const
  {
  return this->buffer()->lastIndexOfAnyBut( &validChar,
                                            1,
                                            startPos );
  }
inline unsigned IString :: lastIndexOfAnyBut ( const IStringTest &aTest,
                                               unsigned           startPos ) const
  {
  return this->buffer()->lastIndexOfAnyBut( aTest,
                                           startPos );
  }
inline unsigned IString :: lastIndexOfAnyOf ( const IString &aString,
                                              unsigned       startPos ) const
  {
  return this->buffer()->lastIndexOfAnyOf( aString.data(),
                                           aString.length(),
                                           startPos );
  }
inline unsigned IString :: lastIndexOfAnyOf ( const char *pSearchChars,
                                              unsigned    startPos ) const
  {
  return this->buffer()->lastIndexOfAnyOf( pSearchChars,
                                           lengthOf( pSearchChars ),
                                           startPos );
  }
inline unsigned IString :: lastIndexOfAnyOf ( char     searchChar,
                                              unsigned startPos ) const
  {
  return this->buffer()->lastIndexOfAnyOf( &searchChar,
                                           1,
                                           startPos );
  }
inline unsigned IString :: lastIndexOfAnyOf ( const IStringTest &aTest,
                                              unsigned           startPos ) const
  {
  return this->buffer()->lastIndexOfAnyOf( aTest,
                                           startPos );
  }
inline unsigned IString :: occurrencesOf ( const IString &aString,
                                           unsigned       startPos ) const
  {
  return this->occurrencesOf( aString.data(),
                              aString.length(),
                              startPos );
  }
inline unsigned IString :: occurrencesOf ( const char *pString,
                                           unsigned    startPos ) const
  {
  return this->occurrencesOf( pString,
                              lengthOf( pString ),
                              startPos );
  }

inline IBase::Boolean IString :: isAlphanumeric ( ) const
  { return this->buffer()->isAlphanumeric(); }
inline IBase::Boolean IString :: isAlphabetic ( ) const
  { return this->buffer()->isAlphabetic(); }
inline IBase::Boolean IString :: isASCII ( ) const
  { return this->buffer()->isASCII(); }
inline IBase::Boolean IString :: isControl ( ) const
  { return this->buffer()->isControl(); }
inline IBase::Boolean IString :: isDigits ( ) const
  { return this->buffer()->isDigits(); }
inline IBase::Boolean IString :: isGraphics ( ) const
  { return this->buffer()->isGraphics(); }
inline IBase::Boolean IString :: isHexDigits ( ) const
  { return this->buffer()->isHexDigits(); }
inline IBase::Boolean IString :: isLowerCase ( ) const
  { return this->buffer()->isLowerCase(); }
inline IBase::Boolean IString :: isPrintable ( ) const
  { return this->buffer()->isPrintable(); }
inline IBase::Boolean IString :: isPunctuation ( ) const
  { return this->buffer()->isPunctuation(); }
inline IBase::Boolean IString :: isUpperCase ( ) const
  { return this->buffer()->isUpperCase(); }
inline IBase::Boolean IString :: isWhiteSpace ( ) const
  { return this->buffer()->isWhiteSpace(); }
inline IBase::Boolean IString :: isMBCS ( ) const
  { return this->buffer()->isMBCS(); }
inline IBase::Boolean IString :: isDBCS ( ) const
  { return this->buffer()->isDBCS(); }
inline IBase::Boolean IString :: isSBCS ( ) const
  { return this->buffer()->isSBCS(); }
inline IBase::Boolean IString :: isValidMBCS ( ) const
  { return this->buffer()->isValidMBCS(); }
inline IBase::Boolean IString :: isValidDBCS ( ) const
  { return this->buffer()->isValidDBCS(); }
inline IBase::Boolean IString :: includesMBCS ( ) const
  { return this->buffer()->includesMBCS(); }
inline IBase::Boolean IString :: includesDBCS ( ) const
  { return this->buffer()->includesDBCS(); }
inline IBase::Boolean IString :: includesSBCS ( ) const
  { return this->buffer()->includesSBCS(); }
inline IBase::Boolean IString :: isLike ( const IString &aPattern,
                                          char           zeroOrMore,
                                          char           anyChar ) const
  {
  return this->isLike( aPattern.data(),
                       aPattern.length(),
                       zeroOrMore,
                       anyChar );
  }
inline IBase::Boolean IString :: isLike ( const char *pPattern,
                                          char        zeroOrMore,
                                          char        anyChar ) const
  {
  return this->isLike( pPattern,
                       lengthOf(pPattern),
                       zeroOrMore,
                       anyChar );
  }
inline IBase::Boolean IString :: isAbbreviationFor ( const IString &aString,
                                                     unsigned       minAbbrevLength ) const
  {
  return this->isAbbrevFor( aString.data(),
                            aString.length(),
                            minAbbrevLength );
  }
inline IBase::Boolean IString :: isAbbreviationFor ( const char *pString,
                                                     unsigned    minAbbrevLength ) const
  {
  return this->isAbbrevFor( pString,
                            lengthOf( pString ),
                            minAbbrevLength );
  }
inline IBase::Boolean IString :: includes ( const IString &aString ) const
  {
  return this->indexOf( aString );
  }
inline IBase::Boolean IString :: includes ( const char *pString ) const
  {
  return this->indexOf( pString );
  }
inline IBase::Boolean IString :: includes ( char aChar ) const
  {
  return this->indexOf( aChar );
  }
inline IBase::Boolean IString :: includes ( const IStringTest &aTest ) const
  {
  return this->indexOf( aTest );
  }

inline IBase::Boolean operator == ( const IString &string1, const IString &string2 )
  {
  return ( string1.buffer()->compare( string2.data(),
                                     string2.length() ) == IBuffer::equal );
  }
inline IBase::Boolean operator == ( const IString &string1, const char *pString2 )
  {
  return
    ( string1.buffer()->compare( pString2,
                                 IString::lengthOf( pString2 ) )
      == IBuffer::equal );
  }
inline IBase::Boolean operator == ( const char *pString1, const IString &string2 )
  {
  return
    ( string2.buffer()->compare( pString1,
                                 IString::lengthOf( pString1 ) )
      == IBuffer::equal );
  }
inline IBase::Boolean operator != ( const IString &string1, const IString &string2 )
  {
  return !( string1 == string2 );
  }
inline IBase::Boolean operator != ( const IString &string1, const char *pString2 )
  {
  return !( string1 == pString2 );
  }
inline IBase::Boolean operator != ( const char *pString1, const IString &string2 )
  {
  return !( pString1 == string2 );
  }
inline IBase::Boolean operator >  ( const IString &string1, const IString &string2 )
  {
  return
    ( string1.buffer()->compare( string2.data(),
                                 string2.length() )
      == IBuffer::greaterThan );
  }
inline IBase::Boolean operator >  ( const IString &string1, const char *pString2 )
  {
  return
    ( string1.buffer()->compare( pString2,
                                 IString::lengthOf( pString2 ) )
      == IBuffer::greaterThan );
  }
inline IBase::Boolean operator >  ( const char *pString1, const IString &string2 )
  {
  return
    ( string2.buffer()->compare( pString1,
                                 IString::lengthOf( pString1 ) )
      == IBuffer::lessThan );
  }
inline IBase::Boolean operator >= ( const IString &string1, const IString &string2 )
  {
  return !
    ( string1.buffer()->compare( string2.data(),
                                 string2.length() )
      == IBuffer::lessThan );
  }
inline IBase::Boolean operator >= ( const IString &string1, const char *pString2 )
  {
  return !
    ( string1.buffer()->compare( pString2,
                                 IString::lengthOf( pString2 ) )
      == IBuffer::lessThan );
  }
inline IBase::Boolean operator >= ( const char *pString1, const IString &string2 )
  {
  return !
    ( string2.buffer()->compare( pString1,
                                 IString::lengthOf( pString1 ) )
      == IBuffer::greaterThan );
  }
inline IBase::Boolean operator <  ( const IString &string1, const IString &string2 )
  {
  return !( string1 >= string2 );
  }
inline IBase::Boolean operator <  ( const IString &string1, const char *pString2 )
  {
  return !( string1 >= pString2 );
  }
inline IBase::Boolean operator <  ( const char *pString1, const IString &string2 )
  {
  return !( pString1 >= string2 );
  }
inline IBase::Boolean operator <= ( const IString &string1, const IString &string2 )
  {
  return !( string1 > string2 );
  }
inline IBase::Boolean operator <= ( const IString &string1, const char *pString2 )
  {
  return !( string1 > pString2 );
  }
inline IBase::Boolean operator <= ( const char *pString1, const IString &string2 )
  {
  return !( pString1 > string2 );
  }

inline IString IString :: asString ( ) const
  {
  return *this;
  }
inline long int IString :: asInt ( ) const
  {
  return strtol( this->data(), 0, 10 );
  }
inline unsigned long IString :: asUnsigned ( ) const
  {
  return strtoul( this->data(), 0, 10 );
  }
inline double IString :: asDouble ( ) const
  {
  return strtod( this->data(), 0 );
  }
inline IString :: operator char* ( ) const
  {
  return this->data();
  }
inline IString :: operator unsigned char* ( ) const
  {
  return (unsigned char*) this->data();
  }
inline IString :: operator signed char* ( ) const
  {
  return (signed char*) this->data();
  }
inline IString IString :: c2b( const IString &aString )
  {
  return IString(aString).c2b();
  }
inline IString IString :: c2d( const IString &aString )
  {
  return IString(aString).c2d();
  }
inline IString IString :: c2x( const IString &aString )
  {
  return IString(aString).c2x();
  }
inline IString IString :: b2c( const IString &aString )
  {
  return IString(aString).b2c();
  }
inline IString & IString :: b2d ( )
  {
  this->b2c().c2d();
  return *this;
  }
inline IString IString :: b2d( const IString &aString )
  {
  return IString(aString).b2d();
  }
inline IString & IString :: b2x ( )
  {
  this->b2c().c2x();
  return *this;
  }
inline IString IString :: b2x( const IString &aString )
  {
  return IString(aString).b2x();
  }
inline IString IString :: d2c( const IString &aString )
  {
  return IString(aString).d2c();
  }
inline IString & IString :: d2b ( )
  {
  this->d2c().c2b();
  return *this;
  }
inline IString IString :: d2b( const IString &aString )
  {
  return IString(aString).d2b();
  }
inline IString & IString :: d2x ( )
  {
  this->d2c().c2x();
  return *this;
  }
inline IString IString :: d2x( const IString &aString )
  {
  return IString(aString).d2x();
  }
inline IString IString :: x2c( const IString &aString )
  {
  return IString(aString).x2c();
  }
inline IString & IString :: x2b ( )
  {
  this->x2c().c2b();
  return *this;
  }
inline IString IString :: x2b( const IString &aString )
  {
  return IString(aString).x2b();
  }
inline IString & IString :: x2d ( )
  {
  this->x2c().c2d();
  return *this;
  }
inline IString IString :: x2d( const IString &aString )
  {
  return IString(aString).x2d();
  }

inline IString & IString :: change ( const IString &aPattern,
                                     const IString &aReplacement,
                                     unsigned       startPos,
                                     unsigned       numChanges )
  {
  return this->change( aPattern.data(),
                       aPattern.length(),
                       aReplacement.data(),
                       aReplacement.length(),
                       startPos,
                       numChanges );
  }
inline IString & IString :: change ( const IString &aPattern,
                                     const char    *pReplacement,
                                     unsigned       startPos,
                                     unsigned       numChanges )
  {
  return this->change( aPattern.data(),
                       aPattern.length(),
                       pReplacement,
                       lengthOf( pReplacement ),
                       startPos,
                       numChanges );
  }
inline IString & IString :: change ( const char    *pPattern,
                                     const IString &aReplacement,
                                     unsigned       startPos,
                                     unsigned       numChanges )
  {
  return this->change( pPattern,
                       lengthOf( pPattern ),
                       aReplacement.data(),
                       aReplacement.length(),
                       startPos,
                       numChanges );
  }
inline IString & IString :: change ( const char *pPattern,
                                     const char *pReplacement,
                                     unsigned    startPos,
                                     unsigned    numChanges )
  {
  return this->change( pPattern,
                       lengthOf( pPattern ),
                       pReplacement,
                       lengthOf( pReplacement ),
                       startPos,
                       numChanges );
  }
inline IString IString :: change ( const IString &aString,
                        const IString &aPattern,
                        const char    *pReplacement,
                        unsigned       startPos,
                        unsigned       numChanges )
  {
  return IString(aString).change( aPattern,
                                  pReplacement,
                                  startPos,
                                  numChanges );
  }
inline IString IString :: change ( const IString &aString,
                        const char    *pPattern,
                        const IString &aReplacement,
                        unsigned       startPos,
                        unsigned       numChanges )
  {
  return IString(aString).change( pPattern,
                                  aReplacement,
                                  startPos,
                                  numChanges );
  }
inline IString IString :: copy ( const IString &aString,
                      unsigned       numCopies )
  {
  return IString(aString).copy( numCopies );
  }
inline IString & IString :: insert ( const IString &aString,
                                     unsigned       index,
                                     char           padCharacter )
  {
  return this->insert( aString.data(),
                       aString.length(),
                       index,
                       padCharacter );
  }
inline IString & IString :: insert ( const char *pString,
                                     unsigned    index,
                                     char        padCharacter )
  {
  return this->insert( pString,
                       lengthOf( pString ),
                       index,
                       padCharacter );
  }
inline IString IString :: insert ( const IString &aString,
                        const IString &anInsert,
                        unsigned       index,
                        char           padCharacter )
  {
  return IString(aString).insert( anInsert, index, padCharacter );
  }
inline IString IString :: insert ( const IString &aString,
                        const char    *pInsert,
                        unsigned       index,
                        char           padCharacter )
  {
  return IString(aString).insert( pInsert, index, padCharacter );
  }
inline IString IString :: leftJustify ( const IString &aString,
                             unsigned       newLength,
                             char           padCharacter )
  {
  return IString(aString).leftJustify( newLength, padCharacter );
  }
inline IString IString :: lowerCase ( const IString &aString )
  {
  return IString(aString).lowerCase();
  }
inline IString & IString :: overlayWith ( const IString &aString,
                                          unsigned       index,
                                          char           padCharacter )
  {
  return this->overlayWith( aString.data(),
                            aString.length(),
                            index,
                            padCharacter );
  }
inline IString& IString :: overlayWith ( const char *pString,
                                         unsigned    index,
                                         char        padCharacter )
   {
   return this->overlayWith( pString,
                             lengthOf( pString ),
                             index,
                             padCharacter );
   }
inline IString IString :: overlayWith ( const IString &aString,
                             const IString &anOverlay,
                             unsigned       index,
                             char           padCharacter )
  {
  return IString(aString).overlayWith( anOverlay, index, padCharacter );
  }
inline IString IString :: overlayWith ( const IString &aString,
                             const char    *pOverlay,
                             unsigned       index,
                             char           padCharacter )
  {
  return IString(aString).overlayWith( pOverlay, index, padCharacter );
  }
inline IString IString :: remove ( const IString &aString,
                                   unsigned       startPos )
  {
  return IString::remove( aString, startPos, (unsigned)0xffffffff );
  }
inline IString IString :: reverse ( const IString &aString )
  {
  return IString(aString).reverse();
  }
inline IString IString :: rightJustify ( const IString &aString,
                              unsigned       newLength,
                              char           padCharacter )
  {
  return IString(aString).rightJustify( newLength, padCharacter );
  }
inline IString & IString :: stripLeading ( )
  {
  return this->strip( IStringTest( isspace ), IStringEnum::leading );
  }
inline IString & IString :: stripTrailing ( )
  {
  return this->strip( IStringTest( isspace ), IStringEnum::trailing );
  }
inline IString & IString :: strip ( char aChar )
  {
  return this->strip( &aChar, 1, IStringEnum::both );
  }
inline IString & IString :: stripLeading ( char aChar )
  {
  return this->strip( &aChar, 1, IStringEnum::leading );
  }
inline IString & IString :: stripTrailing ( char aChar )
  {
  return this->strip( &aChar, 1, IStringEnum::trailing );
  }
inline IString & IString :: strip ( const IString &aString )
  {
  return this->strip( aString.data(), aString.length(), IStringEnum::both );
  }
inline IString & IString :: stripLeading ( const IString &aString )
  {
  return this->strip( aString.data(), aString.length(), IStringEnum::leading );
  }
inline IString & IString :: stripTrailing ( const IString &aString )
  {
  return this->strip( aString.data(), aString.length(), IStringEnum::trailing );
  }
inline IString & IString :: strip ( const char *pString )
  {
  return this->strip( pString, lengthOf( pString ), IStringEnum::both );
  }
inline IString & IString :: stripLeading ( const char *pString )
  {
  return this->strip( pString, lengthOf( pString ), IStringEnum::leading );
  }
inline IString & IString :: stripTrailing ( const char *pString )
  {
  return this->strip( pString, lengthOf( pString ), IStringEnum::trailing );
  }
inline IString & IString :: strip ( const IStringTest &aTest )
  {
  return this->strip( aTest, IStringEnum::both );
  }
inline IString & IString :: stripLeading ( const IStringTest &aTest )
  {
  return this->strip( aTest, IStringEnum::leading );
  }
inline IString & IString :: stripTrailing ( const IStringTest &aTest )
  {
  return this->strip( aTest, IStringEnum::trailing );
  }
inline IString IString :: stripBlanks ( const IString &aString )
  {
  return IString(aString).strip();
  }
inline IString IString :: strip ( const IString &aString,
                       char           aChar )
  {
  return IString(aString).strip(aChar);
  }
inline IString IString :: strip ( const IString &aString,
                       const IString &aStringOfChars )
  {
  return IString(aString).strip(aStringOfChars);
  }
inline IString IString :: strip ( const IString &aString,
                       const char    *pStringOfChars )
  {
  return IString(aString).strip(pStringOfChars);
  }
inline IString IString :: strip ( const IString     &aString,
                       const IStringTest &aTest )
  {
  return IString(aString).strip(aTest);
  }
inline IString IString :: stripLeadingBlanks ( const IString &aString )
  {
  return IString(aString).stripLeading();
  }
inline IString IString :: stripLeading ( const IString &aString,
                              char           aChar )
  {
  return IString(aString).stripLeading(aChar);
  }
inline IString IString :: stripLeading ( const IString &aString,
                              const IString &aStringOfChars )
  {
  return IString(aString).stripLeading(aStringOfChars);
  }
inline IString IString :: stripLeading ( const IString &aString,
                              const char    *pStringOfChars )
  {
  return IString(aString).stripLeading(pStringOfChars);
  }
inline IString IString :: stripLeading ( const IString     &aString,
                              const IStringTest &aTest )
  {
  return IString(aString).stripLeading(aTest);
  }
inline IString IString :: stripTrailingBlanks ( const IString &aString )
  {
  return IString(aString).stripTrailing();
  }
inline IString IString :: stripTrailing ( const IString &aString,
                               char           aChar )
  {
  return IString(aString).stripTrailing(aChar);
  }
inline IString IString :: stripTrailing ( const IString &aString,
                               const IString &aStringOfChars )
  {
  return IString(aString).stripTrailing(aStringOfChars);
  }
inline IString IString :: stripTrailing ( const IString &aString,
                               const char    *pStringOfChars )
  {
  return IString(aString).stripTrailing(pStringOfChars);
  }
inline IString IString :: stripTrailing ( const IString     &aString,
                               const IStringTest &aTest )
  {
  return IString(aString).stripTrailing(aTest);
  }
inline IString & IString :: translate ( const IString &inputChars,
                                        const IString &outputChars,
                                        char           padCharacter )
  {
  return this->translate( inputChars.data(),
                          inputChars.length(),
                          outputChars.data(),
                          outputChars.length(),
                          padCharacter );
  }
inline IString & IString :: translate ( const IString &inputChars,
                                        const char    *pOutputChars,
                                        char           padCharacter )
  {
  return this->translate( inputChars.data(),
                          inputChars.length(),
                          pOutputChars,
                          lengthOf( pOutputChars ),
                          padCharacter );
  }
inline IString & IString :: translate ( const char    *pInputChars,
                                        const IString &outputChars,
                                        char           padCharacter )
  {
  return this->translate( pInputChars,
                          lengthOf( pInputChars ),
                          outputChars.data(),
                          outputChars.length(),
                          padCharacter );
  }
inline IString & IString :: translate ( const char *pInputChars,
                                        const char *pOutputChars,
                                        char        padCharacter )
  {
  return this->translate( pInputChars,
                          lengthOf( pInputChars ),
                          pOutputChars,
                          lengthOf( pOutputChars ),
                          padCharacter );
  }
inline IString IString :: translate ( const IString &aString,
                           const IString &inputChars,
                           const IString &outputChars,
                           char           padCharacter )
  {
  return IString(aString).translate( inputChars, outputChars, padCharacter );
  }
inline IString IString :: translate ( const IString &aString,
                           const IString &inputChars,
                           const char    *pOutputChars,
                           char           padCharacter )
  {
  return IString(aString).translate( inputChars, pOutputChars, padCharacter );
  }
inline IString IString :: translate ( const IString &aString,
                           const char    *pInputChars,
                           const IString &outputChars,
                           char           padCharacter )
  {
  return IString(aString).translate( pInputChars, outputChars, padCharacter );
  }
inline IString IString :: translate ( const IString &aString,
                           const char    *pInputChars,
                           const char    *pOutputChars,
                           char           padCharacter )
  {
  return IString(aString).translate( pInputChars, pOutputChars, padCharacter );
  }

inline IString & IString :: removeWords ( unsigned firstWord )
  {
  return this->removeWords( firstWord, (unsigned)0xffffffff );
  }
inline IString IString :: removeWords ( const IString &aString,
                             unsigned       firstWord )
  {
  return IString(aString).removeWords( firstWord );
  }
inline IString IString :: removeWords ( const IString &aString,
                             unsigned       firstWord,
                             unsigned       numWords )
  {
  return IString(aString).removeWords( firstWord, numWords );
  }
inline unsigned IString :: indexOfPhrase ( const IString &aPhrase,
                                           unsigned       startWord ) const
   {
   return this->findPhrase ( aPhrase, startWord, charIndex );
   }
inline unsigned IString :: indexOfWord ( unsigned wordNumber ) const
  {
  return this->indexOfWord( wordNumber, 1, 0 );
  }
inline unsigned IString :: wordIndexOfPhrase( const IString &aPhrase,
                                              unsigned       startWord ) const
  {
  return this->findPhrase( aPhrase, startWord, wordIndex );
  }
inline IString IString :: space ( const IString &aString,
                       unsigned       numSpaces,
                       char           spaceChar )
  {
  return IString(aString).space( numSpaces, spaceChar );
  }
inline IString IString :: words ( unsigned firstWord ) const
  {
  return this->words( firstWord, (unsigned)0xffffffff );
  }
#line 27 "F:\vacpp\INCLUDE\inotebk.hpp"
class IResourceId;
class ITabBitmapMgr;
class INotebookData;
class INotebookCursorData;
class INotebookPageSettingsData;
class IColor;

#pragma pack(4)

class IPageHandle : public IHandle {
typedef IHandle
  Inherited;
public:

  IPageHandle ( Value pageId = 0 );
#line 44
  operator Value ( ) const;

};
#line 49
class INotebook : public IControl {
typedef IControl
  Inherited;
public:
class Style;

  INotebook   ( unsigned long        windowId,
                IWindow*             parent,
                IWindow*             owner,
                const IRectangle&    initial = IRectangle(),
                const Style&         style = defaultStyle() );

  INotebook   ( unsigned long        windowId,
                IWindow*             parentAndOwner );
  INotebook   ( const IWindowHandle& handle );

virtual
  ~INotebook ( );
#line 69
class Style : public IBitFlag{friend class INotebook;public: class NegatedStyle : public IBitFlag { friend class Style; public: NegatedStyle ( const IWindow::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline NegatedStyle operator & ( const NegatedStyle &lhs, const NegatedStyle &rhs ); friend inline Style operator & ( const NegatedStyle &lhs, const Style &rhs ); NegatedStyle ( const IControl::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} protected: NegatedStyle ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Style& operator |= ( const Style &aFlag ) { Style tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedStyle operator ~ ( ) const { NegatedStyle aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Style& operator &= ( const NegatedStyle &aFlag ) { Style tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Style ( const IWindow::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline Style operator | ( const Style &lhs, const Style &rhs ); friend inline Style operator & ( const Style &lhs, const NegatedStyle &rhs ); Style ( const IControl::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {}protected: Style ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};

static const Style
  classDefaultStyle,
  spiralBinding,
  solidBinding,
  backPagesBottomRight,
  backPagesBottomLeft,
  backPagesTopRight,
  backPagesTopLeft,
  majorTabsRight,
  majorTabsLeft,
  majorTabsTop,
  majorTabsBottom,
  squareTabs,
  roundedTabs,
  polygonTabs,
  statusTextLeft,
  statusTextRight,
  statusTextCenter,
  tabTextLeft,
  tabTextRight,
  tabTextCenter;

static Style
  defaultStyle      ( );

static void
  setDefaultStyle   ( const Style&    style );

virtual unsigned long
  convertToGUIStyle ( const IBitFlag& style,
                      Boolean         extendedOnly = false ) const;
#line 104
enum TextAlignment {
  left,
  right,
  center
};

virtual INotebook
 &setStatusTextAlignment ( TextAlignment       alignment ),
 &setStatusText          ( const IPageHandle&  referencePage,
                           const char*         statusText ),
 &setStatusText          ( const IPageHandle&  referencePage,
                           const IResourceId&  resourceId );

virtual TextAlignment
  statusTextAlignment    ( ) const;
#line 121
enum TabShape {
  square,
  rounded,
  polygon
};

virtual INotebook
 &setTabShape         ( TabShape             tabShape ),
 &setMajorTabSize     ( const ISize&         sizeMajorTab ),
 &setMinorTabSize     ( const ISize&         sizeMinorTab );

virtual TabShape
  tabShape            ( ) const;

virtual INotebook
 &setTabTextAlignment ( TextAlignment        alignment ),
 &refreshTabs         ( ),
 &setTabText          ( const IPageHandle&   referencePage,
                        const char*          tabText ),
 &setTabText          ( const IPageHandle&   referencePage,
                        const IResourceId&   resourceId ),
 &setTabBitmap        ( const IPageHandle&   referencePage,
                        const IBitmapHandle& bitmap ),
 &setTabBitmap        ( const IPageHandle&   referencePage,
                        const IResourceId&   resourceId );

virtual TextAlignment
  tabTextAlignment    ( ) const;
#line 151
virtual INotebook
 &setPageButtonSize ( const ISize& sizePageButton );
#line 155
enum Orientation {
  backpagesBottomTabsRight,
  backpagesTopTabsRight,
  backpagesBottomTabsLeft,
  backpagesTopTabsLeft,
  backpagesRightTabsTop,
  backpagesLeftTabsTop,
  backpagesRightTabsBottom,
  backpagesLeftTabsBottom
};

virtual INotebook
 &setOrientation   ( Orientation orientation );

virtual Orientation
  orientation      ( ) const;
#line 173
enum Binding {
  spiral,
  solid
};

virtual INotebook
 &setBinding     ( Binding binding );

virtual Binding
  binding        ( ) const;
#line 185
virtual IColor
  backgroundColor              ( ) const,
  hiliteBackgroundColor        ( ) const,
  pageBackgroundColor          ( ) const,
  majorTabBackgroundColor      ( ) const,
  minorTabBackgroundColor      ( ) const,
  majorTabForegroundColor      ( ) const,
  minorTabForegroundColor      ( ) const;

virtual INotebook
 &setPageBackgroundColor       ( const IColor& color ),
 &setMajorTabBackgroundColor   ( const IColor& color ),
 &setMinorTabBackgroundColor   ( const IColor& color ),
 &setMajorTabForegroundColor   ( const IColor& color ),
 &setMinorTabForegroundColor   ( const IColor& color );
#line 202
virtual INotebook
 &resetPageBackgroundColor     ( ),
 &resetMajorTabBackgroundColor ( ),
 &resetMinorTabBackgroundColor ( ),
 &resetMajorTabForegroundColor ( ),
 &resetMinorTabForegroundColor ( );
#line 210
class PageSettings : public IVBase {
typedef IVBase
  Inherited;
friend class INotebook;
public:

class Attribute : public IBitFlag{friend class INotebook::PageSettings;public: class NegatedAttribute : public IBitFlag { friend class Attribute; public: NegatedAttribute operator & ( const NegatedAttribute &aFlag ) const { NegatedAttribute aResult ( asUnsignedLong() & aFlag.asUnsignedLong(), asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong() ); return aResult; } protected: NegatedAttribute ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Attribute& operator |= ( const Attribute &aFlag ) { Attribute tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedAttribute operator ~ ( ) const { NegatedAttribute aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Attribute& operator &= ( const NegatedAttribute &aFlag ) { Attribute tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Attribute operator | ( const Attribute &aFlag ) const { Attribute aResult ( asUnsignedLong() | aFlag.asUnsignedLong(), asExtendedUnsignedLong() | aFlag.asExtendedUnsignedLong() ); return aResult; } Attribute operator & ( const NegatedAttribute &aFlag ) const { Attribute aResult ( asUnsignedLong() & aFlag.asUnsignedLong(), asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong() ); return aResult; } unsigned long operator & ( const Attribute &aFlag ) const { unsigned long ulResult = asUnsignedLong() & aFlag.asUnsignedLong(); return ( ulResult | (asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong()) ); }protected: Attribute ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};
static const Attribute
  autoPageSize,
  statusTextOn,
  majorTab,
  minorTab,
  noAttribute;
#line 225
  PageSettings  ( );
  PageSettings  ( const Attribute&               attribute );
  PageSettings  ( const char*                    tabText,
                  const char*                    statusText = 0,
                  const Attribute&               pageAttribute = noAttribute );
  PageSettings  ( const IBitmapHandle&           tabBitmap,
                  const char*                    statusText = 0,
                  const Attribute&               pageAttribute = noAttribute );
  PageSettings  ( const INotebook::PageSettings& pageSettings );

virtual
  ~PageSettings ( );
#line 240
virtual INotebook::PageSettings
 &setStatusText     ( const char*        statusText ),
 &setStatusText     ( const IResourceId& resourceId );

virtual IString
  statusText        ( ) const;

Boolean
  isStatusTextOn    ( ) const;
#line 251
virtual INotebook::PageSettings
 &setTabText        ( const char*          tabText ),
 &setTabText        ( const IResourceId&   resourceId ),
 &setTabBitmap      ( const IBitmapHandle& bitmap ),
 &setTabBitmap      ( const IResourceId&   resourceId );

virtual IString
  tabText           ( ) const;

virtual IBitmapHandle
  tabBitmap         ( ) const;

Boolean
  isMajorTab        ( ) const,
  isMinorTab        ( ) const;
#line 268
virtual INotebook::PageSettings
 &setUserData       ( unsigned long userData );

virtual unsigned long
  userData          ( ) const;
#line 275
Boolean
  isAutoSize       ( ) const;

private:

Attribute
  pageStyle;
IBitmapHandle
  savedTabBitmap;
unsigned long
  savedUserData;
IString
  savedStatusText,
  savedTabText;

INotebookPageSettingsData
 *fPageSettingsData;
};
#line 295
class Cursor : public IVBase {
typedef IVBase
  Inherited;
public :

  Cursor  ( const INotebook& notebook );

virtual
  ~Cursor ( );
#line 306
virtual Boolean
  setToFirst    ( ),
  setToNext     ( ),
  setToPrevious ( ),
  setToLast     ( ),
  isValid       ( ) const;

virtual void
  invalidate    ( );
#line 317
virtual IPageHandle
  first      ( ),
  next       ( ),
  previous   ( ),
  last       ( ),
  current    ( ) const;

void
  setCurrent ( const IPageHandle& current );
#line 328
private:

Cursor       ( const Cursor& cursor );
Cursor
 &operator=  ( const Cursor& cursor );
#line 335
const INotebook
 &nbCl;
unsigned long
  ulClCurrentPageId;
unsigned long
  ulClReferences;

INotebookCursorData
 *fCursorData;
};
#line 348
virtual IPageHandle
  addFirstPage      ( const PageSettings& pageInfo,
                      IWindow*            pageWindow = 0 ),
  addLastPage       ( const PageSettings& pageInfo,
                      IWindow*            pageWindow = 0 ),
  addPageBefore     ( const PageSettings& pageInfo,
                      const IPageHandle&  referencePage,
                      IWindow*            pageWindow = 0 ),
  addPageAfter      ( const PageSettings& pageInfo,
                      const IPageHandle&  referencePage,
                      IWindow*            pageWindow = 0 ),
  addPageBefore     ( const PageSettings& pageInfo,
                      const Cursor&       cursor,
                      IWindow*            pageWindow = 0 ),
  addPageAfter      ( const PageSettings& pageInfo,
                      const Cursor&       cursor,
                      IWindow*            pageWindow = 0 );
#line 367
virtual INotebook
 &removePage        ( const IPageHandle&  page ),
 &removePage        ( const Cursor&       cursor ),
 &removeAllPages    ( ),
 &removeTabSection  ( const IPageHandle&  page ),
 &removeTabSection  ( const Cursor&       cursor );
#line 375
virtual INotebook
 &turnToPage        ( const IPageHandle&  page ),
 &turnToPage        ( const Cursor&       cursor );

virtual IPageHandle
  topPage           ( ) const,
  firstPage         ( ) const,
  lastPage          ( ) const,
  nextPage          ( const IPageHandle&  referencePage ) const,
  previousPage      ( const IPageHandle&  referencePage ) const;
#line 387
PageSettings
  pageSettings      ( const Cursor&       cursor ) const,
  pageSettings      ( const IPageHandle&  page ) const;
#line 392
virtual INotebook
 &setUserData       ( const IPageHandle& referencePage,
                      unsigned long      userData );
#line 397
virtual IWindow
 *window            ( const Cursor&      cursor ) const,
 *window            ( const IPageHandle& page ) const;

virtual INotebook
 &setWindow         ( const Cursor&      cursor,
                            IWindow*     pageWindow = 0 ),
 &setWindow         ( const IPageHandle& referencePage,
                            IWindow*     pageWindow = 0 );
#line 409
virtual ISize
  pageSize        ( ) const,
  notebookSize    ( const IPageHandle& page ) const;

virtual unsigned long
  totalPages      ( ) const,
  pagesToMajorTab ( const IPageHandle& page ) const,
  pagesToMajorTab ( const Cursor&      cursor ) const,
  pagesToMinorTab ( const IPageHandle& page ) const,
  pagesToMinorTab ( const Cursor&      cursor ) const,
  pagesToEnd      ( const IPageHandle& page ) const,
  pagesToEnd      ( const Cursor&      cursor ) const;

virtual Boolean
  isEmpty         ( ) const;
#line 426
static INotificationId const
  pageBackgroundColorId,
  majorTabBackgroundColorId,
  minorTabBackgroundColorId,
  majorTabForegroundColorId,
  minorTabForegroundColorId,
  orientationId;

virtual IWindow
 &enableNotification ( Boolean enable=true );

protected:

virtual ISize
  calcMinimumSize ( ) const;
#line 443
private:

INotebook   ( const INotebook& notebook );
INotebook
 &operator= ( const INotebook& notebook );
#line 450
INotebookData
 *fNotebookData;

static Style
  currentDefaultStyle;

unsigned long
  queryPage      ( void* mp1, void* mp2 ) const,
  insertPage     ( void* mp1, void* mp2 );
Boolean
  deletePage     ( void* mp1, void* mp2 );
short
  queryPageCount ( void* mp1, void* mp2 ) const;
IPageHandle
  insertPageInfo ( const PageSettings& pageInfo,
                   const IPageHandle&  referencePage,
                   IWindow*            window,
                   unsigned long       fPosition );
#line 470
ITabBitmapMgr
 *bmClTabBitmapMgr;
unsigned long
  ulClValidate;

friend class INotebook::Cursor;
friend class INotebookHandler;

class clrFlags : public IBitFlag{friend class INotebook;public: class NegatedclrFlags : public IBitFlag { friend class clrFlags; public: NegatedclrFlags operator & ( const NegatedclrFlags &aFlag ) const { NegatedclrFlags aResult ( asUnsignedLong() & aFlag.asUnsignedLong(), asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong() ); return aResult; } protected: NegatedclrFlags ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; clrFlags& operator |= ( const clrFlags &aFlag ) { clrFlags tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedclrFlags operator ~ ( ) const { NegatedclrFlags aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } clrFlags& operator &= ( const NegatedclrFlags &aFlag ) { clrFlags tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } clrFlags operator | ( const clrFlags &aFlag ) const { clrFlags aResult ( asUnsignedLong() | aFlag.asUnsignedLong(), asExtendedUnsignedLong() | aFlag.asExtendedUnsignedLong() ); return aResult; } clrFlags operator & ( const NegatedclrFlags &aFlag ) const { clrFlags aResult ( asUnsignedLong() & aFlag.asUnsignedLong(), asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong() ); return aResult; } unsigned long operator & ( const clrFlags &aFlag ) const { unsigned long ulResult = asUnsignedLong() & aFlag.asUnsignedLong(); return ( ulResult | (asExtendedUnsignedLong() & aFlag.asExtendedUnsignedLong()) ); }protected: clrFlags ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};
static const clrFlags
  bgnPageColor,
  bgnMajorColor,
  bgnMinorColor,
  fgnMajorColor,
  fgnMinorColor;

INotebook::clrFlags
  colorFlags;

void setNotebookColors   ( unsigned long color,
                           unsigned long colorArea );
void storeNotebookColors ( unsigned long color,
                           unsigned long
                           colorArea );
IColor UnsignedLongAsRGB ( unsigned long color ) const;

struct NotebookColors
{
  unsigned long  pageBackgroundColor;
  unsigned long  majorTabBackgroundColor;
  unsigned long  minorTabBackgroundColor;
  unsigned long  majorTabForegroundColor;
  unsigned long  minorTabForegroundColor;
};
NotebookColors
 *pnotebookColors;
#line 509
public:
enum ColorArea {
  pageBackground,
  majorTabBackground,
  majorTabForeground,
  minorTabBackground,
  minorTabForeground,
  notebookWindowBackground,
  notebookOutline,
  statusLineText,
  selectionCursor
};
virtual INotebook
 &setColor        ( ColorArea      area,
                    const IColor&  color );
virtual IColor
  color           ( ColorArea      area ) const;

virtual IColor
  backgroundPageColor   () const,
  backgroundMajorColor  () const,
  backgroundMinorColor  () const,
  foregroundMajorColor  () const,
  foregroundMinorColor  () const;

virtual INotebook
 &setBackgroundPageColor  (const IColor& color),
 &setBackgroundMajorColor (const IColor& color),
 &setBackgroundMinorColor (const IColor& color),
 &setForegroundMajorColor (const IColor& color),
 &setForegroundMinorColor (const IColor& color);
#line 542
};

inline INotebook::Style operator | ( const INotebook::Style &lhs, const INotebook::Style &rhs ){ INotebook::Style aResult ( lhs.asUnsignedLong() | rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() | rhs.asExtendedUnsignedLong() ); return aResult;}inline INotebook::Style operator & ( const INotebook::Style &lhs, const INotebook::Style::NegatedStyle &rhs ){ INotebook::Style aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline INotebook::Style::NegatedStyle operator & ( const INotebook::Style::NegatedStyle &lhs, const INotebook::Style::NegatedStyle &rhs ){ INotebook::Style::NegatedStyle aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline INotebook::Style operator & ( const INotebook::Style::NegatedStyle &lhs, const INotebook::Style &rhs ){ return rhs & lhs;}inline unsigned long operator & ( const INotebook::Style &lhs, const INotebook::Style &rhs ){ unsigned long ulResult = lhs.asUnsignedLong() & rhs.asUnsignedLong(); return ( ulResult | (lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong()) );} inline unsigned long operator & ( const INotebook::Style &lhs, const INotebook::Style &rhs );

#pragma pack()
#line 28 "F:\vacpp\INCLUDE\inotebk.inl"
inline void  INotebook::setDefaultStyle ( const INotebook::Style& style )
{
  currentDefaultStyle = style;
}

inline IPageHandle :: operator Value ( ) const
{
  return this->handle;
}
#line 25 "F:\vacpp\INCLUDE\ireslock.hpp"
class IResourceLock;
class IPrivateResource;
class ISharedResource;

#pragma pack(4)

class IResource : public IVBase {
typedef IVBase
  Inherited;
public:

  IResource( );
virtual
 ~IResource( );
#line 41
virtual IResource
 &lock           ( long timeOut = -1 ),
 &unlock         ( );

protected:

virtual ISemaphoreHandle
 &handle        ( )  = 0;

private:

  IResource    ( const IResource& resource );
IResource
 &operator=    ( const IResource& resource );
#line 57
IResourceLock
 *reslockGate;

long
  lClReferenceCount;

friend class IResourceLock;
friend class IPrivateResource;
friend class ISharedResource;
};
#line 69
class IPrivateResource : public IResource
{
typedef IResource
  Inherited;
public:

  IPrivateResource   ( );
virtual
 ~IPrivateResource   ( );

protected:

ISemaphoreHandle
 &handle               ( );

private:

  IPrivateResource    ( const IPrivateResource& privateResource );
IPrivateResource
 &operator=           ( const IPrivateResource& privateResource );
#line 91
ISemaphoreHandle
  resourceHandleCl;

friend class IResourceLock;
};
#line 98
class ISharedResource : public IResource
{
typedef IResource
  Inherited;
public:

  ISharedResource   ( const char* keyName );
virtual
 ~ISharedResource   ( );
#line 109
IString
  keyName           ( ) const;

protected:

ISemaphoreHandle
 &handle              ( );

private:

  ISharedResource    ( const ISharedResource& sharedResource );
ISharedResource
 &operator=          ( const ISharedResource& sharedResource );
#line 124
ISemaphoreHandle
  resourceHandleCl;

IString
  keyNameCl;

friend class IResourceLock;
};
#line 134
class IResourceLock : public IVBase
{
typedef IVBase
  Inherited;
public:
#line 141
  IResourceLock   ( IResource& resource,
                    long       timeOut = -1 );
virtual
  ~IResourceLock  ( );

protected:

virtual IResourceLock
 &setLock        ( long timeOut = -1 ),
 &clearLock      ( );

private:

  IResourceLock ( const IResourceLock& resourceLock );
IResourceLock
 &operator=     ( const IResourceLock& resourceLock );
#line 159
IResource
 *presCl;

friend class IResource;
};

#pragma pack()
#line 20 "F:\vacpp\INCLUDE\itrace.hpp"
#pragma pack(4)

class IString;

class ITrace : public IVBase {
typedef IVBase
  Inherited;

friend class ITraceSetup;

public:

  ITrace                   ( const char* traceName =0,
                             long        lineNumber=0 );

 ~ITrace                   ( );
#line 38
static void
  write                    ( const IString& text ),
  write                    ( const char*    text );

enum Destination           {
  queue,
  standardError,
  standardOutput
  };

static ITrace::Destination
  traceDestination         ( );

static void
  writeToQueue             ( ),
  writeToStandardError     ( ),
  writeToStandardOutput    ( );
#line 57
static void
  enableTrace              ( ),
  disableTrace             ( );

static Boolean
  isTraceEnabled           ( );
#line 65
static void
  enableWriteLineNumber    ( ),
  disableWriteLineNumber   ( ),
  enableWritePrefix        ( ),
  disableWritePrefix       ( );

static Boolean
  isWriteLineNumberEnabled ( ),
  isWritePrefixEnabled     ( );
#line 76
protected:

static unsigned long
  threadId                 ( );
#line 82
static void
  writeString              ( char*          text   ),
  writeFormattedString     ( const IString& string,
                             char*          marker );

private:
#line 90
enum State {
  uninitialized=1,
  on=2,
  writeLineNumber=4,
  writePrefix=8
  };
char
 *pszClTraceName;
static int
  iClState;
static ITrace::Destination
  iClTraceLocation;
static unsigned long
  remainingStack ( );
};
#line 146
#pragma pack()
#line 32 "F:\vacpp\INCLUDE\itrace.inl"
inline void ITrace :: enableWriteLineNumber()
{
  ITrace::iClState |= ITrace::writeLineNumber;
}

inline void ITrace :: disableWriteLineNumber()
{
  ITrace::iClState &= ~ITrace::writeLineNumber;
}
#line 43
inline IBase::Boolean ITrace :: isWriteLineNumberEnabled()
{
  return (ITrace::iClState & ITrace::writeLineNumber);
}
#line 49
inline void ITrace::enableTrace()
{
  ITrace::iClState |= ITrace::on;
}

inline void ITrace::disableTrace()
{
  ITrace::iClState &= ~ITrace::on;
}

inline IBase::Boolean ITrace::isTraceEnabled()
{
  return (ITrace::iClState & ITrace::on);
}

inline void ITrace::writeToQueue()
{
 ITrace::iClTraceLocation = ITrace::queue;
}
#line 70
inline void ITrace::writeToStandardError()
{
   ITrace::iClTraceLocation = ITrace::standardError;
}

inline void ITrace::writeToStandardOutput()
{
   ITrace::iClTraceLocation = ITrace::standardOutput;
}

inline ITrace::Destination ITrace::traceDestination()
{
   return(ITrace::iClTraceLocation);
}

inline void ITrace::enableWritePrefix()
{
  ITrace::iClState |= ITrace::writePrefix;
}

inline void ITrace::disableWritePrefix()
{
  ITrace::iClState &= ~ITrace::writePrefix;
}

inline IBase::Boolean ITrace::isWritePrefixEnabled()
{
  return (ITrace::iClState & ITrace::writePrefix);
}
#line 30 "F:\vacpp\INCLUDE\ireslock.inl"
inline IString ISharedResource :: keyName() const
  { return keyNameCl; }
#line 22 "F:\vacpp\INCLUDE\iobslist.hpp"
class IObserver;
class IObserverDataList;
class INotificationEvent;
class IObserverPtr;
class IObserverListData;

#pragma pack(4)

class IObserverList : public IVBase {
typedef IVBase
  Inherited;

public:
#line 37
  IObserverList     ( );

virtual
 ~IObserverList     ( );

class Cursor : public IVBase {
public:

  Cursor ( IObserverList& observerList );
virtual
 ~Cursor ( );
#line 50
virtual Boolean
  setToFirst      ( ),
  setToNext       ( ),
  setToLast       ( ),
  setToPrevious   ( ),
  isValid         ( ) const;

virtual void
  invalidate      ( );

private:

friend class IObserverList;
void
 *fCursor;
};

friend class IObserverList::Cursor;
#line 70
IObserverList
 ¬ifyObservers ( const INotificationEvent& event );
#line 74
virtual Boolean
  add             ( IObserver&       observer,
                    void*            userData );
virtual IObserver
 &elementAt       ( const Cursor&    cursor ) const;
virtual IObserverList
 &removeAt        ( const Cursor&    cursor ),
 &remove          ( const IObserver& observer ),
 &removeAll       ( );
unsigned long
 numberOfElements ( ) const;

Boolean
 isEmpty          ( ) const;
#line 90
private:

IObserverDataList
  *fObserverDataList;
static IPrivateResource
  gObsKey;
static IPrivateResource
  &observerKey();
unsigned long
  fNumObservers;
IObserverPtr
  *fpObserverArray;
void removeFromObsArray(const IObserver& observer);
void removeFromObsArray(IObserver& observer);
IObserverListData
  *fObserverListData;

IObserverList ( const IObserverList& obsList );
IObserverList
   &operator= (const IObserverList& obsList);
};

#pragma pack()
#line 22 "F:\vacpp\INCLUDE\istdntfy.hpp"
class IObserverList;
class IObserver;
class INotificationEvent;

#pragma pack(4)

class IStandardNotifier : public INotifier {
typedef INotifier
  Inherited;

public:

  IStandardNotifier  ( );
  IStandardNotifier  ( const IStandardNotifier& copy );
IStandardNotifier
 &operator=          ( const IStandardNotifier& aStandardNotifier );

virtual
 ~IStandardNotifier  ( );
#line 43
virtual IStandardNotifier
 &enableNotification       ( Boolean enable = true ),
 &disableNotification      ( );

virtual Boolean
  isEnabledForNotification ( ) const;
#line 51
virtual IStandardNotifier
 ¬ifyObservers          ( const INotificationEvent& anEvent );
#line 55
static INotificationId const
  deleteId;

protected:

virtual IStandardNotifier
 &addObserver           ( IObserver&        observer,
                          const IEventData& userData = IEventData(0) ),
 &removeObserver        ( IObserver&  observer ),
 &removeAllObservers    ( );

virtual IObserverList
 &observerList          ( ) const;
#line 70
virtual IStandardNotifier
  ¬ifyObservers      ( const INotificationId& nId );

private:

IObserverList
  *observers;
Boolean
  enabled;
};

#pragma pack()
#line 35 "F:\vacpp\INCLUDE\ivbnbkpg.hpp"
       #pragma library("CPPOOV3.LIB")
#line 50
#pragma pack(4)
#line 55
class IVBNotebookPage : public IStandardNotifier {
public:
#line 61
  IVBNotebookPage (INotebook * parent,
                   const INotebook::PageSettings::Attribute & attribute,
                   IWindow * pageWindow = 0);
virtual
 ~IVBNotebookPage();

virtual IVBNotebookPage
 &setStatusText   (const char* statusText),
 &setStatusText   (const IResourceId&   resourceId),
 &setTabText      (const char* tabText),
 &setTabText      (const IResourceId& resourceId),
 &setTabBitmap    (const IBitmapHandle& bitmap),
 &setTabBitmap    (const IResourceId& resourceId),
 &setWindow       (IWindow* window = 0);

virtual IString
  statusText      () const,
  tabText         () const;

virtual IBitmapHandle
  tabBitmap       () const;

virtual IWindow
 *window          () const;

virtual const IWindow
 *notebook        () const;

virtual IPageHandle
   pageHandle     () const;

private:
#line 96
INotebook * parentNB;
IPageHandle pgHandle;
};
#line 103
#pragma pack()
#line 20 "F:\vacpp\INCLUDE\itextctl.hpp"
#pragma pack(4)

class IResourceId;
class ISize;
class IString;
class ITextControlData;

class ITextControl : public IControl {
typedef IControl
  Inherited;
public:

virtual
 ~ITextControl           ( );
#line 36
virtual ITextControl
 &setText                ( const char* text ),
 &setText                ( const IResourceId& text );

virtual IString
  text                   ( ) const;

virtual unsigned long
  textLength             ( ) const;
#line 47
static Boolean
  clipboardHasTextFormat ( );
#line 51
virtual ISize
  displaySize            ( const char* text = 0 ) const;
#line 55
virtual ITextControl
 &setLayoutDistorted     ( unsigned long layoutAttributeOn,
                           unsigned long layoutAttributeOff );
#line 60
static INotificationId const
  textId;

protected:
  ITextControl           ( );

private:

  ITextControl           ( const ITextControl& textControl );
ITextControl
 &operator=              ( const ITextControl& textControl );
#line 73
friend class ITextControlNotifyHandler;

Boolean
  fromSetText ( ) const;

ITextControlData
 *fTextControlData;
};

#pragma pack()
#line 21 "F:\vacpp\INCLUDE\ientryfd.hpp"
class IRange;
class ISize;
class IString;
class IResourceId;
class IColor;
class IEntryFieldData;

#pragma pack(4)

class IEntryField : public ITextControl {
typedef ITextControl
  Inherited;

public:
class Style;

  IEntryField  ( unsigned long        id,
                 IWindow*             parent,
                 IWindow*             owner,
                 const IRectangle&    initial = IRectangle(),
                 const Style&         style = defaultStyle() );

  IEntryField  ( unsigned long        id,
                 IWindow*             parent );

  IEntryField  ( const IWindowHandle& handle );

virtual
 ~IEntryField  ( );
#line 52
class Style : public IBitFlag{friend class IEntryField;public: class NegatedStyle : public IBitFlag { friend class Style; public: NegatedStyle ( const IWindow::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline NegatedStyle operator & ( const NegatedStyle &lhs, const NegatedStyle &rhs ); friend inline Style operator & ( const NegatedStyle &lhs, const Style &rhs ); NegatedStyle ( const IControl::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} protected: NegatedStyle ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Style& operator |= ( const Style &aFlag ) { Style tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedStyle operator ~ ( ) const { NegatedStyle aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Style& operator &= ( const NegatedStyle &aFlag ) { Style tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Style ( const IWindow::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline Style operator | ( const Style &lhs, const Style &rhs ); friend inline Style operator & ( const Style &lhs, const NegatedStyle &rhs ); Style ( const IControl::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {}protected: Style ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};

static const Style
  classDefaultStyle,
  autoScroll,
  margin,
  readOnly,
  unreadable,
  leftAlign,
  centerAlign,
  rightAlign;
static const Style
  autoTab,
  command,
  anyData,
  sbcsData,
  dbcsData,
  mixedData;

static Style
  defaultStyle      ( );

static void
  setDefaultStyle   ( const Style&    style );

virtual unsigned long
  convertToGUIStyle ( const IBitFlag& style,
                      Boolean         extendedOnly = false ) const;
#line 82
enum Alignment {
  left,
  center,
  right
};

enum CharType {
  sbcs,
  dbcs,
  any,
  mixed
};
#line 96
Alignment
  alignment          ( ) const;

CharType
  charType           ( ) const;

virtual IEntryField
 &enableCommand      ( Boolean   enable=true ),
 &disableCommand     ( ),
 &enableAutoTab      ( Boolean   enable=true ),
 &disableAutoTab     ( ),

 &setAlignment       ( Alignment alignment ),

 &setCharType        ( CharType  type ),
 &enableAutoScroll   ( Boolean   enable=true ),
 &disableAutoScroll  ( );

virtual IEntryField
 &enableMargin       ( Boolean   enable=true ),
 &disableMargin      ( );

Boolean
  isCommand          ( ) const,
  isAutoTab          ( ) const,
  isAutoScroll       ( ) const,
  isMargin           ( ) const;
#line 125
virtual IEntryField
 &cut        ( unsigned long timestamp=0 ),
 ©       ( unsigned long timestamp=0 ),
 &paste      ( ),
 &clear      ( unsigned long timestamp=0 ),
 &discard    ( ),
 &removeAll  ( );
#line 134
virtual IEntryField
 &disable  ( ),
 &enable   ( Boolean enable=true );
#line 139
virtual IEntryField
 &enableInsertMode   ( Boolean insert=true ),
 &disableInsertMode  ( );

Boolean
  isInsertMode       ( ) const;
#line 147
virtual IEntryField
 &enableDataUpdate   ( Boolean update=true ),
 &disableDataUpdate  ( );

Boolean
  isWriteable        ( ) const;
#line 155
virtual IEntryField
 &setLimit  ( unsigned long      textLimit ),
 &setLimit  ( const IResourceId& textLimit );

unsigned long
  limit     ( ) const;
#line 163
static const long end;

virtual IEntryField
 &selectRange    ( const IRange& range = IRange(0,end),
                   unsigned long timestamp = 0 );

IRange
  selectedRange ( ) const;

IString
  selectedText  ( ) const;

unsigned long
  selectedTextLength ( ) const;

virtual IEntryField
 &setCursorPosition( unsigned long newCursorPos );

unsigned long
  cursorPosition ( ) const;
#line 185
virtual IEntryField
  &setLeftIndex ( unsigned long index );

unsigned long
  leftIndex    ( ) const;
#line 192
Boolean
  hasChanged      ( ) const,
  isEmpty         ( ) const,
  hasSelectedText ( ) const;

virtual IEntryField
  &setChangedFlag ( Boolean changeFlag = true );
#line 201
virtual IColor
  foregroundColor ( ) const,
  backgroundColor ( ) const;
#line 207
static INotificationId const
  insertModeId,
  dataUpdateId,
  limitId,
  characterTypeId;
#line 214
virtual IEntryField
 &enableNotification ( Boolean enable=true );
#line 219
protected:

virtual ISize
  calcMinimumSize ( ) const;
#line 227
virtual IEntryField
 &setStyle ( unsigned long style );
#line 231
  IEntryField ( );
#line 234
private:

  IEntryField  ( const IEntryField& entryField );
IEntryField
 &operator=    ( const IEntryField& entryField );
#line 241
friend class IEntryFieldNotifyHandler;

IRange
  getCursorInfo ( ) const;

void
  setCursorInfo ( const IRange &range );

static Style
  currentDefaultStyle;

enum ReadStatus {
  doesntMatter,
  wasInput,
  wasRead,
  wasInputButReset,
  wasReadButReset
};

ReadStatus
  eReadStatus;

Boolean
  queryInsMode;

IEntryFieldData
 *fEntryFieldData;
#line 271
public:
enum ColorArea {
  foreground,
  background,
  disabledForeground,
  highlightForeground,
  border
};

IEntryField
  &setColor ( ColorArea value, const IColor& color );

IColor
  color     ( ColorArea value ) const;

Boolean
  isReadOnly         ( ) const;

};

inline IEntryField::Style operator | ( const IEntryField::Style &lhs, const IEntryField::Style &rhs ){ IEntryField::Style aResult ( lhs.asUnsignedLong() | rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() | rhs.asExtendedUnsignedLong() ); return aResult;}inline IEntryField::Style operator & ( const IEntryField::Style &lhs, const IEntryField::Style::NegatedStyle &rhs ){ IEntryField::Style aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IEntryField::Style::NegatedStyle operator & ( const IEntryField::Style::NegatedStyle &lhs, const IEntryField::Style::NegatedStyle &rhs ){ IEntryField::Style::NegatedStyle aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IEntryField::Style operator & ( const IEntryField::Style::NegatedStyle &lhs, const IEntryField::Style &rhs ){ return rhs & lhs;}inline unsigned long operator & ( const IEntryField::Style &lhs, const IEntryField::Style &rhs ){ unsigned long ulResult = lhs.asUnsignedLong() & rhs.asUnsignedLong(); return ( ulResult | (lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong()) );} inline unsigned long operator & ( const IEntryField::Style &lhs, const IEntryField::Style &rhs );

#pragma pack()
#line 20 "F:\vacpp\INCLUDE\ibutton.hpp"
class IColor;
class IButtonData;

#pragma pack(4)

class IButton : public ITextControl {
typedef ITextControl
  Inherited;
public:

virtual
 ~IButton ( );
#line 34
class Style : public IBitFlag{friend class IButton;public: class NegatedStyle : public IBitFlag { friend class Style; public: NegatedStyle ( const IWindow::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline NegatedStyle operator & ( const NegatedStyle &lhs, const NegatedStyle &rhs ); friend inline Style operator & ( const NegatedStyle &lhs, const Style &rhs ); NegatedStyle ( const IControl::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} protected: NegatedStyle ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Style& operator |= ( const Style &aFlag ) { Style tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedStyle operator ~ ( ) const { NegatedStyle aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Style& operator &= ( const NegatedStyle &aFlag ) { Style tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Style ( const IWindow::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline Style operator | ( const Style &lhs, const Style &rhs ); friend inline Style operator & ( const Style &lhs, const NegatedStyle &rhs ); Style ( const IControl::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {}protected: Style ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};

static const Style
  noPointerFocus;
#line 40
virtual IButton
 &enableMouseClickFocus  ( Boolean enable = true ),
 &disableMouseClickFocus ( );
Boolean
  allowsMouseClickFocus  ( ) const;
#line 47
Boolean
  isHighlighted ( ) const;

virtual IButton
 &highlight     ( Boolean highlight = true ),
 &unhighlight   ( );
#line 55
virtual IButton
 &click         ( );
#line 59
virtual IColor
  foregroundColor         ( ) const,
  backgroundColor         ( ) const,
  disabledForegroundColor ( ) const,
  hiliteForegroundColor   ( ) const,
  hiliteBackgroundColor   ( ) const;
#line 67
static INotificationId const
  buttonClickId;
#line 71
virtual IButton
  &enableNotification (Boolean enable = true);
#line 75
virtual IButton
 &setText       ( const char* text ),
 &setText       ( const IResourceId& text );

protected:
#line 82
  IButton ( );

private:

  IButton       ( const IButton& );
IButton
 &operator=     ( const IButton& );
#line 91
IButtonData
 *fButtonData;

public:
#line 97
enum ColorArea {
  foreground,
  background,
  disabledForeground,
  highlightForeground,
  border
};
IButton
 &setColor      ( ColorArea value, const IColor& color );
IColor
  color         ( ColorArea value ) const;

};

inline IButton::Style operator | ( const IButton::Style &lhs, const IButton::Style &rhs ){ IButton::Style aResult ( lhs.asUnsignedLong() | rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() | rhs.asExtendedUnsignedLong() ); return aResult;}inline IButton::Style operator & ( const IButton::Style &lhs, const IButton::Style::NegatedStyle &rhs ){ IButton::Style aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IButton::Style::NegatedStyle operator & ( const IButton::Style::NegatedStyle &lhs, const IButton::Style::NegatedStyle &rhs ){ IButton::Style::NegatedStyle aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IButton::Style operator & ( const IButton::Style::NegatedStyle &lhs, const IButton::Style &rhs ){ return rhs & lhs;}inline unsigned long operator & ( const IButton::Style &lhs, const IButton::Style &rhs ){ unsigned long ulResult = lhs.asUnsignedLong() & rhs.asUnsignedLong(); return ( ulResult | (lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong()) );} inline unsigned long operator & ( const IButton::Style &lhs, const IButton::Style &rhs );

#pragma pack()
#line 21 "F:\vacpp\INCLUDE\ipushbut.hpp"
class ISize;
class IWindowHandle;
class IPushButtonData;

#pragma pack(4)

class IPushButton : public IButton  {
typedef IButton
  Inherited;
public:

class Style;
#line 35
  IPushButton ( unsigned long id,
                IWindow* parent,
                IWindow* owner,
                const IRectangle& initial= IRectangle(),
                const Style& style = defaultStyle() );

  IPushButton ( unsigned long id,
                IWindow*      parent );

  IPushButton ( const IWindowHandle& handle );

virtual
 ~IPushButton ( );
#line 54
class Style : public IBitFlag{friend class IPushButton;public: class NegatedStyle : public IBitFlag { friend class Style; public: NegatedStyle ( const IWindow::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline NegatedStyle operator & ( const NegatedStyle &lhs, const NegatedStyle &rhs ); friend inline Style operator & ( const NegatedStyle &lhs, const Style &rhs ); NegatedStyle ( const IControl::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} NegatedStyle ( const IButton::Style::NegatedStyle &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} protected: NegatedStyle ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {} }; Style& operator |= ( const Style &aFlag ) { Style tmpFlag = *this | aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } NegatedStyle operator ~ ( ) const { NegatedStyle aResult ( ~asUnsignedLong(), ~asExtendedUnsignedLong() ); return aResult; } Style& operator &= ( const NegatedStyle &aFlag ) { Style tmpFlag = *this & aFlag; this->setValue ( tmpFlag.asUnsignedLong(), tmpFlag.asExtendedUnsignedLong() ); return *this; } Style ( const IWindow::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} friend inline Style operator | ( const Style &lhs, const Style &rhs ); friend inline Style operator & ( const Style &lhs, const NegatedStyle &rhs ); Style ( const IControl::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {} Style ( const IButton::Style &aFlag ) : IBitFlag ( aFlag.asUnsignedLong(), aFlag.asExtendedUnsignedLong() ) {}protected: Style ( unsigned long val, unsigned long extVal=0 ) : IBitFlag ( val, extVal ) {}};

static const Style
  classDefaultStyle,
  help,
  systemCommand,
  defaultButton,
  noBorder;

static Style
  defaultStyle      ( );

static void
  setDefaultStyle   ( const Style&    style );

virtual unsigned long
  convertToGUIStyle ( const IBitFlag& style,
                      Boolean         extendedOnly = false ) const;
#line 74
Boolean
  isDefault            ( ) const,
  isHelp               ( ) const,
  isSystemCommand      ( ) const,
  hasBorder            ( ) const;

virtual IPushButton
 &enableDefault        ( Boolean enable = true ),
 &disableDefault       ( ),
 &enableHelp           ( Boolean enable = true ),
 &disableHelp          ( ),
 &enableSystemCommand  ( Boolean enable = true ),
 &disableSystemCommand ( ),
 &addBorder            ( Boolean add    = true ),
 &removeBorder         ( );

protected:
#line 95
virtual ISize
  calcMinimumSize      ( ) const;
#line 100
private:

static Style
  currentDefaultStyle;

IPushButtonData
 *fPushButtonData;
#line 110
  IPushButton          ( const IPushButton& );
IPushButton
 &operator=            ( const IPushButton& );
#line 116
public:

virtual IPushButton
 &enableBorder         ( Boolean add=true ),
 &disableBorder        ( );
Boolean
  isBorder             ( ) const;
#line 125
};

inline IPushButton::Style operator | ( const IPushButton::Style &lhs, const IPushButton::Style &rhs ){ IPushButton::Style aResult ( lhs.asUnsignedLong() | rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() | rhs.asExtendedUnsignedLong() ); return aResult;}inline IPushButton::Style operator & ( const IPushButton::Style &lhs, const IPushButton::Style::NegatedStyle &rhs ){ IPushButton::Style aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IPushButton::Style::NegatedStyle operator & ( const IPushButton::Style::NegatedStyle &lhs, const IPushButton::Style::NegatedStyle &rhs ){ IPushButton::Style::NegatedStyle aResult ( lhs.asUnsignedLong() & rhs.asUnsignedLong(), lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong() ); return aResult;}inline IPushButton::Style operator & ( const IPushButton::Style::NegatedStyle &lhs, const IPushButton::Style &rhs ){ return rhs & lhs;}inline unsigned long operator & ( const IPushButton::Style &lhs, const IPushButton::Style &rhs ){ unsigned long ulResult = lhs.asUnsignedLong() & rhs.asUnsignedLong(); return ( ulResult | (lhs.asExtendedUnsignedLong() & rhs.asExtendedUnsignedLong()) );} inline unsigned long operator & ( const IPushButton::Style &lhs, const IPushButton::Style &rhs );

#pragma pack()
#line 14 "PgHndler.hpp"
class APageHandler;
#line 26
#pragma pack(4)
#line 31
class APageHandler : public IStandardNotifier {
public:
#line 36
   APageHandler();

   virtual  ~APageHandler();
#line 43
   virtual APageHandler & initializePart();
#line 48
   static const INotificationId readyId;

protected:
#line 54
   Boolean makeConnections();

private:
#line 3 "PgHndler.hpv"
public:
  virtual int previousPageNumber() const;
  virtual APageHandler& setPreviousPageNumber(int aPreviousPageNumber);
  virtual int currentPageNumber() const;
  virtual APageHandler& setCurrentPageNumber(int aCurrentPageNumber);
  APageHandler& handleFor(INotebook* notebk);
  APageHandler& stopHandleFor(INotebook* notebk);

  static INotificationId previousPageNumberId;
  static INotificationId currentPageNumberId;
  static INotificationId selectedPage1Id;
  static INotificationId selectedPage2Id;
  static INotificationId selectedPage3Id;

private:
  int iPreviousPageNumber;
  int iCurrentPageNumber;
#line 34
protected:
#line 37
   class PageHandler : public IPageHandler  {
     public:
       void setOuterPgHandler(APageHandler * nvPageHdler) {
        outerPgHandler = nvPageHdler;
        }
     protected:
       virtual Boolean select( IPageSelectEvent & event);
     private:
       APageHandler* outerPgHandler;
   };

private:
  PageHandler nbPageHandler;
#line 59 "PgHndler.hpp"
};
#line 65
#pragma pack()
#line 23 "F:\vacpp\INCLUDE\inotifev.hpp"
class INotificationEventData;

#pragma pack(4)

class INotificationEvent : public IBase {
typedef IBase
  Inherited;
public:
#line 33
  INotificationEvent  ( const INotificationId&   identifier,
                        INotifier&               notifier,
                        Boolean                  notifierAttrChanged=true,
                        const IEventData&        eventData=IEventData(),
                        const IEventData&        observerData=IEventData() );

  INotificationEvent  ( const INotificationEvent& event );

INotificationEvent
 &operator=           ( const INotificationEvent& event );

 ~INotificationEvent ( );
#line 47
INotificationEvent
 &setNotifierAttrChanged  ( Boolean           notifierAttrchanged=true ),
 &setEventData            ( const IEventData& eventData ),
 &setObserverData         ( const IEventData& observerData );

INotificationId
  notificationId          ( ) const;
INotifier
 ¬ifier                ( ) const;
Boolean
  hasNotifierAttrChanged  ( ) const;
IEventData
  eventData               ( ) const,
  observerData            ( ) const;

private:

INotificationId
  fEvtId;
INotifier
 *fEvtNotifier;
Boolean
 fAttrChanged;
IEventData
 fEvtData,
 fObsData;
INotificationEventData
 *fExtendedNotificationData;
};

#pragma pack()
#line 28 "F:\vacpp\INCLUDE\inotifev.inl"
inline INotificationEvent& INotificationEvent::setEventData( const IEventData& eventData )
{
  this->fEvtData = eventData;
  return *this;
}

inline INotificationEvent& INotificationEvent::setObserverData( const IEventData& observerData)
{
  this->fObsData = observerData;
  return *this;
}

inline INotificationEvent& INotificationEvent::setNotifierAttrChanged(
                                                       Boolean changed)
{
  this->fAttrChanged = changed;
  return *this;
}
#line 48
inline INotificationId INotificationEvent::notificationId ( ) const
{
  return this->fEvtId;
}

inline INotifier& INotificationEvent::notifier ( ) const
{
  return *(this->fEvtNotifier);
}

inline IEventData INotificationEvent::eventData( ) const
{
  return this->fEvtData;
}

inline IEventData INotificationEvent::observerData( ) const
{
  return this->fObsData;
}

inline IBase::Boolean INotificationEvent::hasNotifierAttrChanged( ) const
{
  return this->fAttrChanged;
}
#line 21 "F:\vacpp\INCLUDE\iobservr.hpp"
#pragma pack(4)

class INotificationEvent;
class INotifier;
class IObserverData;

class IObserver : public IVBase {
typedef IVBase
  Inherited;
public:

virtual
 ~IObserver ( );
#line 36
virtual IObserver
 &handleNotificationsFor       ( INotifier&        notifier,
                                 const IEventData& userData = IEventData() ),
 &stopHandlingNotificationsFor ( INotifier&        notifier );
#line 42
protected:

virtual IObserver
 &dispatchNotificationEvent  ( const INotificationEvent& event )=0;
#line 48
  IObserver ( );

private:

friend class INotifier;
friend class IObserverList;

IObserverData
 *fObserverData;
};

#pragma pack()
#line 14 "test.hpp"
class test;
#line 20
class ICanvas;
class INotebook;
class IVBNotebookPage;
class IEntryField;
class IPushButton;
class APageHandler;
#line 34
class testConn0;
class testConn2;
class testConn4;
class testConn5;
class testConn7;
#line 45
#pragma pack(4)
#line 50
class test : public IFrameWindow {
public:
#line 55
   test(
      unsigned long id = 15000,
      IWindow* parent = IWindow::desktopWindow(),
      IWindow* owner = 0,
      const IRectangle& rect = defaultFramingSpec(),
      const IFrameWindow::Style& style = IFrameWindow::defaultStyle ( ),
      const char* title = defaultTitle());

   virtual  ~test();
#line 68
   static const IRectangle defaultFramingSpec();
   static IString defaultTitle();
   virtual test & initializePart();
   test * getFrameWindow() { return this; };
#line 76
   static const INotificationId readyId;

protected:
#line 82
   Boolean makeConnections();

private:
#line 88
   ICanvas * iCanvas;
   INotebook * iNotebook1;
   IVBNotebookPage * iVBNotebookPage;
   ICanvas * iCanvas1;
   IVBNotebookPage * iVBNotebookPage1;
   ICanvas * iCanvas2;
   IVBNotebookPage * iVBNotebookPage2;
   ICanvas * iCanvas3;
   IEntryField * iEntryField1;
   IPushButton * iPushButton1;
   IPushButton * iPushButton2;
   IEntryField * iEntryField2;
   APageHandler * iAPageHandler1;
   testConn0 * conn0;
   testConn2 * conn2;
   testConn4 * conn4;
   testConn5 * conn5;
   testConn7 * conn7;
   static unsigned long partWindowId;
#line 109
};
#line 115
#pragma pack()
#line 75 "test.cpp"
class testConn0 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn0(){};
#line 82
   void initialize(IPushButton * aSource, APageHandler * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn0 & setNotebk(INotebook * aSelf) {iNotebk = aSelf; return *this;};

protected:
#line 90
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == IPushButton::buttonClickId)
         {
         ;
         ;
         try {target->handleFor(iNotebk);}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
#line 106
   IPushButton * source;
   APageHandler * target;
   INotebook * iNotebk;
#line 111
};
#line 117
class testConn2 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn2(){};
#line 124
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn2 & setNewValue(APageHandler * aSelf) {iNewValue = aSelf; return *this;};

protected:
#line 132
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == APageHandler::selectedPage1Id)
         {
         ;
         ;
         try {target->setText(IString(iNewValue->currentPageNumber()));}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
#line 148
   APageHandler * source;
   IEntryField * target;
   APageHandler * iNewValue;
#line 153
};
#line 159
class testConn4 : public IObserver {
public:
   virtual  ~testConn4(){};
#line 166
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; aligning = false; };
   void setSource()
      {
      if (aligning==false) {
         ;
         ;
         ;
         aligning = true;
         try {source->setPreviousPageNumber(target->text().asInt());}
         catch (IException& exc) {};
         aligning = false;
         }
      };
   void setTarget()
      {
      if (aligning==false) {
         ;
         ;
         ;
         aligning = true;
         try {target->setText(IString(source->previousPageNumber()));}
         catch (IException& exc) {};
         aligning = false;
         }
      };

protected:
#line 197
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == 0) setTarget();
      if ((anEvent.notificationId() == APageHandler::previousPageNumberId) && (source == &anEvent.notifier()))
         setTarget();
      else
      if ((anEvent.notificationId() == IEntryField::textId) && (target == &anEvent.notifier()))
         setSource();
      return(*this);
      };

private:
#line 212
   APageHandler * source;
   IEntryField * target;
   Boolean aligning;
#line 217
};
#line 223
class testConn5 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn5(){};
#line 230
   void initialize(APageHandler * aSource, IEntryField * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn5 & setNewValue(APageHandler * aSelf) {iNewValue = aSelf; return *this;};

protected:
#line 238
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == APageHandler::selectedPage2Id)
         {
         ;
         ;
         try {target->setText(IString(iNewValue->currentPageNumber()));}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
#line 254
   APageHandler * source;
   IEntryField * target;
   APageHandler * iNewValue;
#line 259
};
#line 265
class testConn7 : public IObserver, public IStandardNotifier {
public:
   virtual  ~testConn7(){};
#line 272
   void initialize(IPushButton * aSource, APageHandler * aTarget)
      {source = aSource; target = aTarget; enableNotification(); };
   testConn7 & setNotebk(INotebook * aSelf) {iNotebk = aSelf; return *this;};

protected:
#line 280
   virtual IObserver & dispatchNotificationEvent(const INotificationEvent & anEvent)
      {
      if (anEvent.notificationId() == IPushButton::buttonClickId)
         {
         ;
         ;
         try {target->stopHandleFor(iNotebk);}
         catch (IException& exc) {};
         }
      return(*this);
      };

private:
#line 296
   IPushButton * source;
   APageHandler * target;
   INotebook * iNotebk;
#line 301
};
#line 304
#pragma export (test::readyId)
const INotificationId test::readyId = "test::readyId";

#pragma export (test::partWindowId)
unsigned long test::partWindowId = 0;
#line 313
#pragma export (test::defaultFramingSpec())
const IRectangle test::defaultFramingSpec()
{
   return(IRectangle(IPoint(30, IWindow::desktopWindow()->size().height() - 30 - 384),ISize(512, 384)));
}
#line 323
#pragma export (test::defaultTitle())
IString test::defaultTitle()
{
   return("FrameWindow");
}
#line 333
#pragma export (test::test(unsigned long, IWindow*, IWindow*, const IRectangle&, const IFrameWindow::Style&, const char*))
test::test(
      unsigned long id,
      IWindow* parent,
      IWindow* owner,
      const IRectangle& rect,
      const IFrameWindow::Style& style,
      const char* title)
   : IFrameWindow((partWindowId) ? partWindowId : id, parent, owner, rect, style, title)
{
   partWindowId = (partWindowId) ? partWindowId : id;
   iCanvas = new ICanvas(
      (0x8008),
      this,
      this,
      IRectangle());
   iNotebook1 = new INotebook(
      partWindowId+1,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(18,104),ISize(438, 220)));
   iCanvas1 = new ICanvas(
      partWindowId+2,
      iNotebook1,
      iNotebook1,
      IRectangle());
   iVBNotebookPage = new IVBNotebookPage(iNotebook1, INotebook::PageSettings::majorTab | INotebook::PageSettings::autoPageSize, iCanvas1);
   iCanvas2 = new ICanvas(
      partWindowId+3,
      iNotebook1,
      iNotebook1,
      IRectangle());
   iVBNotebookPage1 = new IVBNotebookPage(iNotebook1, INotebook::PageSettings::majorTab | INotebook::PageSettings::autoPageSize, iCanvas2);
   iCanvas3 = new ICanvas(
      partWindowId+4,
      iNotebook1,
      iNotebook1,
      IRectangle());
   iVBNotebookPage2 = new IVBNotebookPage(iNotebook1, INotebook::PageSettings::majorTab | INotebook::PageSettings::autoPageSize, iCanvas3);
   iEntryField1 = new IEntryField(
      partWindowId+5,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(42,71),ISize(161, 26)));
   iPushButton1 = new IPushButton(
      partWindowId+6,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(97,19),ISize(124, 34)));
   iPushButton2 = new IPushButton(
      partWindowId+7,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(271,15),ISize(121, 34)));
   iEntryField2 = new IEntryField(
      partWindowId+8,
      iCanvas,
      iCanvas,
      IRectangle(IPoint(328,70),ISize(148, 27)));
   iAPageHandler1 = new APageHandler();

   conn0 = new testConn0();
   conn2 = new testConn2();
   conn4 = new testConn4();
   conn5 = new testConn5();
   conn7 = new testConn7();

   this->setFocus();
   this->setClient(iCanvas);
   iVBNotebookPage->setTabText("Tab1");
   iCanvas1->setMinimumSize(ISize(100, 100));
   iVBNotebookPage1->setTabText("Tab2");
   iCanvas2->setMinimumSize(ISize(100, 100));
   iVBNotebookPage2->setTabText("Tab3");
   iCanvas3->setMinimumSize(ISize(100, 100));
   iPushButton1->setText("start handle");
   iPushButton2->setText("stop handle");
}
#line 416
#pragma export (test::~test())
test::~test()
{
   conn0->stopHandlingNotificationsFor(*iPushButton1);
   conn2->stopHandlingNotificationsFor(*iAPageHandler1);
   conn4->stopHandlingNotificationsFor(*iAPageHandler1);
   conn4->stopHandlingNotificationsFor(*iEntryField2);
   conn5->stopHandlingNotificationsFor(*iAPageHandler1);
   conn7->stopHandlingNotificationsFor(*iPushButton2);

   delete conn0;
   delete conn2;
   delete conn4;
   delete conn5;
   delete conn7;
#line 433
   delete iCanvas;
   delete iNotebook1;
   delete iVBNotebookPage;
   delete iCanvas1;
   delete iVBNotebookPage1;
   delete iCanvas2;
   delete iVBNotebookPage2;
   delete iCanvas3;
   delete iEntryField1;
   delete iPushButton1;
   delete iPushButton2;
   delete iEntryField2;
   delete iAPageHandler1;
}
#line 451
#pragma export (test::initializePart())
test & test::initializePart()
{
   makeConnections();
   notifyObservers(INotificationEvent(readyId, *this));
   return *this;
}
#line 463
#pragma export (test::makeConnections())
Boolean test::makeConnections()
{
   this->enableNotification();
   iCanvas->enableNotification();
   iNotebook1->enableNotification();
   iVBNotebookPage->enableNotification();
   iCanvas1->enableNotification();
   iVBNotebookPage1->enableNotification();
   iCanvas2->enableNotification();
   iVBNotebookPage2->enableNotification();
   iCanvas3->enableNotification();
   iEntryField1->enableNotification();
   iPushButton1->enableNotification();
   iPushButton2->enableNotification();
   iEntryField2->enableNotification();
   iAPageHandler1->enableNotification();

   conn0->initialize(iPushButton1, iAPageHandler1);
   conn0->handleNotificationsFor(*iPushButton1);
   conn0->setNotebk(iNotebook1);
   conn2->initialize(iAPageHandler1, iEntryField1);
   conn2->handleNotificationsFor(*iAPageHandler1);
   conn2->setNewValue(iAPageHandler1);
   conn4->initialize(iAPageHandler1, iEntryField2);
   conn4->handleNotificationsFor(*iAPageHandler1);
   conn4->handleNotificationsFor(*iEntryField2);
   conn5->initialize(iAPageHandler1, iEntryField1);
   conn5->handleNotificationsFor(*iAPageHandler1);
   conn5->setNewValue(iAPageHandler1);
   conn7->initialize(iPushButton2, iAPageHandler1);
   conn7->handleNotificationsFor(*iPushButton2);
   conn7->setNotebk(iNotebook1);

   conn4->setTarget();
   return true;
}
Ç
.\test.cppê¼TIS
êǃCPPOM30I.LIBêǃOS2386.LIBê»DEMANGLêǃCPPOOC3I.LIBêǃCPPOOV3I.LIBêÇáreadyId__4testêÇá__vft4test6IVBaseê/*******************************************************************************
* FILE NAME: test.rcx                                                          *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Main resource file for application class:                                  *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
/*******************************************************************************
* FILE NAME: test.rci                                                          *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Resource include file for class:                                           *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/

/*******************************************************************************
* FILE NAME: test.h                                                            *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Constant declarations for class:                                           *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
/*******************************************************************************
* FILE NAME: icconst.h                                                         *
*                                                                              *
* DESCRIPTION:                                                                 *
*   User Interface resource identifier macro constants.                        *
*                                                                              *
* COPYRIGHT:                                                                   *
*   IBM Open Class Library                                                     *
*   (C) Copyright International Business Machines Corporation 1992, 1995       *
*   Licensed Material - Program-Property of IBM - All Rights Reserved.         *
*   US Government Users Restricted Rights - Use, duplication, or disclosure    *
*   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
*                                                                              *
*******************************************************************************/
/*******************************************************************************
* FILE NAME: icconsta.h                                                        *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Application Support resource identifier macro constants                    *
*                                                                              *
* COPYRIGHT:                                                                   *
*   IBM Open Class Library                                                     *
*   (C) Copyright International Business Machines Corporation 1992, 1995       *
*   Licensed Material - Program-Property of IBM - All Rights Reserved.         *
*   US Government Users Restricted Rights - Use, duplication, or disclosure    *
*   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
*                                                                              *
*******************************************************************************/



// Identifiers for class library errors.














// The following identifiers are used for exception handling in the GBM
// image handling code.



// Window identifiers for frames and standard frame components.

// The IC_ID_BASE constant is defined both here and in ibase.hpp.
// It is defined here to allow its use in resource files or other
// places where a C++ header cannot be used.

// The following identifiers are defined and may be used when constructing
// IToolBarButtons for standard operations.

// The following identifiers are defined and used by the class libary
// when constructing special IToolBarButtons.


// Window identifiers for the child windows of an IViewPort.



/*******************************************************************************
* FILE NAME: ivbdefs.h                                                         *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Declaration of the defines and macros for the Visual Builder.              *
*                                                                              *
* COPYRIGHT:                                                                   *
*   IBM(R) VisualAge(TM) C++ for OS/2(R), Version 3                            *
*   (C) Copyright IBM Corporation 1991, 1995.                                  *
*    - Licensed Material - Program-Property of IBM - All Rights Reserved.      *
*   US Government Users Restricted Rights - Use, duplication, or disclosure    *
*   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
*******************************************************************************/








































#include <os2.h>


HELPTABLE 15000
   BEGIN
      HELPITEM  15000,  15000,  0
   END

STRINGTABLE
   BEGIN
      1,  "Visual Builder 3.0"
   END


/*******************************************************************************
* FILE NAME: PgHndler.rci                                                      *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Resource include file for class:                                           *
*     APageHandler- Notebook page handler                                      *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/

/*******************************************************************************
* FILE NAME: PgHndler.h                                                        *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Constant declarations for class:                                           *
*     APageHandler- Notebook page handler                                      *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/





#include <os2.h>








HELPSUBTABLE (15000)
   BEGIN
   END




/*******************************************************************************
* FILE NAME: test.rci                                                          *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Resource include file for class:                                           *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef vbinclude
#define vbinclude  #include
#endif

#include "test.h"

vbinclude <os2.h>

#ifndef MAIN_RESOURCES_INCLUDED
#define MAIN_RESOURCES_INCLUDED

HELPTABLE WND_test
   BEGIN
      HELPITEM  WND_test_FrameWindow,  WND_test_FrameWindow,  0
   END

#define test_WINDOWRESOURCES
#define test_NONWINDOWRESOURCES
STRINGTABLE
   BEGIN
      1,  "Visual Builder 3.0"
   END

#endif

#ifdef test_NONWINDOWRESOURCES
#ifndef test_NONWINDOWRESOURCES_INCLUDED
#define test_NONWINDOWRESOURCES_INCLUDED
#ifndef APageHandler_NONWINDOWRESOURCES_INCLUDED
#define APageHandler_NONWINDOWRESOURCES
#include "PgHndler.rci"
#undef APageHandler_NONWINDOWRESOURCES
#endif

#endif
#endif

#ifdef test_WINDOWRESOURCES
#define test_WINDOWRESOURCES_INCLUDING
HELPSUBTABLE (WND_test_FrameWindow)
   BEGIN
   END

#undef test_WINDOWRESOURCES_INCLUDING
#endif

#ifdef test_HELPITEMRESOURCES
      HELPITEM  WND_test_FrameWindow,  WND_test_FrameWindow,  0
#endif

#ifdef test_HELPSUBITEMRESOURCES
#endif

/*******************************************************************************
* FILE NAME: test.rcx                                                          *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Main resource file for application class:                                  *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#include "test.rci"
  ÿ:0
ÿ:ÿ:    ÿ:0  
04╡

Visual Builder 3.0













<áP0



AvlFileHeaderfileType version êbinary
┌│
%JÇΘ
<áP
╚

*

/*******************************************************************************
* FILE NAME: vbmain.cpp                                                        *
*                                                                              *
* DESCRIPTION:                                                                 *
*   Main program stub for class:                                               *
*     test                                                                     *
* ---------------------------------------------------------------------------- *
* Warning: This file was generated by the VisualAge C++ Visual Builder.        *
* Modifications to this source file will be lost when the part is regenerated. *
*******************************************************************************/
#ifndef _IWINDOW_
#include <iwindow.hpp>
#endif

#ifndef _IAPP_
#include <iapp.hpp>
#endif

#ifndef _IMSGBOX_
#include <imsgbox.hpp>
#endif

#ifndef _TEST_
#include "test.hpp"
#endif


//------------------------------------------------------------------------------
// main
//------------------------------------------------------------------------------
int main(int argc, char ** argv)
{
   IApplication::current().setArgs(argc, argv);

   test *iPart;
   IMessageBox::Response resp = IMessageBox::unknown;

   do {
      try {
         iPart = new test();
         iPart->initializePart();
         }
      catch (IException& exc) {
         resp = IMessageBox(IWindow::desktopWindow()).show(exc);
         }
      }
   while (resp == IMessageBox::retry);

   if (resp == IMessageBox::cancel) IApplication::current().exit();

   iPart->setAutoDeleteObject();
   iPart->show();
   IApplication::current().run();
   return 0;
}   //end main

Ç.\vbmain.cppê¼TIS
êǃCPPOM30I.LIBêǃOS2386.LIBê»DEMANGLêǃCPPOOC3I.LIBêÇíHLêÇ¡LNKOH410ê(ǽ
x
ûûCODECONSTBSSDATADGROUPFLATDEBTYPDEBSYMCODE32
CONST32_ROBSS32DATA32$$TYPES    $$SYMBOLS
CTOR_DTOR1
CTOR_DTOR2
CTOR_DTOR3EH_DATA_VFTEH_CODEÖ    ⌐┬    
Ö    ⌐
Ö    ⌐Ö    ⌐Ö    ⌐╨
Ö    ⌐3Ö    ⌐Ö    ⌐Ö    ⌐Ö    ⌐XÖ    )Ö    ⌐9
ÜÜ  æ
mainé
¥PE


îñ
    __dl__FPväτ_Exception_CPPîr__dt__7IStringFvcurrent__12IApplicationFv    _exeentry    __nw__FUiîqdesktopWindow__7IWindowFvdefaultFramingSpec__4testFvdefaultStyle__12IFrameWindowFvdefaultTitle__4testFvC__ct__4testFUlP7IWindowT2RC10IRectangleRCQ2_12IFrameWindow5StylePCc__CatchMatchîv__ct__11IMessageBoxFP7IWindow__dt__11IMessageBoxFv__CleanupCatchîw    __ReThrowîwsetAutoDeleteObject__7IWindowFi_fltusedÇéêó
í▀z
âñTâéâTâùâz
â@
__vftyp
ââFï__faddrFéï__tdispz
â]âééBoolean{âäâêê
éBooleanConstantséfalseèétrueè
TâñâT

âùâTâùâ@    IMessageText
âââââââââE
IMessageText__FUlPCcN92&E
IMessageText__FRC12IMessageTextE~IMessageText__FvE__opPCc__FvEtext__FvEsetDefaultText__FPCcE__as__FRC12IMessageTextFñïpClTextFéï
bClSuccessHT

âùâTâñâHT

ââT

ââT

ââ@ostreamH!@
$IBase)
â%â&â'â(â)â*â+â,â-â.â/â0â1C    #C
#E
messageFile__FvE
setMessageFile__FPCcE
 messageText__FUlPCcN82B3__ls__FR7ostreamRC5IBaseEasString__FvEbasDebugInfo__FvC#E
version__Fv+F

⌠ïunrecoverable__5IBaseunrecoverable'F

⌠ïrecoverable__5IBaserecoverableí∞┘F
ñïmsgFile__5IBasemsgFileH#Tâ"â@
5IStringM
â6â7â8â9â:â;â<â=â>â?â@âAâBâCâDâEâFâGâHâIâJâKâLâMâNâOâPâQâRâSâTâUâVâWâXâYâZâ[â\â]â^â_â`âaâbâcâdâeâfâgâhâiâjâkâlâmânâoâpâqârâsâtâuâvâwâxâyâzâ{â|â}â~ââÇâüâéâââäâàâåâçâêâëâèâïâîâìâÄâÅâÉâæâÆâôâöâòâûâùâÿâÖâÜâ¢â£â¥â₧âƒâáâíâóâúâñâÑâªâºâ¿â⌐â¬â½â¼â¡â«â»â░â▒â▓â│â┤â╡â╢â╖â╕â╣â║â╗â╝â╜â╛â┐â└â┴â┬â├â─â┼â╞â╟â╚â╔â╩â╦â╠â═â╬â╧â╨â╤â╥â╙â╘â╒â╓â╫â╪â┘â┌â█â▄â▌â▐â▀âαâßâΓâπâΣâσâµâτâΦâΘâΩâδâ∞âφâεâ∩â≡â±â≥â≤â⌠â⌡â÷â≈â°â∙â·â√âⁿâ²â■â ââ
ââââââââ    â
ââââââââââââââââ