| Cocf::TOcConvertInfo::[struct].__unnamed0__.Clsid | |
| Cocf::TOcConvertInfo::[struct].__unnamed0__.Format | |
| Cocf::TOcInitInfo::[struct].__unnamed0__.Handle | |
| Cocf::TOcConvertInfo::[struct].__unnamed0__.SwitchToIcon | |
| Cocf::TAutoSymbol::[union].__unnamed0__ | |
| Cocf::TOcConvertInfo::[union].__unnamed0__ | |
| Cocf::TOcInitInfo::[union].__unnamed0__ | |
| Cowl::TFunctorBase::[union].__unnamed0__ | |
| Cowl::TLayoutConstraint::[union].__unnamed0__ | This union is included for the convenience of naming the layout constraints |
| Cowl::TResponseTableEntry::[union].__unnamed0__ | |
| Cocf::TAutoSymbol::[union].__unnamed1__ | |
| C_IMAGEINFO | |
| Cowl::TImageInfo | TImageInfo is a wrapper class for a structure that describes an image within an image list |
| CA | |
| Cowl::TMBaseMemBlocks< A > | Used internally |
| CCHARFORMAT2 | |
| Cowl::TCharFormat | TCharFormat encapsulates the CHARFORMAT2 structure which contains information about character formatting in a rich edit control |
| CCHARRANGE | |
| Cowl::TCharRange | TCharRange encapsulates the CHARRANGE structure, which specifies a range of characters in a rich edit control |
| CCOLORSCHEME | |
| Cowl::TColorScheme | |
| CCOMBOBOXEXITEM | |
| Cowl::TCBExItemInfo | |
| Cowl::DLGTEMPLATEEX | |
| CEDITSTREAM | |
| Cowl::TEditStream | TEditStream encapsulates the EDITSTREAM structure, which contains information about a data stream used with a rich edit control |
| CENDROPFILES | |
| Cowl::TEnDropFiles | Structure sent with EN_DROPFILES notification |
| CENPROTECTED | |
| Cowl::TEnProtected | Structure sent with EN_PROTECTED notification |
| Cstd::exception | STL class |
| Cowl::TDiagException | |
| Cowl::TCheckFailure | |
| Cowl::TPreconditionFailure | |
| Cowl::TXBase | Derived from xmsg, TXBase is the base class for ObjectWindows and ObjectComponents exception-handling classes |
| Cocf::TXAuto | Automation exception object |
| Cocf::TXOle | OLE API related exception object |
| Cocf::TXObjComp | Base OC exception class |
| Cowl::TMRSWSection::TXLockFailure | |
| Cowl::TThread::TThreadError | The error class that defines the objects that are thrown when an error occurs |
| Cowl::TXOwl | TXOwl is root class of the ObjectWindows exception hierarchy |
| Cowl::TTransferBufferWindowBase::TXFieldConflict | Thrown if a more than one control tries to associate with the same field |
| Cowl::TTransferBufferWindowBase::TXMeddlingValidator | Thrown if a validator attempts to meddle with the transfer |
| Cowl::TTransferBufferWindowBase::TXPolygamousControl | Thrown if a a control tries to associate with more than one field |
| Cowl::TTransferBufferWindowBase::TXUnboundControl | Thrown if a transfer is attempted with an unbound control |
| Cowl::TXBadFormat | Used for throwing exceptions when a bad file format is encountered |
| Cowl::TXClipboard | TXClipboard creates the TXClipboard exception with a string resource |
| Cowl::TXCommCtrl | Exception object thrown by the Common Control wrappers of ObjectWindows |
| Cowl::TXGdi | Describes an exception resulting from GDI failures such as creating too many TWindow device contexts (DCs) |
| Cowl::TXInvalidMainWindow | A nested class, TXInvalidMainWindow describes an exception that results from an invalid Window |
| Cowl::TXInvalidModule | A nested class, TXInvalidModule describes an exception that results from an invalid module |
| Cowl::TXMenu | A nested class, TXMenu describes an exception that occurs when a menu item cannot be constructed |
| Cowl::TXModuleVersionInfo | Exception class for TModuleVersionInfo. [VH 2005-04-03] |
| Cowl::TXNotSupportedCall | |
| Cowl::TXOutOfMemory | Describes an exception that results from running out of memory |
| Cowl::TXPrinter | TXPrinter describes an exception that results from an invalid printer object |
| Cowl::TXPrinting | TXPrinting describes an exception that indicates that printing failed |
| Cowl::TXRegistry | Thrown for errors within the Registry classes |
| Cowl::TXShell | Base Shell exception class. Handles all TShellItem and related class exceptions |
| Cowl::TXTheme | |
| Cowl::TXValidator | A nested class, TXValidator describes an exception that results from an invalid validator object |
| Cowl::TXWindow | A nested class, TXWindow describes an exception that results from trying to create an invalid window |
| CFILETIME | |
| Cowl::TFileTime | TFileTime is a class derived from the structure FILETIME |
| CFINDTEXT | |
| Cowl::TFindText | TFindText encapsulates the FINDTEXT structure, which contains information about text to search for in a rich edit control |
| CFORMATRANGE | |
| Cowl::TFormatRange | TFormatRange encapsulates the FORMATRANGE structure, which contains information that a rich edit control uses to format its output for a particular device |
| CHD_HITTESTINFO | |
| Cowl::THeaderHitTestInfo | THeaderHitTestInfo contains hittest information for the header control |
| CHD_ITEM | |
| Cowl::THdrItem | THdrItem contains information about an item in a header control |
| CHD_NOTIFY | |
| Cowl::THdrNotify | THdrNotify encapsulates the 'HD_NOTIFY' structure which is sent with the WM_NOTIFY messages sent by the HeaderControl to its parent |
| CHH_AKLINK | |
| Cowl::THlpAklink | |
| CHH_ENUM_IT | |
| Cowl::THlpEnumIt | |
| CHH_FTS_QUERY | |
| Cowl::THlpFtsQuery | |
| CHH_POPUP | |
| Cowl::THlpPopup | |
| CHH_SET_INFOTYPE | |
| Cowl::THlpSetInfoType | |
| CHH_WINTYPE | |
| Cowl::THlpWinType | |
| CHHN_NOTIFY | |
| Cowl::THlpNotify | |
| CHHNTRACK | |
| Cowl::THlpTrack | |
| Chostent | |
| Cowl::THostEntry | THostEntry encapsulates the attributes of a host (hostent) |
| CIClassFactory | |
| Cocf::IBClass | IBClass – Supported by BOleFactory |
| CIClassFactory2 | |
| Cocf::TAppDescriptor | |
| CIEnumVARIANT | |
| Cocf::TAutoIterator | Automation collection iterator |
| Cowl::TDib::IFileIn | Internal DIB file Reda/Write functions talk to these interfaces |
| Cowl::TDib::IFileOut | |
| CIMAGELISTDRAWPARAMS | |
| Cowl::TImageListDrawParam | |
| Cstd::ios_base | STL class |
| Cstd::basic_ios< Char > | STL class |
| Cstd::basic_istream< Char > | STL class |
| Cstd::basic_iostream< Char > | STL class |
| Cstd::basic_fstream< Char > | STL class |
| Cstd::fstream | STL class |
| Cowl::TStreamFile | |
| Cstd::istream | STL class |
| Cowl::TInStream | Derived from TStream and istream, TInStream is a base class used to define input streams for documents |
| Cstd::basic_ostream< Char > | STL class |
| Cstd::basic_iostream< Char > | STL class |
| Cstd::ostream | STL class |
| Cowl::TOutStream | Derived from TStream and ostream, TOutStream is a base class used to create output storage streams for a document |
| CITypeInfo | |
| Cocf::TCoClassInfo | |
| CITypeLib | |
| Cocf::TTypeLibrary | |
| CIUnknown | |
| Cocf::IBClassMgr | IClassMgr abstract base class |
| Cocf::TOcApp | OCF Application class |
| Cocf::IBContains | IContains abstract base class |
| Cocf::TOcView | The TOcView partner is a container (viewer) of a given (server/client) document |
| Cocf::TOcRemView | Remote Viewer object for a server document |
| Cocf::TOcxView | The TOcxView partner is a container (viewer) of a given (server/client) document |
| Cocf::IBControlSite | |
| Cocf::TOcControl | Class representing an embedded control within a document |
| Cocf::IBDataNegotiator | IBDataNegotiator – Enumerats formats for drag/drop and paste |
| Cocf::IBDataConsumer | IBDataConsumer – Supported by containers who want to accept drag/drop and paste |
| Cocf::IBDropDest | IBDropDest – Supported by container app's document window and/or other areas inside the window |
| Cocf::TOcView | The TOcView partner is a container (viewer) of a given (server/client) document |
| Cocf::IBDataProvider | IBDataProvider – Supported by parts and/or sites which can be copied to the OLE2 clipboard |
| Cocf::IBDataProvider2 | IBDataProvider2 – new version of IBDataProvider |
| Cocf::IBPart2 | IBPart2 – Supported by server objects |
| Cocf::TOcRemView | Remote Viewer object for a server document |
| Cocf::IBPart | IBPart – Supported by server objects |
| Cocf::IBControl | |
| Cocf::IBPart2 | IBPart2 – Supported by server objects |
| Cocf::TOcLinkView | Link Viewer object for a server document |
| Cocf::TOcDataProvider | Data Provider object for a container document |
| Cocf::IBDataState | |
| Cocf::IBDocument | IBDocument – Supported by BOleDocument one per container child window |
| Cocf::IBEventClass | |
| Cocf::IBEventsHandler | |
| Cocf::IBLinkInfo | IBLinkInfo – Supported by BOleParts which are link objects |
| Cocf::IBLinkable | ILinkable abstract base class |
| Cocf::IBRootLinkable | |
| Cocf::IBOverrideBrowseLinks | IBOverrideBrowseLinks – Supported by containers(who aggregate BOleDoc) who want to override our BrowseLinks dialog |
| Cocf::IBOverrideHelpButton | IBOverrideHelpButton – Supported by container apps (who aggregate BOleService) who want to suppress the help button in our dialogs |
| Cocf::IBService | IService abstract base class |
| Cocf::IBService2 | |
| Cocf::IBSinkList | |
| Cocf::IBSite | IBSite – Supported by container apps for each linked/embedded object |
| Cocf::IBSite2 | IBSite2 – Add flexibility to have parent of site not be container |
| Cocf::TOcPart | OC part class represents an embeded or linked part in a document |
| Cocf::TOcControl | Class representing an embedded control within a document |
| Cocf::IBWindow | IBWindow – Supported on child window and frame window of container apps |
| Cocf::IBApplication | IBApplication – Supported at frame window/app object of container apps |
| Cocf::TOcApp | OCF Application class |
| Cocf::IBContainer | IBContainer – Supported by container app's document window |
| Cocf::TOcView | The TOcView partner is a container (viewer) of a given (server/client) document |
| CLVBKIMAGE | |
| Cowl::TLvBkImage | |
| CLVCOLUMN | |
| Cowl::TLvColumn | Encapsulates structure LVCOLUMN, used to pass or retrieve column attributes in a TListViewCtrl |
| CLVFINDINFO | |
| Cowl::TLvFindInfo | Encapsulates structure LVFINDINFO, used to find an item in a TListViewCtrl |
| CLVFOOTERINFO | |
| Cowl::TLvFooterInfo | Encapsulates structure LVFOOTERINFO, used to pass or retrieve footer information in a TListViewCtrl |
| CLVFOOTERITEM | |
| Cowl::TLvFooterItem | Encapsulates structure LVFOOTERITEM, used to pass or retrieve footer item information in a TListViewCtrl |
| CLVHITTESTINFO | |
| Cowl::TLvHitTestInfo | Encapsulates structure LVHITTESTINFO, used to contain information about a hit test in a TListViewCtrl |
| CLVITEM | |
| Cowl::TLvItem | Encapsulates structure LVITEM, used to describe an item in a TListViewCtrl |
| CLVTILEVIEWINFO | |
| Cowl::TLvTileViewInfo | Encapsulates structure LVTILEVIEWINFO, used to pass or retrieve tile view information in a TListViewCtrl |
| CMCHITTESTINFO | |
| Cowl::TMCHitTestInfo | MonthCalendar Control notifications |
| CMENUITEMINFO | |
| Cowl::TMenuItemInfo | |
| Cowl::METAFILEHEADER | |
| CMSGFILTER | |
| Cowl::TMsgFilter | Structure sent with EN_MSGFILTER notification |
| CNM_UPDOWN | |
| Cowl::TNmUpDown | TNmUpDown is a wrapper of the NM_UPDOWN structure sent with notifications from an 'UpDown' control |
| CNMCBEDRAGBEGIN | |
| Cowl::TCBExDragInfo | |
| CNMCBEENDEDIT | |
| Cowl::TCBExEditInfo | |
| CNMCHAR | |
| Cowl::TNmChar | |
| CNMCOMBOBOXEX | |
| Cowl::TCBExNotifyInfo | |
| CNMCUSTOMDRAW | |
| Cowl::TNmCustomDraw | |
| CNMDATETIMECHANGE | |
| Cowl::TDateTimeChange | |
| CNMDATETIMEFORMAT | |
| Cowl::TDateTimeFormat | |
| CNMDATETIMEFORMATQUERY | |
| Cowl::TDateTimeFormatQuery | |
| CNMDATETIMESTRING | |
| Cowl::TDateTimeString | |
| CNMDATETIMEWMKEYDOWN | |
| Cowl::TDateTimeKeyDown | |
| CNMDAYSTATE | |
| Cowl::TNmDayState | |
| CNMHDDISPINFO | |
| Cowl::THdrDispInfo | |
| CNMHDFILTERBTNCLICK | |
| Cowl::THdrFilterBtnClick | |
| CNMHDR | |
| Cowl::TNotify | TNotify is a thin wrapper around the NMHDR structure |
| CNMIPADDRESS | |
| Cowl::TNmIPAddress | IP Address control notifications |
| CNMITEMACTIVATE | |
| Cowl::TLvItemActivate | |
| CNMKEY | |
| Cowl::TNmKey | |
| CNMLISTVIEW | |
| Cowl::TLvNotify | Basic TListViewCtrl notification |
| CNMLVCACHEHINT | |
| Cowl::TLvCacheHint | |
| CNMLVCUSTOMDRAW | |
| Cowl::TLvCustomDraw | |
| CNMLVDISPINFO | |
| Cowl::TLvDispInfoNotify | A TListViewCtrl notification to repaint an item |
| CNMLVFINDITEM | |
| Cowl::TLvFindItem | |
| CNMLVGETINFOTIP | |
| Cowl::TLvGetInfoTip | |
| CNMLVKEYDOWN | |
| Cowl::TLvKeyDownNotify | A TListViewCtrl notification that a key has been pressed |
| CNMLVODSTATECHANGE | |
| Cowl::TLvOdStateChanged | |
| CNMMOUSE | |
| Cowl::TNmMouse | |
| CNMOBJECTNOTIFY | |
| Cowl::TNmObjectNotify | |
| CNMPGCALCSIZE | |
| Cowl::TNmPGCalcSize | Pager Control notifications |
| CNMPGSCROLL | |
| Cowl::TNmPGScroll | |
| CNMSELCHANGE | |
| Cowl::TNmSelChange | |
| CNMTREEVIEW | |
| Cowl::TTvNotify | Basic TTreeViewCtrl notification |
| CNMTTCUSTOMDRAW | |
| Cowl::TTtCustomDraw | |
| CNMTTDISPINFO | |
| Cowl::TTooltipDispInfo | |
| CNMTVCUSTOMDRAW | |
| Cowl::TTvCustomDraw | |
| CNMTVDISPINFO | |
| Cowl::TTvDispInfoNotify | A TTreeViewCtrl notification to repaint an item |
| CNMTVGETINFOTIP | |
| Cowl::TTvGetInfoTip | |
| CNMTVKEYDOWN | |
| Cowl::TTvKeyDownNotify | A TTreeViewCtrl notification that a key has been pressed |
| CNOTIFYICONDATA | |
| Cowl::TTrayIcon | |
| Cowl::ObjectBuilder | |
| Cowl::TStreamableClass | TStreamableClass is used by the private database class and pstream in the registration of streamable classes |
| CPARAFORMAT2 | |
| Cowl::TParaFormat | TParaFormat encapsulates the PARAFORMAT structure, which contains information about paragraph formatting attributes of a rich edit control |
| CPOINTL | |
| Cowl::TPointL | TPointL is similar to TPoint, but uses long rather than int variables |
| CPSHNOTIFY | |
| Cowl::TPshNotify | |
| Cowl::pstream | Base class for handling streamable objects |
| Cowl::fpbase | Provides the basic operations common to all object file stream I/O |
| Cowl::ifpstream | Ifpstream is a simple "mix" of its bases, fpbase and ipstream |
| Cowl::ofpstream | Provides the base class for writing (inserting) streamable objects to file streams |
| Cowl::ipstream | Ipstream, a specialized input stream derivative of pstream, is the base class for reading (extracting) streamable objects |
| Cowl::ifpstream | Ifpstream is a simple "mix" of its bases, fpbase and ipstream |
| Cowl::opstream | Base class for writing streamable objects |
| Cowl::ofpstream | Provides the base class for writing (inserting) streamable objects to file streams |
| CRBHITTESTINFO | |
| Cowl::TRbHitTestInfo | |
| CREBARINFO | |
| Cowl::TRebarInfo | |
| Cowl::RECT16 | |
| CREQRESIZE | |
| Cowl::TReqResize | Structure sent with EN_REQUESTRESIZE notification |
| CSELCHANGE | |
| Cowl::TSelChange | Structure sent with EN_SELCHANGE notification |
| Cservent | |
| Cowl::TServiceEntry | Encapsulates information about a service |
| Csockaddr | |
| Cowl::TSocketAddress | Stores a Winsock socket address |
| Cowl::TINetSocketAddress | A Winsock Internet address |
| CSYSTEMTIME | |
| Cowl::TSystemTime | TSystemTime is a class derived from the structure SYSTEMTIME |
| Cowl::TAEnvelope< T > | Envelope-letter type of smart pointer array |
| CtagPALETTEENTRY | |
| Cowl::TPaletteEntry | Wrapper for Windows' PALETTEENTRY type |
| CtagPOINT | |
| Cowl::TPoint | TPoint is a support class, derived from tagPOINT |
| CtagRECT | |
| Cowl::TRect | TRect is a mathematical class derived from tagRect |
| Cowl::TSplitterIndicator | Indicates to the user where the splitter will be moved to when dragging completes |
| Cowl::THSplitterIndicator | Horizontal indicator |
| Cowl::TVSplitterIndicator | Vertical indicator |
| CtagRGBQUAD | |
| Cowl::TRgbQuad | Wrapper for Windows' RBGQUAD type |
| CtagRGBTRIPLE | |
| Cowl::TRgbTriple | Wrapper for Windows' RBGTRIPLE type |
| CtagSIZE | |
| Cowl::TSize | The tagSIZE struct is defined as |
| Cowl::TAppDictionary | TAppDictionary implementation for DLLs only |
| Cowl::TDispatch< WM_PARENTNOTIFY >::TArgs | Base class for the parameter to the WM_PARENTNOTIFY handler |
| Cowl::TDispatch< WM_PARENTNOTIFY >::TChildInfoArgs | Parameter package for the WM_PARENTNOTIFY handler |
| Cowl::TDispatch< WM_PARENTNOTIFY >::TMouseInfoArgs | Parameter package for the WM_PARENTNOTIFY handler |
| Cowl::TArrayBase | Base array class |
| Cowl::TMObjectArray< T, TStandardAllocator > | |
| Cowl::TMSortedObjectArray< T, TStandardAllocator > | |
| Cowl::TSortedObjectArray< T > | |
| Cowl::TMSortedObjectArray< T, A > | |
| Cowl::TSortedObjectArray< tstring > | |
| Cowl::TSortedObjectArray< TStringMapNode > | |
| Cowl::TSortedObjectArray< TObjInfo > | |
| Cowl::TObjectArray< T > | |
| Cowl::TTypedArray< int, int, TStandardAllocator > | |
| Cowl::TTypedArray< uint32, uint32, TStandardAllocator > | |
| Cowl::TTypedArray< LPARAM, LPARAM, TStandardAllocator > | |
| Cowl::TTypedArray< uint, uint, TStandardAllocator > | |
| Cowl::TTypedArray< TCheckListItem *, TCheckListItem *, TStandardAllocator > | |
| Cowl::TPtrArray< TCheckListItem * > | |
| Cowl::TCheckListArray | |
| Cowl::TTypedArray< T, R, TStandardAllocator > | |
| Cowl::TMIPtrArray< T, R, A > | |
| Cowl::TSTypedArray< T, R, A > | |
| Cowl::TTypedArray< TStringNode *, TStringNode *, TStandardAllocator > | |
| Cowl::TPtrArray< TStringNode * > | |
| Cowl::TIPtrArray< TStringNode * > | |
| Cowl::TTypedArray< TPickerCell *, TPickerCell *, TStandardAllocator > | |
| Cowl::TPtrArray< TPickerCell * > | |
| Cowl::TIPtrArray< TPickerCell * > | |
| Cowl::TTypedArray< T, T, TStandardAllocator > | |
| Cowl::TSTypedArray< T, T, TStandardAllocator > | |
| Cowl::TSortedPtrArray< T > | Sorted array of pointers of simple types |
| Cowl::TISortedPtrArray< T > | |
| Cowl::TPtrArray< T > | Array of pointers of simple types |
| Cowl::TIPtrArray< TCoolBand * > | |
| Cowl::TIPtrArray< TDrawItem * > | |
| Cowl::TIPtrArray< TFileDroplet * > | |
| Cowl::TIPtrArray< TOcFormatName * > | |
| Cocf::TOcNameList | Clipboard format names |
| Cowl::TIPtrArray< TOcFormat * > | |
| Cocf::TOcFormatList | Container of clipboard formats with iterator |
| Cowl::TIPtrArray< T > | |
| Cowl::TTypedArray< TStreamableBase *, TStreamableBase *, TStandardAllocator > | |
| Cowl::TPtrArray< TStreamableBase * > | |
| Cowl::TTypedArray< TStreamableClass *, TStreamableClass *, TStandardAllocator > | |
| Cowl::TSTypedArray< TStreamableClass *, TStreamableClass *, TStandardAllocator > | |
| Cowl::TSortedPtrArray< TStreamableClass * > | |
| Cowl::TISortedPtrArray< TStreamableClass * > | |
| Cowl::TTypedArray< owl::TCheckListItem *, owl::TCheckListItem *, TStandardAllocator > | |
| Cowl::TPtrArray< owl::TCheckListItem * > | |
| Cowl::TIPtrArray< owl::TCheckListItem * > | |
| Cowl::TMObjectArray< T, A > | Holds array pointers to strings |
| Cowl::TObjectArray< TComboBoxExItem > | |
| Cowl::TObjectArray< tstring > | |
| Cowl::TTypedArray< T, R, A > | Stores pointer to object |
| Cowl::TPtrArray< TOcLinkView * > | |
| Cocf::TOcLinkCollection | Container of link views with iterator |
| Cowl::TPtrArray< TOcPart * > | |
| Cocf::TOcPartCollection | Container of parts with iterator |
| Cowl::TArrayProperty< T, I > | |
| Cocf::TAutoBase | |
| Cocf::TAutoBool | |
| Cocf::TAutoBoolRef | |
| Cocf::TAutoByte | |
| Cocf::TAutoByteRef | |
| Cocf::TAutoCommand | Automation abstract base class for command objects |
| Cocf::TAutoCreator | Object responsible for creating automation COM object |
| Cocf::TDispatchCreator | |
| Cocf::TServedObjectCreator | |
| Cocf::TAutoCurrency | |
| Cocf::TAutoCurrencyRef | |
| Cocf::TAutoDate | |
| Cocf::TAutoDateRef | |
| Cocf::TAutoDetach | |
| Cocf::TAutoDispatch | |
| Cocf::TAutoDispId | |
| Cocf::TAutoDispIds< N > | |
| Cocf::TAutoDouble | |
| Cocf::TAutoDoubleRef | |
| Cocf::TAutoEnumeratorBase | |
| Cocf::TAutoEnumerator< T > | |
| Cocf::TAutoEnumVal< T > | |
| Cocf::TAutoEventDummy | |
| Cocf::TAutoFactory< T > | A template class, TAutoFactory<> creates callback code for ObjectWindows classes |
| Cocf::TAutoFloat | |
| Cocf::TAutoFloatRef | |
| Cocf::TAutoLong | |
| Cocf::TAutoLongRef | |
| Cocf::TAutoObject< T > | Holders for C++ object pointers for automation conversions |
| Cocf::TAutoObjectDelete< T > | |
| Cocf::TAutoObjectByVal< T > | |
| Cocf::TAutoProxy | Client C access proxy, base class |
| Cocf::TAutoProxyArgs | |
| Cocf::TAutoArgs< N > | The first TAutoVal item of TAutoArgs holds the return value |
| Cocf::TAutoSafeArray | |
| Cocf::TAutoShort | |
| Cocf::TAutoShortRef | |
| Cocf::TAutoStack | Automation argument stack abstraction |
| Cocf::TAutoStringRef | |
| Cocf::TAutoSymbol | Symbol table element |
| Cocf::TAutoType | |
| Cocf::TAutoClass | |
| Cocf::TAutoEnum | |
| Cocf::TAutoEnumT< T > | |
| Cocf::TAutoUnknown | |
| Cocf::TAutoVal | Automation data element (same data as OLE/BASIC VARIANT) |
| CTAutoVal | |
| CTSafeArray< T > | |
| Cocf::TAutoVariant | |
| Cocf::TAutoVariantRef | |
| Cocf::TAutoVoid | |
| Cowl::TBandInfo | Equivalent to BANDINFOSTRUCT |
| Cowl::TBarDescr | Descriptor of Bar Implementation |
| Cowl::TBaseList< T > | |
| Cowl::TBaseList< TSplitterIndicator * > | |
| Cowl::TSplitterIndicatorList | |
| Cowl::TBaseListIterator< T > | |
| Cowl::TBaseNode< T > | |
| Cowl::TBinField | The TBinField struct describes a group of like-typed fields in a structure to be read or written using the Binary I/O Struct calls |
| Cowl::TBitFlags< T > | For example: |
| Cowl::TBitFlags< uint > | |
| Cowl::TFlatPainter | |
| Cowl::TFlatComboBox | |
| Cowl::TGadgetComboBox | For use with TGadgetWindow |
| Cowl::TFlatEdit | |
| Cowl::TGadgetEdit | For use with TGadgetWindow |
| Cowl::TFlatListBox | |
| Cowl::TGadgetListBox | For use with TGadgetWindow |
| Cowl::TGridPicker | |
| Cowl::TPopupPicker | |
| Cowl::TColorPicker | |
| Cowl::TPickerCell | Bsabstract base class |
| Cowl::TBitmapCell | |
| Cowl::TColorCell | |
| Cowl::TTextCell | |
| Cowl::TBitSet< T > | Simplifies setting and testing bits in a 32 count array of uint8 (32 bytes) |
| Cowl::TBitSet< tchar > | |
| Cowl::TCharSet | Derived from TBitSet, TCharSet sets and clears bytes for a group of characters |
| Cowl::TGadget::TBorders | Border dimensions |
| CTC_HITTESTINFO | |
| Cowl::TTabHitTestInfo | TTabHitTestInfo is a thin [very thin] wrapper around the TC_HITTESTINFO structure |
| CTC_KEYDOWN | |
| Cowl::TTabKeyDown | Wrapper of the TC_KEYDOWN structure sent to the parent of a tabcontrol to notify that a key has been pressed |
| Cowl::TCelArray | TCelArray is a horizontal array of cels (a unit of animation) created by slicing a portion of or an entire bitmap into evenly sized shapes |
| Cowl::TCharIterator< T > | |
| Cowl::TBidirCharIterator< T > | |
| Cowl::TCheckListData | |
| Cowl::TCheckListItem | Each item displayed and manipulated by TCheckList |
| Cowl::TWindow::TChildrenIteratorTemplate< T > | Utility class template used as an iterator type template for TChildrenRangeTemplate |
| Cowl::TWindow::TChildrenRangeTemplate< T > | Utility class template used as a return type for TWindow::GetChildren |
| CTCITEM | |
| Cowl::TTabItem | TTabItem encapsulates the attributes of a single tab within a tab control |
| Cowl::TCkInfo | RIFF chunk information data structure |
| Cocf::TClassId | GUID/IID/CLSID management |
| Cocf::TBaseClassId | Base GUID for a components sequence of GUIDs |
| Cowl::TClipboard | The clipboard class encapsulates the methods for the clipboard object of Windows |
| Cowl::TClipboardFormatIterator | |
| Cowl::TCmdLine | Command line argument processing class, processes in the form: |
| Cowl::TCodePages | Encapsulates Windows code page functionality |
| Cowl::TCollection< T > | Simple template holding pointers to Ts used internally by ObjectWindows Controls |
| Cowl::TColor | Class wrapper for management of color values |
| Cowl::TComboBoxData | An interface object that represents a transfer buffer for a TComboBox |
| Cowl::TComboBoxExData | |
| Cowl::TComboBoxExItem | Encapsulates an item in an extended combo box (COMBOBOXEXITEM) |
| Cocf::TAutoEventDummy::TCommand_ | |
| Cowl::TCommandEnabler | Base class for an extensible interface for auto enabling/disabling of commands (menu items, tool bar buttons, ...) |
| Cowl::TControlEnabler | A TCommandEnabler for child controls in a dialog |
| Cowl::TMenuItemEnabler | Derived from TCommandEnabler, TMenuItemEnabler is a command enabler for menu items |
| Cowl::TTooltipEnabler | TTooltipEnabler is the object forwarded along the command-chain to retrieve the tip text of a tool |
| Cowl::TListViewCtrl::TCompareFunc | Pure virtual base class for comparing sort items |
| Cowl::TComRefBase< T > | Encapsulation of OLE interface pointers |
| Cowl::TComRef< T > | |
| Cowl::TComRefBase< IContextMenu > | |
| Cowl::TComRef< IContextMenu > | |
| Cowl::TContextMenu | Wraps the IContextMenu interface (currently lightweight) |
| Cowl::TComRefBase< IDataObject > | |
| Cowl::TComRef< IDataObject > | |
| Cowl::TDataObject | Wraps the IDataObject interface (currently lightweight) |
| Cowl::TComRefBase< IDropTarget > | |
| Cowl::TComRef< IDropTarget > | |
| Cowl::TDropTarget | Wraps the IDropTarget interface (currently lightweight) |
| Cowl::TComRefBase< IEnumIDList > | |
| Cowl::TComRef< IEnumIDList > | |
| Cowl::TShellItemIterator | TShellItemIterator is an interator for walking through the contents of a folder |
| Cowl::TComRefBase< IExtractIcon > | |
| Cowl::TComRef< IExtractIcon > | |
| Cowl::TExtractIcon | Wraps the IExtractIcon interface (currently lightweight) |
| Cowl::TComRefBase< IMalloc > | |
| Cowl::TComRef< IMalloc > | |
| Cowl::TShellMalloc | Wraps the shell's IMalloc interface |
| Cowl::TComRefBase< IShellFolder > | |
| Cowl::TComRef< IShellFolder > | |
| Cowl::TShellItem | An item in the shell's name space |
| Cowl::TConfigFile | Save/Load configuration parameters Base abstract class |
| Cowl::TIniConfigFile | Encapsulates the Windows INI file interface Get/SetPrivateProfileXXX functions |
| Cowl::TMemConfigFile | |
| Cowl::TRegConfigFile | Derived from TConfigFile, TRegConfigFile is used to maintain configuration settings in the registry |
| Cowl::TConfigFileSection | Small inline wrapper around Section |
| Cowl::TConstArrayProperty< T, I > | Array read only array |
| Cowl::TConstObjArrayProperty< T, I > | Array read only array |
| Cowl::TConstObjProperty< T > | Read only Property container for object |
| Cowl::TConstProperty< T > | |
| Cowl::TCoolBand | |
| Cowl::TShellItem::TCreateStruct | TCreateStruct contains information to construct a TShellItem Typically a TCreateStruct is returned (for example by GetParentFolder) and this TCreateStruct is used to construct a TshellItem Passed in as arguments to: |
| Cowl::TCriticalSection | Lightweight intra-process thread synchronization |
| Cocf::TCtrlEvent | Base struct for all control event messages |
| Cocf::TCtrlCustomEvent | |
| Cocf::TCtrlErrorEvent | |
| Cocf::TCtrlFocusEvent | |
| Cocf::TCtrlKeyEvent | |
| Cocf::TCtrlMouseEvent | |
| Cocf::TCtrlPropertyEvent | |
| Cocf::TCtrlTransformCoords | |
| Cowl::TCurrentEvent | Current event structure for windows events |
| Cowl::TChooseColorDialog::TData | Defines information necessary to initialize the dialog box with the user's color selection |
| Cowl::TChooseFontDialog::TData | Defines information necessary to initialize the dialog box with the user's font selection |
| Cowl::TFindReplaceDialog::TData | The TFindReplaceDialog::TData class encapsulates information necessary to initialize a TFindReplace dialog box |
| Cowl::TOpenSaveDialog::TData | TOpenSaveDialog structure contains information about the user's file open or save selection |
| Cowl::TDvOpenSaveData | TDvOpenSaveData encapsulates the information used to initialized the Open or Save As dialog box by ObjectWindows' DocView manager |
| Cowl::TPrintDialog::TData | TPrintDialog::TData contains information required to initialize the printer dialog box with the user's print selections |
| Cowl::TDate | Date |
| Cowl::TDateTimePickerData | |
| Cowl::TPrinter::TDevMode | Contains information about the initialization and environment of a printer device |
| Cowl::TDiagBase | |
| Cowl::TDiagBaseHook | |
| Cowl::TTraceWindow | |
| Cowl::TDiagFunction | |
| Cowl::TDialogAttr | Holds a TDialog object's creation attributes, which include the style, appearance, size, and types of controls associated with the dialog box |
| Cowl::TDialogRes | |
| Cowl::TDispatch< MessageID > | Undefined default template for dispatchers Template specialization is used to allow the compiler to look up the dispatcher for a particular message at compile-time |
| Cowl::TDispatch< DM_GETDEFID > | |
| Cowl::TDispatch< DM_REPOSITION > | |
| Cowl::TDispatch< DM_SETDEFID > | |
| Cowl::TDispatch< WM_ACTIVATE > | |
| Cowl::TDispatch< WM_ACTIVATEAPP > | |
| Cowl::TDispatch< WM_ASKCBFORMATNAME > | |
| Cowl::TDispatch< WM_CANCELMODE > | |
| Cowl::TDispatch< WM_CAPTURECHANGED > | |
| Cowl::TDispatch< WM_CHANGECBCHAIN > | |
| Cowl::TDispatch< WM_CHAR > | |
| Cowl::TDispatch< WM_CHARTOITEM > | |
| Cowl::TDispatch< WM_CHILDACTIVATE > | |
| Cowl::TDispatch< WM_CHILDINVALID > | |
| Cowl::TDispatch< WM_CLOSE > | |
| Cowl::TDispatch< WM_COMMAND_ENABLE > | |
| Cowl::TDispatch< WM_COMPACTING > | |
| Cowl::TDispatch< WM_COMPAREITEM > | |
| Cowl::TDispatch< WM_CONTEXTMENU > | |
| Cowl::TDispatch< WM_COPYDATA > | |
| Cowl::TDispatch< WM_CREATE > | |
| Cowl::TDispatch< WM_CTLCOLORBTN > | |
| Cowl::TDispatch< WM_CTLCOLORDLG > | |
| Cowl::TDispatch< WM_CTLCOLOREDIT > | |
| Cowl::TDispatch< WM_CTLCOLORLISTBOX > | |
| Cowl::TDispatch< WM_CTLCOLORSCROLLBAR > | |
| Cowl::TDispatch< WM_CTLCOLORSTATIC > | |
| Cowl::TDispatch< WM_CUT > | |
| Cowl::TDispatch< WM_DEADCHAR > | |
| Cowl::TDispatch< WM_DELETEITEM > | |
| Cowl::TDispatch< WM_DESTROY > | |
| Cowl::TDispatch< WM_DESTROYCLIPBOARD > | |
| Cowl::TDispatch< WM_DEVICECHANGE > | |
| Cowl::TDispatch< WM_DEVMODECHANGE > | |
| Cowl::TDispatch< WM_DISPLAYCHANGE > | |
| Cowl::TDispatch< WM_DRAWCLIPBOARD > | |
| Cowl::TDispatch< WM_DRAWITEM > | |
| Cowl::TDispatch< WM_DROPFILES > | |
| Cowl::TDispatch< WM_ENABLE > | |
| Cowl::TDispatch< WM_ENDSESSION > | |
| Cowl::TDispatch< WM_ENTERIDLE > | |
| Cowl::TDispatch< WM_ENTERMENULOOP > | |
| Cowl::TDispatch< WM_ENTERSIZEMOVE > | |
| Cowl::TDispatch< WM_ERASEBKGND > | |
| Cowl::TDispatch< WM_EXITMENULOOP > | |
| Cowl::TDispatch< WM_EXITSIZEMOVE > | |
| Cowl::TDispatch< WM_FONTCHANGE > | |
| Cowl::TDispatch< WM_GETDLGCODE > | |
| Cowl::TDispatch< WM_GETFONT > | |
| Cowl::TDispatch< WM_GETICON > | |
| Cowl::TDispatch< WM_GETMINMAXINFO > | |
| Cowl::TDispatch< WM_GETTEXT > | |
| Cowl::TDispatch< WM_GETTEXTLENGTH > | |
| Cowl::TDispatch< WM_HELP > | |
| Cowl::TDispatch< WM_HOTKEY > | |
| Cowl::TDispatch< WM_HSCROLL > | |
| Cowl::TDispatch< WM_HSCROLLCLIPBOARD > | |
| Cowl::TDispatch< WM_INITMENU > | |
| Cowl::TDispatch< WM_INITMENUPOPUP > | |
| Cowl::TDispatch< WM_INPUTLANGCHANGE > | |
| Cowl::TDispatch< WM_INPUTLANGCHANGEREQUEST > | |
| Cowl::TDispatch< WM_KEYDOWN > | |
| Cowl::TDispatch< WM_KEYUP > | |
| Cowl::TDispatch< WM_KILLFOCUS > | |
| Cowl::TDispatch< WM_LBUTTONDBLCLK > | |
| Cowl::TDispatch< WM_LBUTTONDOWN > | |
| Cowl::TDispatch< WM_LBUTTONUP > | |
| Cowl::TDispatch< WM_MBUTTONDBLCLK > | |
| Cowl::TDispatch< WM_MBUTTONDOWN > | |
| Cowl::TDispatch< WM_MBUTTONUP > | |
| Cowl::TDispatch< WM_MDIACTIVATE > | |
| Cowl::TDispatch< WM_MDICASCADE > | |
| Cowl::TDispatch< WM_MDICREATE > | |
| Cowl::TDispatch< WM_MDIDESTROY > | |
| Cowl::TDispatch< WM_MEASUREITEM > | |
| Cowl::TDispatch< WM_MENUCHAR > | |
| Cowl::TDispatch< WM_MENUSELECT > | |
| Cowl::TDispatch< WM_MOUSEACTIVATE > | |
| Cowl::TDispatch< WM_MOUSEHOVER > | |
| Cowl::TDispatch< WM_MOUSEHWHEEL > | |
| Cowl::TDispatch< WM_MOUSELEAVE > | |
| Cowl::TDispatch< WM_MOUSEMOVE > | |
| Cowl::TDispatch< WM_MOUSEWHEEL > | |
| Cowl::TDispatch< WM_MOVE > | |
| Cowl::TDispatch< WM_MOVING > | |
| Cowl::TDispatch< WM_NCACTIVATE > | |
| Cowl::TDispatch< WM_NCCALCSIZE > | |
| Cowl::TDispatch< WM_NCCREATE > | |
| Cowl::TDispatch< WM_NCDESTROY > | |
| Cowl::TDispatch< WM_NCHITTEST > | |
| Cowl::TDispatch< WM_NCLBUTTONDBLCLK > | |
| Cowl::TDispatch< WM_NCLBUTTONDOWN > | |
| Cowl::TDispatch< WM_NCLBUTTONUP > | |
| Cowl::TDispatch< WM_NCMBUTTONDBLCLK > | |
| Cowl::TDispatch< WM_NCMBUTTONDOWN > | |
| Cowl::TDispatch< WM_NCMBUTTONUP > | |
| Cowl::TDispatch< WM_NCMOUSEHOVER > | |
| Cowl::TDispatch< WM_NCMOUSELEAVE > | |
| Cowl::TDispatch< WM_NCMOUSEMOVE > | |
| Cowl::TDispatch< WM_NCPAINT > | |
| Cowl::TDispatch< WM_NCRBUTTONDBLCLK > | |
| Cowl::TDispatch< WM_NCRBUTTONDOWN > | |
| Cowl::TDispatch< WM_NCRBUTTONUP > | |
| Cowl::TDispatch< WM_NEXTDLGCTL > | |
| Cowl::TDispatch< WM_NEXTMENU > | |
| Cowl::TDispatch< WM_NOTIFY > | |
| Cowl::TDispatch< WM_OCEVENT > | |
| Cowl::TDispatch< WM_OWLCANCLOSE > | |
| Cowl::TDispatch< WM_OWLCREATETTIP > | |
| Cowl::TDispatch< WM_OWLDOCUMENT > | |
| Cowl::TDispatch< WM_OWLFRAMESIZE > | |
| Cowl::TDispatch< WM_OWLHELPHIT > | |
| Cowl::TDispatch< WM_OWLNOTIFY > | |
| Cowl::TDispatch< WM_OWLPREPROCMENU > | |
| Cowl::TDispatch< WM_OWLVIEW > | |
| Cowl::TDispatch< WM_OWLWAKEUP > | |
| Cowl::TDispatch< WM_OWLWINDOWDOCKED > | |
| Cowl::TDispatch< WM_PAINT > | |
| Cowl::TDispatch< WM_PAINTCLIPBOARD > | |
| Cowl::TDispatch< WM_PALETTECHANGED > | |
| Cowl::TDispatch< WM_PALETTEISCHANGING > | |
| Cowl::TDispatch< WM_PARENTNOTIFY > | |
| Cowl::TDispatch< WM_PASTE > | |
| Cowl::TDispatch< WM_POWERBROADCAST > | |
| Cowl::TDispatch< WM_PRINT > | |
| Cowl::TDispatch< WM_PRINTCLIENT > | |
| Cowl::TDispatch< WM_QUERYDRAGICON > | |
| Cowl::TDispatch< WM_QUERYENDSESSION > | |
| Cowl::TDispatch< WM_QUERYNEWPALETTE > | |
| Cowl::TDispatch< WM_QUERYOPEN > | |
| Cowl::TDispatch< WM_QUEUESYNC > | |
| Cowl::TDispatch< WM_RBUTTONDBLCLK > | |
| Cowl::TDispatch< WM_RBUTTONDOWN > | |
| Cowl::TDispatch< WM_RBUTTONUP > | |
| Cowl::TDispatch< WM_RENDERALLFORMATS > | |
| Cowl::TDispatch< WM_RENDERFORMAT > | |
| Cowl::TDispatch< WM_SETCURSOR > | |
| Cowl::TDispatch< WM_SETFOCUS > | |
| Cowl::TDispatch< WM_SETFONT > | |
| Cowl::TDispatch< WM_SETICON > | |
| Cowl::TDispatch< WM_SETREDRAW > | |
| Cowl::TDispatch< WM_SETTEXT > | |
| Cowl::TDispatch< WM_SETTINGCHANGE > | |
| Cowl::TDispatch< WM_SHOWWINDOW > | |
| Cowl::TDispatch< WM_SIZE > | |
| Cowl::TDispatch< WM_SIZECLIPBOARD > | |
| Cowl::TDispatch< WM_SIZING > | |
| Cowl::TDispatch< WM_SPOOLERSTATUS > | |
| Cowl::TDispatch< WM_STYLECHANGED > | |
| Cowl::TDispatch< WM_STYLECHANGING > | |
| Cowl::TDispatch< WM_SYSCHAR > | |
| Cowl::TDispatch< WM_SYSCOLORCHANGE > | |
| Cowl::TDispatch< WM_SYSCOMMAND > | |
| Cowl::TDispatch< WM_SYSDEADCHAR > | |
| Cowl::TDispatch< WM_SYSKEYDOWN > | |
| Cowl::TDispatch< WM_SYSKEYUP > | |
| Cowl::TDispatch< WM_TCARD > | |
| Cowl::TDispatch< WM_THEMECHANGED > | |
| Cowl::TDispatch< WM_TIMECHANGE > | |
| Cowl::TDispatch< WM_TIMER > | |
| Cowl::TDispatch< WM_UNDO > | |
| Cowl::TDispatch< WM_USERCHANGED > | |
| Cowl::TDispatch< WM_VKEYTOITEM > | |
| Cowl::TDispatch< WM_VSCROLL > | |
| Cowl::TDispatch< WM_VSCROLLCLIPBOARD > | |
| Cowl::TDispatch< WM_WINDOWPOSCHANGED > | |
| Cowl::TDispatch< WM_WINDOWPOSCHANGING > | |
| CTDispatchCOM | |
| Cocf::TDispatch | Lightweight IDispatch implementation for automation controllers |
| Cowl::TDllLoader< T > | TDllLoader<> provides an easy way to load one instance of a DLL on demand |
| Cowl::TDockable | TDockable is an abstract base class for fixed or floating docking windows that want to be dockable into docking slips |
| Cowl::TDockableGadgetWindow | A version of TGadgetWindow which is dockable |
| Cowl::TDockableControlBar | A control bar class that is dockable |
| Cowl::TFloatingSlip | TFloatingSlip is a floating frame which can hold a dockable window |
| Cowl::TDockingSlip | TDockingSlip is an abstract base class for windows which accepts and holds dockable windows |
| Cowl::TEdgeSlip | TEdgeSlip is the class of windows used by THarbor as the actual docking slips along the decorated frame client's edges |
| Cowl::TFloatingSlip | TFloatingSlip is a floating frame which can hold a dockable window |
| Cocf::TDocViewDispatch< TMsgId > | |
| Cocf::TDocViewDispatch< WM_OWLNOTIFY > | |
| Cowl::TDrawItemBase | Class will be base class for owner draw items: ListBox,ComboBox,Menu atc |
| Cowl::TDrawItem | |
| Cowl::TButtonTextDrawItem | |
| Cowl::TDrawMenuItem | Derived from TButtonTextDrawItem, the TDrawMenuItem class is used for owner drawn menus |
| Cowl::TDrawItemProxy | Proxy parent for TDrawItem |
| Cowl::TDrawMenuItemProxy | Derived from TDrawItemProxy, TDrawMenuItemProxy is a proxy parent for TDrawMenuItem |
| Cowl::TDropInfo | TDropInfo is a simple class that supports file-name drag-and-drop operations using the WM_DROPFILES message |
| Cowl::TDvOpenSaveDataOwner | TDvOpenSaveDataOwner is a mixin class used by the DocView encapsulation of the FileOpen and FileSave dialogs |
| Cowl::TDvFileOpenDialog | TDvFileOpenDialog encapsulates the FileOpen dialog used by the DocView manager |
| Cowl::TDvFileSaveDialog | TDvFileSaveDialog encapsulates the FileSave dialog used by the DocView manager |
| Cowl::TAppDictionary::TEntry | An application dictionary entry that associates a process ID (Pid) with an application (App) |
| Cowl::TRegParamList::TEntry | |
| Cowl::TEnvelope< T > | Envelope-letter type of smart pointers |
| Cowl::TErrorMode | Simple encapsulation of the SetErrorMode call |
| Cocf::TEventEntry | |
| Cowl::TEventHandler | TEventHandler is a base class from which you can derive classes that handle messages |
| Cowl::TApplication | Derived from TModule and TMsgThread and virtually derived from TEventHandler, TApplication acts as an object-oriented stand-in for an application module |
| Cowl::TDocManager | TDocManager creates a document manager object that manages the list of current documents and registered templates, handles standard file menu commands, and displays the user-interface for file and view selection boxes |
| Cowl::TDragListEventHandler | A TEventHandler mix-in |
| Cowl::THelpFileManager | THelpFileManager, which is designed to be a mix-in for TApplication, uses the global context table |
| Cowl::TRecentFiles | TRecentFiles implements a most-recent files list, designed to be mixed in with TApplication |
| Cowl::TSerializeReceiver | Mix-in class that automatically puts together the block of data sent by TSerializer |
| Cowl::TTabbedBase | TTabbedBase implements a tabbed window, designed to be mixed in with TWindow derived |
| Cowl::TTabbedWindow | Tabbed windows it is used in tabbed window |
| Cowl::TTabbedView | |
| Cowl::TView | Abstract base class for view access from document |
| Cocf::TOleLinkView | Derived from TView, TOleLinkView provides embedding and linking support for a portion of a document instead of an entire document |
| Cocf::TOleView | The OLE2 window view class. Used as a view in doc/view model |
| Cowl::TDialogView | Derived from TDialog and TView |
| Cowl::TEditView | Derived from TView and TEditSearch, TEditView provides a view wrapper for the ObjectWindows text edit class (TEdit) |
| Cowl::TListBoxView | Provides views for list boxes |
| Cowl::TListViewCtrlView | |
| Cowl::TPaneSplitterView | |
| Cowl::TRichEditView | |
| Cowl::TTabbedView | |
| Cowl::TTreeViewCtrlView | |
| Cowl::TWindowView | Derived from both TWindow and TView, TWindowView is a streamable base class that can be used for deriving window-based views |
| Cowl::TWindow | TWindow, derived from TEventHandler and TStreamableBase, provides window-specific behavior and encapsulates many functions that control window behavior and specify window creation and registration attributes |
| Cocf::TOleWindow | The generic OLE2 window. Use as a client of a frame window |
| Cocf::TOleDialog | Provides OLE support to dialog boxes |
| Cocf::TOleView | The OLE2 window view class. Used as a view in doc/view model |
| Cowl::TClipboardViewer | Mix-in class that registers as a clipboard viewer when the user interface element is created and removes itself from the clipboard-viewer chain when it is destroyed |
| Cowl::TControl | TControl unifies its derived control classes, such as TScrollBar, TControlGadget, and TButton |
| Cowl::TAnimateCtrl | Encapsulates the Animation Control (a window that silently displays an Audio Video Interleaved, AVI clip) |
| Cowl::TButton | TButton is an interface class derived from TControl that represents a pushbutton interface element |
| Cowl::TCheckBox | TCheckBox is a streamable interface class that represents a check box control |
| Cowl::TRadioButton | Defines an interface object that represents a corresponding radio button element in Windows |
| Cowl::TGlyphButton | TGlyphButton encapsulates a control which is capable of displaying a bitmap (or glyph) and/or text |
| Cowl::TColumnHeader | TColumnHeader encapsulates the 'header control', a window usually positioned above columns of text or numbers |
| Cowl::TCoolBar | This simple implementation does no more than encapsulte the messages which can be sent to the rebar control |
| Cowl::TDateTimePicker | |
| Cowl::TGauge | A streamable class derived from TControl, TGauge defines the basic behavior of gauge controls |
| Cowl::TGridPicker | |
| Cowl::TGroupBox | An instance of a TGroupBox is an interface object that represents a corresponding group box element |
| Cowl::THotKey | THotKey encapsulates the hot-key control, a window that allows the user to enter a combination of keystrokes to be used as a a hot key |
| Cowl::TIPAddress | |
| Cowl::TListBox | An interface object that represents a corresponding list box element |
| Cowl::TCheckList | TCheckList is an owner-drawn list box to select multiple items |
| Cowl::TTabCheckList | Represents an owner-drawn list box that can select multiple items with tabs |
| Cowl::TComboBox | You can use TComboBox to create a combo box or a combo box control in a parent TWindow, or to facilitate communication between your application and the combo box controls of TDialog |
| Cowl::TComboBoxEx | ComboBoxEx controls are combo box controls that provide native support for item images |
| Cowl::TFlatComboBox | |
| Cowl::TMemComboBox | |
| Cowl::TDragList | TDragList is a draggable list box |
| Cowl::TFlatListBox | |
| Cowl::TListBoxView | Provides views for list boxes |
| Cowl::TListViewCtrl | Encapsulates the ListView control, a window that displays a collection of items, each item consisting of an icon and a label |
| Cowl::TListViewCtrlView | |
| Cowl::TMonthCalendar | |
| Cowl::TNoteTab | TNoteTab encapsulates a tab control with each tab item along the bottom of the window |
| Cowl::TPageScroller | |
| Cowl::TProgressBar | |
| Cowl::TScrollBar | TScrollBar objects represent standalone vertical and horizontal scroll bar controls |
| Cowl::TSlider | An abstract base class derived from TScrollBar, TSlider defines the basic behavior of sliders (controls that are used for providing nonscrolling, position information) |
| Cowl::THSlider | Derived from TSlider, THSlider provides implementation details for horizontal sliders |
| Cowl::TVSlider | Derived from TSlider, TVSlider provides implementation details for vertical sliders |
| Cowl::TStatic | An interface object that represents a static text interface element |
| Cowl::TEdit | A TEdit is an interface object that represents an edit control interface element |
| Cowl::TEditSearch | TEditSearch is an edit control that responds to Find, Replace, and FindNext menu commands |
| Cowl::TEditFile | TEditFile is a file-editing window |
| Cowl::TRichEdit | TRichEdit encapsulates a rich edit control, a window in which a user can enter, edit and format text |
| Cowl::TRichEditView | |
| Cowl::TEditView | Derived from TView and TEditSearch, TEditView provides a view wrapper for the ObjectWindows text edit class (TEdit) |
| Cowl::TFlatEdit | |
| Cowl::TSysLink | Encapsulates the SysLink common control, a Windows control that provides a convenient way to embed hypertext links in a window |
| Cowl::TAutoSysLink | Derives from TSysLink and provides automatic handling of link activation |
| Cowl::TTabControl | TTabControl encapsulates the tab control - a window that provides a user interface analogous to dividers in a notebook |
| Cowl::TTooltip | TTooltip encapsulates a tooltip window - i.e |
| Cowl::TTreeViewCtrl | Encapsulates the TreeView common control |
| Cowl::TTreeViewCtrlView | |
| Cowl::TUpDown | TUpDown encapsulates an up-down control, which is a window with a pair of arrow buttons that the user can click to increment or decrement a value |
| Cowl::TDelegatedTransferWindow | TWindow mix-in Delegates the job of transferring data to the given function object |
| Cowl::TDelegatedTransferDialog | Dialog derivative of TDelegatedTransferWindow |
| Cowl::TDialog | Typically used to obtain information from a user, a dialog box is a window inside of which other controls such as buttons and scroll bars can appear |
| Cocf::TOleDialog | Provides OLE support to dialog boxes |
| Cowl::TCommonDialog | Derived from TDialog, TCommonDialog is the abstract base class for TCommonDialog objects |
| Cowl::TChooseColorDialog | Wrapper for the Choose-Color common dialog |
| Cowl::TChooseFontDialog | Encapsulates the Choose-Font common dialog |
| Cowl::TFindReplaceDialog | TFindReplaceDialog is an abstract base class for a modeless dialog box that lets you search for and replace text |
| Cowl::TFindDialog | TFindDialog objects represents modeless dialog box interface elements that let you specify text to find |
| Cowl::TReplaceDialog | TReplaceDialog creates a modeless dialog box that lets the user enter a selection of text to replace |
| Cowl::TOpenSaveDialog | TOpenSaveDialog is the base class for modal dialogs that let you open and save a file under a specified name |
| Cowl::TFileOpenDialog | TFileOpenDialog is a modal dialog box that lets you specify the name of a file to open |
| Cowl::TDvFileOpenDialog | TDvFileOpenDialog encapsulates the FileOpen dialog used by the DocView manager |
| Cowl::TFileSaveDialog | TFileSaveDialog is a modal dialog box that lets you enter the name of a file to save |
| Cowl::TDvFileSaveDialog | TDvFileSaveDialog encapsulates the FileSave dialog used by the DocView manager |
| Cowl::TPrintDialog | TPrintDialog displays a modal print or a page setup dialog |
| Cowl::TDelegatedTransferDialog | Dialog derivative of TDelegatedTransferWindow |
| Cowl::TDialogView | Derived from TDialog and TView |
| Cowl::TInputDialog | Provides a generic dialog box to retrieve text input by a user |
| Cowl::TPickListDialog | The PickListDialog allows selection of an item from a list in a dialog with OK and Cancel buttons |
| Cowl::TPrinterAbortDlg | TPrinterAbortDlg is the object type of the default printer-abort dialog box |
| Cowl::TPropertyPage | The 'TPropertyPage' object represents a dialog box found within a property sheet |
| Cowl::TRollDialog | Allow a dialog to "roll" up and down, similar to the Corel interface |
| Cowl::TTransferDialog< TDataSource, TDialogBase > | Dialog class derived from TTransferWindow Provides convenient initialization of the dialog and transfer window bases |
| Cowl::TEdgeSlip | TEdgeSlip is the class of windows used by THarbor as the actual docking slips along the decorated frame client's edges |
| Cowl::TFrameWindow | Derived from TWindow, TFrameWindow controls such window-specific behavior as keyboard navigation and command processing for client windows |
| Cowl::TDecoratedFrame | TDecoratedFrame automatically positions its client window (you must supply a client window) so that it is the same size as the client rectangle |
| Cocf::TOleFrame | Decorated frame that supports OLE 2 using OCF |
| Cocf::TOleMDIFrame | Decorated MDI frame that supports OLE 2 using OCF |
| Cowl::TDecoratedMDIFrame | Derived from both TMDIFrame and TDecoratedFrame, TDecoratedMDIFrame is an MDI frame that supports decorated child windows |
| Cowl::TPreviewWin | TPreviewWin encapsulates a simple preview window frame |
| Cowl::TRichEditPreviewFrame | TRichEditPreviewFrame is a window object which contains preview pages displaying data from a rich edit control |
| Cowl::TFloatingFrame | Derived from TFrameWindow and TTinyCaption, TFloatingFrame implements a floating frame that can be positioned anywhere in the parent window |
| Cowl::TFloatingSlip | TFloatingSlip is a floating frame which can hold a dockable window |
| Cowl::TMDIChild | TMDIChild defines the basic behavior of all MDI child windows |
| Cowl::TMDIFrame | Multiple Document Interface (MDI) frame windows, represented by TMDIFrame, are overlapped windows that serve as main windows of MDI-compliant applications |
| Cocf::TOleMDIFrame | Decorated MDI frame that supports OLE 2 using OCF |
| Cowl::TDecoratedMDIFrame | Derived from both TMDIFrame and TDecoratedFrame, TDecoratedMDIFrame is an MDI frame that supports decorated child windows |
| Cowl::TTraceWindow | |
| Cowl::TGadgetWindow | Derived from TWindow, TGadgetWindow maintains a list of tiled gadgets for a window and lets you dynamically arrange tool bars |
| Cowl::TControlBar | Derived from TGadgetWindow, TControlBar implements a control bar that provides mnemonic access for its button gadgets |
| Cowl::TDockableGadgetWindow | A version of TGadgetWindow which is dockable |
| Cowl::TGadgetControl | TGadgetControl is a specialized, easily constructed gadget window that holds one gadget for use as a control in a window |
| Cowl::TMessageBar | Derived from TGadgetWindow, TMessageBar implements a message bar with one text gadget as wide as the window and no border |
| Cowl::TStatusBar | Status bars have more options than a plain message bar: you can have multiple text gadgets, different style borders, and you can reserve space for mode indicators |
| Cowl::TToolBox | |
| Cowl::THarbor | THarbor is the object that holds all the docking slips |
| Cowl::THostInfoWindow | A private class created by THostInfoManager to catch WinSock messages |
| Cowl::TLayoutWindow | Derived from TWindow, TLayoutWindow provides functionality for defining the layout metrics for a window |
| Cowl::TDecoratedFrame | TDecoratedFrame automatically positions its client window (you must supply a client window) so that it is the same size as the client rectangle |
| Cowl::TPaneSplitter | TPaneSplitter is a class that acts as a container for child windows (called panes) and splitters (pane mover, separator) |
| Cowl::TPaneSplitterView | |
| Cowl::TSplashWindow | This class creates a layout window that contains a TPictureWindow and optionally, a TStatic and a TGauge |
| Cowl::TSplitter | Abstract base class for TVSplitter and THSplitter |
| Cowl::THSplitter | Represents a horizontal splitter |
| Cowl::TVSplitter | Represents a vertical splitter |
| Cowl::TTabbedWindow | Tabbed windows it is used in tabbed window |
| Cowl::TMDIClient | Multiple Document Interface (MDI) client windows (represented by a TMDIClient object) manage the MDI child windows of a TMDIFrame parent |
| Cowl::TMciHiddenWindow | A private TWindow derivative used by TMci to capture events |
| Cowl::TPickListPopup | The PickList allows selection of an item from a popup list |
| Cowl::TPictureWindow | This class displays a dib in a window in different ways |
| Cowl::TPreviewPage | TPreviewPage encapsulates a window which displays print-preview data |
| Cowl::TRichEditPagePreview | TRichEditPagePreview is a window which displays rich edit data formatted for a particular printer DC |
| Cowl::TPropertySheet | TPropertySheet encapsulates a window which contains one or more overlapping child windows knowns as property pages |
| Cowl::TServiceWindow | TServiceWindow is a private class created by the TServiceManager to catch notifications |
| Cowl::TSocketWindow | Derived from TWindow, a private window used to catch notification messages |
| Cowl::TTinyCaption | Derived from TWindow, TTinyCaption is a mix-in class that handles a set of non-client events to produce a smaller caption bar for a window |
| Cowl::TFloatingFrame | Derived from TFrameWindow and TTinyCaption, TFloatingFrame implements a floating frame that can be positioned anywhere in the parent window |
| Cowl::TTransferBufferWindowBase | Serves as the base class for safe transfer buffer windows |
| Cowl::TTransferBufferWindow< TBuffer > | Provides the type-safe interface needed to set up a safe transfer buffer |
| Cowl::TTransferWindow< TDataSource > | Mix-in class template providing support for data transfer to and from controls |
| Cowl::TTransferDialog< TDataSource, TDialogBase > | Dialog class derived from TTransferWindow Provides convenient initialization of the dialog and transfer window bases |
| Cowl::TWindowView | Derived from both TWindow and TView, TWindowView is a streamable base class that can be used for deriving window-based views |
| Cowl::TEventHandler::TEventInfo | A nested class, TEventInfo provides specific information about the type of message sent, the class that contains the function to be handled, the corresponding response table entry, and the dispatch function that processes the message |
| Cocf::TEventList | |
| CTEXTRANGE | |
| Cowl::TTextRange | TTextRange encapsulates the TEXTRANGE structure, which contains information about a range of text in a rich edit control |
| Cowl::TFile | Standard file characteristics and operations |
| Cowl::TBufferedFile | Derived from TFile encapsulates standard file characteristics and operations using buffered I/O |
| Cowl::TQtFile | Used for reading and writing QuickTime files |
| Cowl::TRiffFile | Used for reading and writing RIFF files |
| Cowl::TTextFile | Derived from TBufferedFile and encapsulates standard file characteristics and operations using text based buffered I/O |
| Cowl::TStreamFile | |
| Cowl::TFileDroplet | TFileDroplet encapsulates information about a single dropped file, its name, where it was dropped, and whether or not it was in the client area |
| Cowl::TFileHandle | |
| Cowl::TDiskFileHandle | |
| Cowl::TStreamHandle | |
| Cowl::TFileLineIterator | Used to iterate through a TTextFile file |
| Cowl::TFileName | Constructs filenames |
| Cowl::TFileNameIterator | TFileNameIterator is used to iterate through a list of file names |
| Cowl::TFileStatus | |
| Cowl::TFixedPoint | |
| Cowl::TFuncObjProperty< T > | |
| Cowl::TFuncObjPropertyGet< T > | |
| Cowl::TFuncObjPropertyIdx< T, index > | |
| Cowl::TFuncObjPropertyIdxGet< T, index > | |
| Cowl::TFuncObjPropertyIdxPut< T, index > | |
| Cowl::TFuncObjPropertyPut< T > | |
| Cowl::TFuncObjPropertyVarPut< T > | |
| Cowl::TFuncProperty< T > | |
| Cowl::TFuncPropertyGet< T > | |
| Cowl::TFuncPropertyIdx< T, index > | |
| Cowl::TFuncPropertyIdxGet< T, index > | |
| Cowl::TFuncPropertyIdxPut< T, index > | |
| Cowl::TFuncPropertyPut< T > | |
| Cowl::TFuncPropertyVarPut< T > | |
| Cowl::TFunctorBase | Base functor class holds all of the actual data |
| Cowl::TFunctor0< owl::TColor & > | |
| Cowl::TFunctor0< owl::TColorScheme & > | |
| Cowl::TFunctor0< bool > | |
| Cowl::TFunctor0< owl::TIPtrArray< TCoolBand * > & > | |
| Cowl::TFunctor0< T & > | |
| Cowl::TFunctor0< T > | |
| Cowl::TFunctor1< TGadgetWindow *, TWindow * > | |
| Cowl::TFunctor1< T &, int > | |
| Cowl::TFunctor1< T, int > | |
| Cowl::TFunctor3< TGadget *, int, int, bool & > | |
| Cowl::TFunctor3< bool, TDecoratedFrame &, TGadgetWindow &, TAbsLocation > | |
| Cowl::TFunctorV1< const owl::TColor & > | |
| Cowl::TFunctorV1< const owl::TColorScheme & > | |
| Cowl::TFunctorV1< owl::TPalette * > | |
| Cowl::TFunctorV1< owl::TWindow * > | |
| Cowl::TFunctorV1< owl::TTooltip * > | |
| Cowl::TFunctorV1< bool > | |
| Cowl::TFunctorV1< const T & > | |
| Cowl::TFunctorV1< T > | |
| Cowl::TFunctorV2< int, const T & > | |
| Cowl::TFunctorV2< int, T > | |
| Cowl::TFunctor0< R > | Functor with 0 parameters, return R |
| Cowl::TFunctionTranslator0< R, Funct > | |
| Cowl::TMemberTranslator0< R, TCallee, TMemFunc > | |
| Cowl::TFunctor1< R, P1 > | Functor with 1 parameter, return R |
| Cowl::TFunctionTranslator1< R, P1, Funct > | |
| Cowl::TMemberTranslator1< R, P1, TCallee, TMemFunc > | |
| Cowl::TFunctor2< R, P1, P2 > | Functor with 2 parameters, return R |
| Cowl::TFunctionTranslator2< R, P1, P2, Funct > | |
| Cowl::TMemberTranslator2< R, P1, P2, TCallee, TMemFunc > | |
| Cowl::TFunctor3< R, P1, P2, P3 > | Functor with 3 parameters, return R |
| Cowl::TFunctionTranslator3< R, P1, P2, P3, Funct > | |
| Cowl::TMemberTranslator3< R, P1, P2, P3, TCallee, TMemFunc > | |
| Cowl::TFunctor4< R, P1, P2, P3, P4 > | Functor with 4 parameters, return R |
| Cowl::TFunctionTranslator4< R, P1, P2, P3, P4, Funct > | |
| Cowl::TMemberTranslator4< R, P1, P2, P3, P4, TCallee, TMemFunc > | |
| Cowl::TFunctor5< R, P1, P2, P3, P4, P5 > | Functor with 5 parameters, return R |
| Cowl::TFunctionTranslator5< R, P1, P2, P3, P4, P5, Funct > | |
| Cowl::TMemberTranslator5< R, P1, P2, P3, P4, P5, TCallee, TMemFunc > | |
| Cowl::TFunctor6< R, P1, P2, P3, P4, P5, P6 > | Functor with 6 parameters, return R |
| Cowl::TFunctionTranslator6< R, P1, P2, P3, P4, P5, P6, Funct > | |
| Cowl::TMemberTranslator6< R, P1, P2, P3, P4, P5, P6, TCallee, TMemFunc > | |
| Cowl::TFunctorV0 | Functor with 0 parameters, void return |
| Cowl::TFunctionTranslatorV0< Funct > | |
| Cowl::TMemberTranslatorV0< TCallee, TMemFunc > | |
| Cowl::TFunctorV1< P1 > | Functor with 1 parameter, void return |
| Cowl::TFunctionTranslatorV1< P1, Funct > | |
| Cowl::TMemberTranslatorV1< P1, TCallee, TMemFunc > | |
| Cowl::TFunctorV2< P1, P2 > | Functor with 2 parameters, void return |
| Cowl::TFunctionTranslatorV2< P1, P2, Funct > | |
| Cowl::TMemberTranslatorV2< P1, P2, TCallee, TMemFunc > | |
| Cowl::TFunctorV3< P1, P2, P3 > | Functor with 3 parameters, void return |
| Cowl::TFunctionTranslatorV3< P1, P2, P3, Funct > | |
| Cowl::TMemberTranslatorV3< P1, P2, P3, TCallee, TMemFunc > | |
| Cowl::TFunctorV4< P1, P2, P3, P4 > | Functor with 4 parameters, void return |
| Cowl::TFunctionTranslatorV4< P1, P2, P3, P4, Funct > | |
| Cowl::TMemberTranslatorV4< P1, P2, P3, P4, TCallee, TMemFunc > | |
| Cowl::TFunctorV5< P1, P2, P3, P4, P5 > | Functor with 5 parameters, void return |
| Cowl::TFunctionTranslatorV5< P1, P2, P3, P4, P5, Funct > | |
| Cowl::TMemberTranslatorV5< P1, P2, P3, P4, P5, TCallee, TMemFunc > | |
| Cowl::TFunctorV6< P1, P2, P3, P4, P5, P6 > | Functor with 6 parameters, void return |
| Cowl::TFunctionTranslatorV6< P1, P2, P3, P4, P5, P6, Funct > | |
| Cowl::TMemberTranslatorV6< P1, P2, P3, P4, P5, P6, TCallee, TMemFunc > | |
| Cowl::TGadget | TGadget is the base class for the following derived gadget classes: |
| Cowl::TBitmapGadget | Derived from TGadget, TBitmapGadget is a simple gadget that can display an array of bitmap images one at a time |
| Cowl::TDynamicBitmapGadget | Class will send EvEnable message to window, so you can set bitmap, using SetCheck() method of TCommandEnabler |
| Cowl::TButtonGadget | Derived from TGadget, TButtonGadget represent buttons that you can click on or off |
| Cowl::TButtonTextGadget | Derived from TButtonGadget, TButtonTextGadget represents buttons with bitmap and text, or with text only, or with bitmap only, that you can click on or off |
| Cowl::TPopupButtonGadget | |
| Cowl::TPickerGadget | |
| Cowl::TBitmapPickerGadget | |
| Cowl::TColorPickerGadget | |
| Cowl::TPopupMenuGadget | |
| Cowl::TControlGadget | TControlGadget serves as a surrogate for TControl so that you can place TControl objects such as edit controls, buttons, sliders, gauges, or third-party controls, into a gadget window |
| Cowl::TSeparatorGadget | TSeparatorGadget is a simple class you can use to create a separator between gadgets |
| Cowl::TFlatHandleGadget | A gadget that is used on the far right of a status bar to provide re-sizing grip for the host window |
| Cowl::TSizeGripGadget | TSizeGripGadget is a gadget that is used on the far right of a status bar to provide re-sizing grip for the host window |
| Cowl::TTextGadget | Derived from TGadget, TTextGadget is a text gadget object |
| Cowl::TDynamicTextGadget | Small class will send EvEnable to window, You can set text by handling EvCommandEnable message |
| Cowl::TMenuGadget | TMenuGadget is a text gadget that, when pressed, acts as a pop-up menu |
| Cowl::TModeGadget | TModeGadget is a mode-tracking text gadget class |
| Cowl::TTimeGadget | A gadget for displaying a time and/or date message |
| Cowl::TGadgetList | TGadgetList is a list of gadgets with management functions |
| Cowl::TGadgetWindow | Derived from TWindow, TGadgetWindow maintains a list of tiled gadgets for a window and lets you dynamically arrange tool bars |
| Cowl::TGdiBase | Root and abstract class for Windows object wrappers |
| Cowl::TCursor | TCursor, derived from TGdiBase, represents the GDI cursor object class |
| Cowl::TDC | TDC is the root class for GDI DC wrappers |
| Cowl::TCreatedDC | An abstract TDC class, TCreatedDC serves as the base for DCs that are created and deleted |
| Cowl::TIC | Derived from TCreatedDC, TIC is a device context (DC) class that provides a constructor for creating a DC object from explicit driver, device, and port names |
| Cowl::TMemoryDC | A device context (DC) class derived from TCreatedDC, TMemoryDC provides access to a memory DC |
| Cowl::TDibDC | A DC class that provides access to DIBs using DIBSection, WinG, or the DIB.DRV driver |
| Cowl::TPrintDC | A DC class that provides access to a printer |
| Cowl::TPreviewDCBase | TPreviewDCBase is the base class encapsulating a 'dual' device context - i.e |
| Cowl::TPrintPreviewDC | Derived from TPrintDC, TPrintPreviewDC maps printer device coordinates to logical screen coordinates |
| Cowl::TMetaFileDC | A DC class that provides access to a DC with a metafile selected into it for drawing on (into) |
| Cowl::TPaintDC | A DC class that wraps begin and end paint calls for use in an WM_PAINT response function |
| Cowl::TWindowDC | Derived from TDC, TWindowDC is a device context (DC) class that provides access to the entire area owned by a window |
| Cowl::TClientDC | A device context class derived from TWindowDC, TClientDC provides access to the client area owned by a window |
| Cocf::TOleClientDC | Derived from TClientDC, TOleClientDC is a helper class that translates between two different coordinate systems |
| Cowl::TDesktopDC | A DC class that provides access to the desktop window's client area which is the window behind all other windows |
| Cowl::TNCPaintDC | A DC class that provides access to the non-client area owned by a window |
| Cowl::TScreenDC | Derived from TWindowDC, TScreenDC is a DC class that provides direct access to the screen bitmap |
| Cowl::TDib | Pseudo-GDI object Device Independent Bitmap (DIB) class |
| Cowl::TDiBitmap | Combination of a TDib and a TBitmap |
| Cowl::TEnhMetaFilePict | TEnhMetaFilePict is a class that encapsulates the enhanced metafile |
| Cowl::TGdiObject | GdiObject is the root, pseudo-abstract base class for ObjectWindows' GDI (Graphics Device Interface) wrappers |
| Cowl::TBitmap | TBitmap is the GDI bitmap class derived from TGdiObject |
| Cowl::TBtnBitmap | TBtnBitmap is an enhanced version of TBitmap with the ability to update the face color of a bitmap to match the system setting (COLOR_BTNFACE) |
| Cowl::TDiBitmap | Combination of a TDib and a TBitmap |
| Cowl::TBrush | The GDI Brush class is derived from TGdiObject |
| Cowl::THatch8x8Brush | Derived from TBrush, THatch8x8Brush defines a small, 8x8, monochrome, configurable hatch brush |
| Cowl::TFont | TFont derived from TGdiObject provides constructors for creating font objects from explicit information or indirectly |
| Cowl::TDefaultGuiFont | Encapsulates the system font used for a specific GUI element, e.g. icon, caption, menu, message |
| Cowl::TGadgetWindowFont | Derived from TFont, TGadgetWindowFont is the default font used by TGadgetWindow |
| Cowl::TPalette | TPalette is the GDI Palette class derived from TGdiObject |
| Cowl::THalftonePalette | A halftone palette is intended for use when the stretching mode of a device context is set to HALFTONE |
| Cowl::TIdentityPalette | An identity palette is a palette where the colors and order of those colors match the physical palette |
| Cowl::TPen | TPen is derived from TGdiObject |
| Cowl::TIcon | TIcon, derived from TGdiObject, represents the GDI object icon class |
| Cowl::TMetaFilePict | TMetaFilePict is a support class used with TMetaFileDC to simplify metafile operations, such as playing into a device context (DC) or storing data on the Clipboard |
| Cowl::TRegion | TRegion, derived from TGdiObject, represents GDI abstract shapes or regions |
| Cowl::TConstArrayProperty< T, I >::TGetter | |
| Cowl::TConstObjArrayProperty< T, I >::TGetter | |
| Cowl::TGlobalAllocator | Provides class-specific operator new and operator delete that allocate from global memory |
| Cowl::THelpContext | THelpContext is a class that maintains information about a menu item id and a child control id with a help context id |
| Cowl::THelpHitInfo | |
| Cowl::THostInfoManager | (and its friend class THostInfoWindow) encapsulate the Winsock database functions gethostbyname(), gethostbyaddr(), and gethostname() |
| Cowl::TImageList | TImageList is a wrapper class for the ImageList common "control" |
| Cowl::TCursor::TInfo | |
| Cowl::TIcon::TInfo | |
| Cowl::TRegKey::TInfo | Data structure returned by QueryInfo |
| Cowl::TIPAddressBits | Also used as transfer buffer |
| Cowl::detail::TIsRepresentable< T, U, is_integer > | |
| Cowl::detail::TIsRepresentable< T, U, true > | |
| Cowl::TLangModule | International resource support: [APP]ENG.DLL - default application module |
| Cowl::TLayoutConstraint | TLayoutConstraint is a structure that defines a relationship (a layout constraint) between an edge or size of one window and an edge or size of one of the window's siblings or its parent |
| Cowl::TEdgeConstraint | TEdgeConstraint adds member functions that set edge (but not size) constraints |
| Cowl::TEdgeOrSizeConstraint | |
| Cowl::TEdgeOrHeightConstraint | |
| Cowl::TEdgeOrWidthConstraint | |
| Cowl::TGadgetWindow::TLayoutInfo | Gadget layout information used during the layout process |
| Cowl::TLayoutMetrics | When specifying the layout metrics for a window, four layout constraints are needed |
| Cocf::TLicenseKeyFactory | |
| Cowl::TDocument::TList | Document list class |
| Cowl::TListBoxData | Used to transfer the contents of a list box |
| Cowl::TLocalAllocator | Provides class-specific operator new and operator delete that allocate from local memory |
| Cowl::TLocaleString | Designed to provide support for localized registration parameters, the TLocaleString Struct defines a localizable substitute for char* strings |
| Cowl::TCriticalSection::TLock | This nested class handles locking and unlocking critical sections |
| Cowl::TStaticSync< T >::TLock | |
| Cowl::TSync::TLock | This nested class handles locking and unlocking critical sections |
| Cowl::TMRSWSection::TLock | |
| Cowl::TSemaphore::TLock | |
| Cowl::TSemaphoreSet::TLock | |
| Cowl::TMapNode< T1, T2 > | Map node |
| Cowl::TMapNode< tstring, tstring > | |
| Cowl::TMapNode< tstring, TStringMap > | |
| Cowl::TMargins | Used by the TGadgetWindow and TGadget classes, TMargins contains the measurements of the margins for the gadget |
| Cowl::TMBlockList< A > | |
| Cowl::TMBlockList< TStandardAllocator > | |
| Cowl::TBlockList | Used internally |
| Cowl::TMci | TMci is a Windows MCI (Media Control Interface) encapsulation class |
| Cowl::TMciWaveAudio | Wrapper to play .WAV files |
| Cowl::TMenu | Window menus |
| Cowl::TMenuDescr | Menu with information used to allow merging |
| Cowl::TPopupMenu | TPopupMenu creates an empty pop-up menu to add to an existing window or pop-up menu |
| Cowl::TSystemMenu | TSystemMenu creates a system menu object that then becomes the existing system menu |
| Cowl::TMMarker< A > | Managed memory stack |
| Cowl::TMMarker< TStandardAllocator > | |
| Cowl::TMarker | Provides the mark for TMemStack |
| Cowl::TMMemBlocks< A > | Managed single-size block allocator |
| Cowl::TMMemBlocks< TStandardAllocator > | |
| Cowl::TMemBlocks | Single-size block allocator |
| Cowl::TMMemStack< A > | |
| Cowl::TMMemStack< TStandardAllocator > | |
| Cowl::TMemStack | Implements mark and release style memory management using the standard allocator |
| Cowl::TModuleProc | TModuleProc is a base class that does inital binding of a function name or ordinal to the corresponding function in the given module (DLL) |
| Cowl::TModuleVersionInfo | TModuleVersionInfo provides access to a TModule's VERSIONINFO resource |
| Cowl::TMonthCalendarData | |
| Cowl::TMRSWSection | Multiple Read, Single Write section |
| Cowl::TMsgThread | TMsgThread implements basic behavior for threads that own message queues, including mutex locking for the queue |
| Cowl::TApplication | Derived from TModule and TMsgThread and virtually derived from TEventHandler, TApplication acts as an object-oriented stand-in for an application module |
| Cocf::TNoArg | |
| Cowl::TNoteTabItem | TNoteTabItem holds information about each tab in a notetab control |
| Cocf::TDocViewDispatch< WM_OWLNOTIFY >::TNotificationDispatch | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPDIALOGHELP > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPRESTOREUI > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPSTATUSTEXT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWSETTITLE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWTITLE > | |
| Cocf::TDocViewDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnInvalidate > | |
| Cocf::TDocViewDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnLinkMoniker > | |
| Cocf::TDocViewDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnLinkView > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatchBase | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< ACN_START > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< ACN_STOP > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< CBEN_BEGINEDIT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< CBEN_DELETEITEM > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< CBEN_DRAGBEGIN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< CBEN_ENDEDIT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< CBEN_GETDISPINFO > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< CBEN_INSERTITEM > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< DTN_CLOSEUP > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< DTN_DATETIMECHANGE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< DTN_DROPDOWN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< DTN_FORMAT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< DTN_FORMATQUERY > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< DTN_USERSTRING > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< DTN_WMKEYDOWN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< EN_DROPFILES > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< EN_MSGFILTER > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< EN_PROTECTED > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< EN_REQUESTRESIZE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< EN_SELCHANGE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_BEGINDRAG > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_BEGINTRACK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_DIVIDERDBLCLICK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_ENDDRAG > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_ENDTRACK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_FILTERBTNCLICK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_FILTERCHANGE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_GETDISPINFO > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_ITEMCHANGED > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_ITEMCHANGING > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_ITEMCLICK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_ITEMDBLCLICK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< HDN_TRACK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< IPN_FIELDCHANGED > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_BEGINDRAG > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_BEGINLABELEDIT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_BEGINRDRAG > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_COLUMNCLICK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_DELETEALLITEMS > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_DELETEITEM > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_ENDLABELEDIT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_GETDISPINFO > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_GETINFOTIP > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_HOTTRACK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_INSERTITEM > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_ITEMACTIVATE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_ITEMCHANGED > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_ITEMCHANGING > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_KEYDOWN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_MARQUEEBEGIN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_ODCACHEHINT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_ODFINDITEM > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_ODSTATECHANGED > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< LVN_SETDISPINFO > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< MCN_GETDAYSTATE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< MCN_SELCHANGE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< MCN_SELECT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_CHAR > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_CLICK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_CUSTOMDRAW > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_DBLCLK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_HOVER > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_KEYDOWN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_KILLFOCUS > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_NCHITTEST > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_OUTOFMEMORY > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_RCLICK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_RDBLCLK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_RELEASEDCAPTURE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_RETURN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_SETCURSOR > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_SETFOCUS > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< NM_TVSTATEIMAGECHANGING > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PGN_CALCSIZE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PGN_SCROLL > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_APPLY > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_GETOBJECT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_HELP > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_KILLACTIVE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_QUERYCANCEL > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_RESET > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_SETACTIVE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_WIZBACK > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_WIZFINISH > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< PSN_WIZNEXT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_AUTOSIZE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_BEGINDRAG > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_CHILDSIZE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_DELETEDBAND > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_DELETINGBAND > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_ENDDRAG > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_GETOBJECT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_HEIGHTCHANGE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< RBN_LAYOUTCHANGED > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TCN_GETOBJECT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TCN_KEYDOWN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TCN_SELCHANGE > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TCN_SELCHANGING > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TTN_GETDISPINFO > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TTN_POP > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TTN_SHOW > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_BEGINDRAG > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_BEGINLABELEDIT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_BEGINRDRAG > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_DELETEITEM > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_ENDLABELEDIT > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_GETDISPINFO > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_GETINFOTIP > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_ITEMEXPANDED > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_ITEMEXPANDING > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_KEYDOWN > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_SELCHANGED > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_SELCHANGING > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_SETDISPINFO > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< TVN_SINGLEEXPAND > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch< UDN_DELTAPOS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatchBase | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETBACKCOLOR > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETDISPLAYASDEFAULT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETDISPLAYNAME > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETFONT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETFORECOLOR > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETLOCALEID > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETMESSAGEREFLECT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETSCALEUNITS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETSHOWGRABHANDLES > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETSHOWHATCHING > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETSUPPORTSMNEMONICS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETTEXTALIGN > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETUIDEAD > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_GETUSERMODE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETBACKCOLOR > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETDISPLAYASDEFAULT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETDISPLAYNAME > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETFONT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETFORECOLOR > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETLOCALEID > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETMESSAGEREFLECT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETSCALEUNITS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETSHOWGRABHANDLES > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETSHOWHATCHING > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETSUPPORTSMNEMONICS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETTEXTALIGN > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETUIDEAD > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_AMBIENT_SETUSERMODE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPBORDERSPACEREQ > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPBORDERSPACESET > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPFRAMERECT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPINSMENUS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPMENUS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPPROCESSMSG > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_APPSHUTDOWN > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_CLICK > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_CUSTOMEVENT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_DBLCLICK > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_ERROREVENT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_FOCUS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_KEYDOWN > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_KEYUP > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_MOUSEDOWN > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_MOUSEMOVE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_MOUSEUP > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_PROPERTYCHANGE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_CTRLEVENT_PROPERTYREQUESTEDIT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWATTACHWINDOW > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWBORDERSPACEREQ > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWBORDERSPACESET > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWBREAKLINK > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWCLIPDATA > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWCLOSE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWDOVERB > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWDRAG > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWDROP > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWGETITEMNAME > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWGETPALETTE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWGETSCALE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWGETSITERECT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWINSMENUS > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWLOADPART > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWOPENDOC > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWPAINT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWPARTACTIVATE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWPARTINVALID > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWPARTSIZE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWPASTEOBJECT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWSAVEPART > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWSCROLL > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWSETDATA > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWSETLINK > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWSETSCALE > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWSETSITERECT > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatch< OC_VIEWSHOWTOOLS > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatchBase | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnCommit > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnDocClosed > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnDocOpened > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnIsDirty > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnIsWindow > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnRevert > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnViewClosed > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatch< vnViewOpened > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatchBase< NotificationCode, TParamType & > | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatchBase< NotificationCode, TParamType * > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatchBase< NotificationCode, TResult, NMHDR & > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatch | |
| Cowl::TDispatch< WM_OCEVENT >::TNotificationDispatchBase< NotificationCode, void > | |
| Cowl::TDispatch< WM_OWLNOTIFY >::TNotificationDispatchBase< NotificationCode, void > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatchBase< NotificationCode_, THandlerResult_, TNmParam & > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatchBase< NotificationCode_, THandlerResult_, void > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatchBase< NotificationCode_, void, TNmParam & > | |
| Cowl::TDispatch< WM_NOTIFY >::TNotificationDispatchBase< NotificationCode_, void, void > | |
| Cowl::TObjArrayIterator< T, T1 > | Iterator for TObjectContainer |
| Cocf::TObjectDescBase | Precursor to TServedObject containing object info |
| Cocf::TObjectDescriptor | |
| Cowl::TObjProperty< T > | Property container for object |
| Cocf::TOcAppFrameHost | OCF Application frame window host class. Receives window events from OcApp |
| Cocf::TOcAppFrameHostMsg | Default implementation of frame window host that uses messages |
| Cocf::TOcAppHost | OCF Application host class. Owner of & host for a TOcApp object |
| Cocf::TOcModule | |
| Cocf::TOcAutoFactory< T > | Simple factory for Automation Server |
| Cocf::TOcComFactory< T > | Simple factor for COM Servers |
| Cocf::TOcContainerHost | |
| Cocf::TOcContainerHostMsg | |
| Cocf::TOcConvertInfo | |
| Cocf::TOcDocument | OC Document class, holds parts & is a owner of views |
| Cocf::TOcDragDrop | For viewdrop & viewdrag |
| Cocf::TOcFormat | Clipboard format wrapper |
| Cocf::TOcFormatData | Used to obtain the native clipboard format data |
| Cocf::TOcFormatInfo | |
| Cocf::TOcFormatName | Clipboard format name |
| Cocf::TOcGetAccel | |
| Cocf::TOcInitInfo | |
| Cocf::TOcItemLink | Used to obtain the item name for building monikers |
| Cocf::TOcItemName | Used to obtain the item name for building monikers |
| Cocf::TOcMenuDescr | |
| Cocf::TOcMenuWidths | |
| Cocf::TOcPartChangeInfo | View/Data change info |
| Cocf::TOcPartSize | Used to obtain the size of the rectangle that encloses the selection |
| Cocf::TOcSaveLoad | Use when doing parts save and load |
| Cocf::TOcScaleFactor | |
| Cocf::TOcScaleInfo | |
| Cocf::TOcServerHost | |
| Cocf::TOcServerHostMsg | |
| Cocf::TOcSiteRect | |
| Cocf::TOcStorage | |
| Cocf::TOcStream | |
| Cocf::TOcToolBarInfo | |
| Cocf::TOcVerb | |
| Cocf::TOcViewPaint | For part adornment painting over part, & painting views |
| Cowl::TOle | Delay loading Ole32.DLL/COMPOBJ.DLL |
| Cocf::TOleAllocator | Object to initialize OLE and access memory manager |
| Cocf::TOleInit | Simple wrapper of TOleAllocator used exclusively for initializing OLE |
| Cowl::TOleAuto | Delay loading OLEAUT32.DLL/OLE2DISP.DLL |
| Cocf::TOleAutoDll | |
| Cocf::TOleFactoryAppBase< T, Auto > | Application creation/destruction callouts shared for doc/view and non-d/v |
| Cocf::TOleFactoryDocView< T, Auto > | Docview application callout implementation - supplies CreateObject function |
| Cocf::TOleFactoryNoDocView< T, Auto > | Non-docview application callout implementation, no CreateObject implemented User must either provide an implementation of CreateOleObject for app class or else reimplement this template function for the particular class |
| Cocf::TOleFactoryAuto< T > | Automated application default automation callout implementation |
| Cocf::TOleFactoryBase< T, Obj > | A template class, TOleFactoryBase<> creates callback code for ObjectWindows classes |
| Cocf::TOleFactoryBase< T, TOleFactoryDocView< T, TOleFactoryAuto< T > > > | |
| Cocf::TOleDocViewAutoFactory< T > | Factory for OWL Doc/View, automated OLE components |
| Cocf::TOleFactoryBase< T, TOleFactoryDocView< T, TOleFactoryNoAuto< T > > > | |
| Cocf::TOleDocViewFactory< T > | Factory for OWL Doc/View, non-automated OLE components |
| Cocf::TOleFactoryBase< T, TOleFactoryNoDocView< T, TOleFactoryAuto< T > > > | |
| Cocf::TOleAutoFactory< T > | Factory for OWL non-Doc/View, automated OLE components |
| Cocf::TOleFactoryBase< T, TOleFactoryNoDocView< T, TOleFactoryNoAuto< T > > > | |
| Cocf::TOleFactory< T > | Factory for OWL non-Doc/View, non-automated OLE components |
| Cocf::TOleFactoryNoAuto< T > | Non-automated application automation callout stub implementation |
| Cowl::TOOLBARTEMPLATE | Structure describing the binary layout of toolbar resources |
| CTOOLINFO | |
| Cowl::TToolInfo | TToolInfo contains information about a particular tool (a tool is either a window or an application-defined rectangular area within a window's client area) |
| CTOOLTIPTEXT | |
| Cowl::TTooltipText | TTooltipText identifies a tool for which text is to be displayed |
| Cowl::TPidl | TPidl is an item identifier list class (ITEMIDLIST) |
| Cowl::TPointerBase< T > | Smart pointer base class |
| Cowl::TAPointer< T > | Pointer to an array of type T |
| Cowl::TPointer< T > | Smart pointer to a single object. Provides member access operator -> |
| Cowl::TPointerBase< owl::TBitmap > | |
| Cowl::TPointer< owl::TBitmap > | |
| Cowl::TPointerBase< owl::TFileName > | |
| Cowl::TAPointer< owl::TFileName > | |
| Cowl::TPointerBase< owl::TRect > | |
| Cowl::TAPointer< owl::TRect > | |
| Cowl::TPointerBase< tchar > | |
| Cowl::TAPointer< tchar > | |
| Cowl::tPOINTF | Base struct for the TPointF class |
| Cowl::TPointF | TPointF is similar to TPoint, but uses floating variables rather than integers |
| Cowl::TPReadObjects | |
| Cowl::TSystem::TProcessorInfo | Encapsulates information about a processor core |
| Cowl::TProcInstance | A ProcInstance object |
| Cowl::TProfile | An instance of TProfile encapsulates a setting within a system file, often referred to as a profile or initialization file |
| Cowl::TProperty< T > | Simple type/pointer |
| Cowl::TPtrArrayIterator< T, T1 > | Iterator for Pointer Container |
| Cowl::TPWrittenObjects::TPWObj | |
| Cowl::TPWrittenObjects | |
| Cowl::TQtInfo | QuickTime atom information data structure |
| Cowl::TEdit::TRange | Represents a half-open range of positions in the edit control, e.g |
| Cowl::TRangeValidator::TRange | |
| Cowl::TRegexp | This class represents regular expressions |
| Cowl::TRegFormatHeap | Used internally to provide buffers for formating registration strings |
| Cocf::TRegisterOcxWnd | Registers an OCX window for a subsequent call to the TOleDialog::SetupWindow function |
| Cocf::TRegistrar | Application registration manager interface class |
| Cocf::TOcRegistrar | Linking & embeding version of the Registrar |
| Cowl::TRegistry | TRegistry provides high level stream and list access to the registry |
| Cowl::TRegItem | A single registration list entry |
| Cowl::TRegKey | Encapsulates a registration key in the Windows Registry |
| Cowl::TRegKeyIterator | Iterator for walking thru the subkeys of a key |
| Cowl::TRegLink | A linked structure in which each node points to a list of TRegList objects (or TRegList-derived objects) or TDocTemplate objects |
| Cowl::TDocTemplate | TDocTemplate is an abstract base class that contains document template functionality |
| Cowl::TDocTemplateT< D, V > | To register the associated document and view classes, a parameterized subclass, TDocTemplateT<D,V>, is used to construct a particular document and view, where D represents the document class and V represents the view class |
| Cowl::TRegList | A registration parameter table, composed of a list of TRegItems |
| Cowl::TRegParamList | A list of param entries for use as an intermediate between a TRegList and the actual template list used to generate the registration |
| Cowl::TRegSymbolTable | High level symbol-based registry entry manipulation |
| Cowl::TRegTemplateList | List of parameterized template strings that represent the actual entries to be registered |
| Cowl::TRegValue | Encapsulates a value-data entry within one registration key |
| Cowl::TRegValueIterator | Iterator for walking through the values of a key |
| Cowl::TResIdT< T > | TResId encapsulates a Windows resource identifier |
| Cowl::TResIdT< tchar > | |
| Cowl::TResId | |
| Cowl::TResource< T, resType > | TResource simplifies access to a resource by encapsulating the find, load, lock and free steps for accessing a resource |
| Cowl::TResource< TOOLBARTEMPLATE, RtToolbar > | |
| Cowl::TToolbarRes | |
| Cowl::TResponseTableEntry< T > | A template class, TResponseTableEntry lets you define a pattern for entries into a response table |
| Cowl::TScrollBarData | The TScrollBarData structure contains integer values that represent a range of thumb positions on the scroll bar |
| Cowl::TRegKey::TSecurityDescriptor | Encapsulates a SECURITY_DESCRIPTOR |
| Cowl::TSelectionIndexMapper< TValue > | Maps between application-specific value and a selection index, such as a radio-button group index or a list box selection |
| Cowl::TSemaphore | Base class for handle-based thread synchronization classes, TMutex, TCountedSemaphore and TEventSemaphore |
| Cowl::TCountedSemaphore | Counted semaphore. Currently Win32 only |
| Cowl::TEventSemaphore | |
| Cowl::TMutex | Mutual-exclusive semaphore |
| Cowl::TWaitableTimer | |
| Cowl::TSemaphoreSet | Semaphore object aggregator |
| Cowl::TSerializer | This class sends a block of data to another window |
| CTServedCOM | |
| Cocf::TServedObject | OLE object exposed for automated access of internal object |
| Cowl::TServiceManager | (and its friend class TServiceWindow) encapsulate the Winsock database functions getservbyname(), getservbyport(), WSAAsyncGetServByName(), and WSAAsyncGetServByPort() |
| Cowl::TArrayProperty< T, I >::TSetter | |
| Cowl::TShell | Delay loading SHELL32.DLL/SHELL.DLL |
| Cowl::TShouldDelete | |
| Cowl::TSHPath | Delay loading SHLWAPI.DLL |
| Cowl::TSHReg | Delay loading SHLWAPI.DLL |
| Cowl::TSocket | TSocket encapsulates the basic attributes of a socket |
| Cowl::TDatagramSocket | The TDatagramSocket encapsulates a Winsock datagram (non-reliable, packet-based) socket |
| Cowl::TStreamSocket | The TStreamSocket encapsulates a Winsock stream socket |
| Cowl::TSocketError | TSocketError converts Windows Sockets errors to string messages |
| Cowl::TSocketManager | A class that starts up WinSock and provides information about the system's WinSock |
| Cowl::TStatusBar::TSpacing | |
| Cowl::TSplitterIndicatorMgr | Handles the moving of the indicators |
| Cowl::TStandardAllocator | Provides class-specific operator new and operator delete that simply call the global operator new and operator delete |
| Cowl::TMBaseMemBlocks< TStandardAllocator > | |
| Cowl::TBaseMemBlocks | Used internally |
| Cowl::TMObjectArray< T, TStandardAllocator > | |
| Cowl::TTypedArray< int, int, TStandardAllocator > | |
| Cowl::TTypedArray< uint32, uint32, TStandardAllocator > | |
| Cowl::TTypedArray< LPARAM, LPARAM, TStandardAllocator > | |
| Cowl::TTypedArray< uint, uint, TStandardAllocator > | |
| Cowl::TTypedArray< TCheckListItem *, TCheckListItem *, TStandardAllocator > | |
| Cowl::TTypedArray< T, R, TStandardAllocator > | |
| Cowl::TTypedArray< TStringNode *, TStringNode *, TStandardAllocator > | |
| Cowl::TTypedArray< TPickerCell *, TPickerCell *, TStandardAllocator > | |
| Cowl::TTypedArray< T, T, TStandardAllocator > | |
| Cowl::TTypedArray< TStreamableBase *, TStreamableBase *, TStandardAllocator > | |
| Cowl::TTypedArray< TStreamableClass *, TStreamableClass *, TStandardAllocator > | |
| Cowl::TTypedArray< owl::TCheckListItem *, owl::TCheckListItem *, TStandardAllocator > | |
| Cowl::TMObjectArray< T, A > | Holds array pointers to strings |
| Cowl::TTypedArray< T, R, A > | Stores pointer to object |
| Cowl::TStaticSync< T > | TStaticSync provides a system-independent interface to build sets of classes that act somewhat like monitors, i.e., classes in which only one member function can execute at any one time regardless of which instance it is being called on |
| Cowl::TStream | An abstract base class, TStream provides links between streams and documents, views, and document files |
| Cowl::TInStream | Derived from TStream and istream, TInStream is a base class used to define input streams for documents |
| Cowl::TOutStream | Derived from TStream and ostream, TOutStream is a base class used to create output storage streams for a document |
| Cowl::TStreamableBase | Classes that inherit from TStreamableBase are known as streamable classes (their objects can be written to and read from streams) |
| Cowl::TDocManager | TDocManager creates a document manager object that manages the list of current documents and registered templates, handles standard file menu commands, and displays the user-interface for file and view selection boxes |
| Cowl::TDocTemplate | TDocTemplate is an abstract base class that contains document template functionality |
| Cowl::TDocument | An abstract base class, TDocument is the base class for all document objects and serves as an interface between the document, its views, and the document manager (TDocManager class) |
| Cocf::TStorageDocument | |
| Cocf::TOleDocument | Derived from TStorageDocument, TOleDocument implements the document half of the Doc/View pair |
| Cowl::TFileDocument | Derived from TDocument, TFileDocument opens and closes views and provides stream support for views |
| Cowl::TModule | ObjectWindows dynamic-link libraries (DLLs) construct an instance of TModule, which acts as an object-oriented stand-in for the library (DLL) module |
| Cowl::TApplication | Derived from TModule and TMsgThread and virtually derived from TEventHandler, TApplication acts as an object-oriented stand-in for an application module |
| Cowl::THtmlHelpDll | Wrapper for the HHCTRL.OCX itself |
| Cowl::TMailer | The MAPI DLL (MAPI [32].DLL) |
| Cowl::TRichEditModule | Wrapper object which loads the DLL providing the implementation of the RichEdit control |
| Cowl::TThemeModule | This singleton encapsulates the "uxtheme.dll" module |
| Cowl::TWinSockDll | The WinSock DLL (WINSOCK.DLL) |
| Cowl::TPrinter | TPrinter is an encapsulation around the Windows printer device interface, and represents the physical printer device |
| Cowl::TPrintout | TPrintout represents the physical printed document that is to sent to a printer to be printed |
| Cowl::TRichEditPrintout | TRichEditPrintout encapsulates the information to print/preview data from a rich edit control |
| Cowl::TScroller | Class TScroller implements the actual scroller object |
| Cowl::TFlatScroller | Class TFlatScroller implements the actual scroller object |
| Cowl::TStreamable | |
| Cowl::TValidator | A streamable class, TValidator defines an abstract data validation object |
| Cowl::TFilterValidator | A streamable class, TFilterValidator checks an input field as the user types into it |
| Cowl::TRangeValidator | Determines whether the data typed by a user falls within a designated range of integers |
| Cowl::TLookupValidator | A streamable class, TLookupValidator compares the string typed by a user with a list of acceptable values |
| Cowl::TStringLookupValidator | Derived from TLookupValidator, TStringLookupValidator is a streamable class |
| Cowl::TPXPictureValidator | TPXPictureValidator objects compare user input with a picture of a data format to determine the validity of entered data |
| Cowl::TView | Abstract base class for view access from document |
| Cowl::TWindow | TWindow, derived from TEventHandler and TStreamableBase, provides window-specific behavior and encapsulates many functions that control window behavior and specify window creation and registration attributes |
| Cowl::TStreamableTypes | |
| Cowl::TStreamer | Provides a base class for all streamable objects |
| Cowl::TNewStreamer | |
| Cowl::TOldStreamer | Provides a base class for all streamable objects |
| Cowl::TString | Reference to reference counted string object TUString Lightweight reference object consisting of a pointer to actual object Facilitates copying and assignment with minimal string reallocations |
| Cocf::TAutoString | Based on reference counted TString with added automation functionality |
| Cowl::TSync | TSync provides a system-independent interface to build classes that act like monitors, i.e., classes in which only one member can execute on a particular instance at any one time |
| Cowl::TSysStr | System string (BSTR) encapsulation |
| Cowl::TSystem | Provides information on OS relevant information |
| Cowl::TSystemMessage | |
| Cowl::TTernaryNode< T, T1 > | |
| Cowl::TTernaryTree< T, T1 > | |
| Cowl::TTheme | Encapsulates a theme handle |
| Cowl::TThemePart | Encapsulates a themed part |
| CTTHITTESTINFO | |
| Cowl::TTooltipHitTestInfo | TTooltipHitTestInfo is a thin [very thin] wrapper around the TTHITTESTINFO structure, used to determined whether a point is within the bounding rectangle of a particular tool |
| Cowl::TThread | TThread provides a system-independent interface to threads |
| Cowl::TTime | Time functions and characteristics |
| Cowl::TTmpBufferBase | Static temporary fixed buffer, provides fast temporary buffer, for use in functions |
| Cowl::TTmpBuffer< T > | |
| Cowl::TToolbarBldr | |
| Cowl::TTransferBufferBinder< TControlType > | Provides a customization hook for binding and creating controls |
| Cowl::TTransferBufferBinder< TEdit > | Binder for TEdit; restricts the possible field types to character array or tstring |
| Cowl::TTransferBufferBinder< TMemComboBox > | Binder for TMemComboBox; restricts the possible field types to character array, tstring or TComboBoxData |
| Cowl::TTransferBufferBinder< TStatic > | Binder for TStatic; restricts the possible field types to character array or tstring |
| Cowl::TTransferBufferBinderImplementation< TControlType, TFieldType > | Generic binder implementation; restricts the field type for the given control type |
| Cowl::TTransferBufferBinderImplementation< TCheckBox, WORD > | |
| Cowl::TTransferBufferBinder< TCheckBox > | Binder for TCheckBox; restricts the field type to WORD (uint16) |
| Cowl::TTransferBufferBinderImplementation< TCheckList, TCheckListData > | |
| Cowl::TTransferBufferBinder< TCheckList > | Binder for TCheckList; restricts the field type to TCheckListData |
| Cowl::TTransferBufferBinderImplementation< TComboBox, TComboBoxData > | |
| Cowl::TTransferBufferBinder< TComboBox > | Binder for TComboBox; restricts the field type to TComboBoxData |
| Cowl::TTransferBufferBinderImplementation< TComboBoxEx, TComboBoxExData > | |
| Cowl::TTransferBufferBinder< TComboBoxEx > | Binder for TComboBoxEx; restricts the field type to TComboBoxExData |
| Cowl::TTransferBufferBinderImplementation< TDateTimePicker, TDateTimePickerData > | |
| Cowl::TTransferBufferBinder< TDateTimePicker > | Binder for TDateTimePicker; restricts the field type to TDateTimePickerData |
| Cowl::TTransferBufferBinderImplementation< THotKey, uint16 > | |
| Cowl::TTransferBufferBinder< THotKey > | Binder for THotKey; restricts the field type to uint16 |
| Cowl::TTransferBufferBinderImplementation< TIPAddress, TIPAddressBits > | |
| Cowl::TTransferBufferBinder< TIPAddress > | Binder for TIPAddress; restricts the field type to TIPAddressBits |
| Cowl::TTransferBufferBinderImplementation< TListBox, TListBoxData > | |
| Cowl::TTransferBufferBinder< TListBox > | Binder for TListBox; restricts the field type to TListBoxData |
| Cowl::TTransferBufferBinderImplementation< TMonthCalendar, TMonthCalendarData > | |
| Cowl::TTransferBufferBinder< TMonthCalendar > | Binder for TMonthCalendar; restricts the field type to TMonthCalendarData |
| Cowl::TTransferBufferBinderImplementation< TRadioButton, WORD > | |
| Cowl::TTransferBufferBinder< TRadioButton > | Binder for TRadioButton; restricts the field type to WORD (uint16) |
| Cowl::TTransferBufferBinderImplementation< TScrollBar, TScrollBarData > | |
| Cowl::TTransferBufferBinder< TScrollBar > | Binder for TScrollBar; restricts the field type to TScrollBarData |
| Cowl::TTransferBufferBinderImplementation< TSlider, TScrollBarData > | |
| Cowl::TTransferBufferBinder< TSlider > | Binder for TSlider; restricts the field type to TScrollBarData |
| Cowl::detail::TTransferCheckBoxData | |
| Cowl::detail::TTransferCheckListData | |
| Cowl::detail::TTransferComboBoxData | |
| Cowl::detail::TTransferComboBoxExData | |
| Cowl::detail::TTransferDateTimePickerData | |
| Cowl::detail::TTransferDlgItemText | |
| Cowl::detail::TTransferEditData | |
| Cowl::TTransferFormat | Contains stream formatting parameters for use with TransferDlgItemText |
| Cowl::detail::TTransferHotKeyData | |
| Cowl::TTransferInfo | Used to pass information to transfer functions |
| Cowl::detail::TTransferIPAddressData | |
| Cowl::detail::TTransferListBoxData | |
| Cowl::detail::TTransferMonthCalendarData | |
| Cowl::detail::TTransferRadioButtonData | |
| Cowl::detail::TTransferScrollBarData | |
| Cowl::detail::TTransferSliderData | |
| Cowl::detail::TTransferStaticData | |
| Cowl::TTreeNode | Use this class to navigate the TTreeViewCtrl |
| Cowl::TTvComparator | Base class for comparing tree nodes |
| Cocf::TTypeConvert< T, B > | |
| Cowl::TUIBorder | Assists in drawing borders of many styles |
| Cowl::TUIFace | TUIFace assists in painting UI elements in various states |
| Cowl::TUIHandle | Assists in drawing user manupulators for on-screen objects |
| Cowl::TUIHelper | Wrapper for misc. Win4 USER functions |
| Cowl::TUIMetric | TUIMetric encapsulates the GetSystemMetric() API |
| Cowl::TUIPart | Encapsulates the DrawFrameControl 32-bit API |
| Cocf::TUnknown | Standard implementation of a controlling IUnknown for an object, to be inherited with other COM interfaces into an implementation class whose IUnknown implementation delegates to TUnknown::Outer |
| Cocf::TOcApp | OCF Application class |
| Cocf::TOcControlEvent | OC Control Event class for standard control events |
| Cocf::TOcDataProvider | Data Provider object for a container document |
| Cocf::TOcLinkView | Link Viewer object for a server document |
| Cocf::TOcPart | OC part class represents an embeded or linked part in a document |
| Cocf::TOcView | The TOcView partner is a container (viewer) of a given (server/client) document |
| Cowl::TRegistry::TUnregParams | |
| Cowl::TUser | Delay loading USER :), just for some memory/resource check programs |
| Cowl::TUString | Privately used by TString to manage string pointers This is a reference counted union of various string representatons Constructors/destructors are private to enforce reference count model Create functions are used to facilitate rapid allocation schemes Null pointers are never stored; instead a static null object is ref'd |
| Cowl::TVersion | Delay loading VERSION.DLL |
| CTVHITTESTINFO | |
| Cowl::TTvHitTestInfo | A TTreeViewCtrl notification for hit-testing |
| CTVITEM | |
| Cowl::TTvItem | Used to represent the data to be stored in the TTreeViewCtrl |
| Cowl::TVoidPointer | |
| Cowl::TWaitCursor | TWaitCursor is a simple class used to display a wait cursor |
| Cowl::TWindowAttr | Holds TWindow attributes set during construction of a window |
| Cowl::TWindowClassName | Type-safe encapsulation of a Windows class name, a union between ATOM and LPCTSTR |
| Cowl::TWinMM | Delay loading WINMM.DLL |
| Cowl::TWinSock | TWinSock is an alias for an instance of the TDllLoader template which ensures the underlying DLL is loaded and available |
| Cowl::TXEndSession | TXEndSession is thrown from TWindow's handler for WM_ENDSESSION |
| CUDACCEL | |
| Cowl::TUDAccel | TUDAccel is a very thin wrapper for the UDACCEL structure which contains information about updown accelarators |
| CVarType< T > | |
| CVarType< bool > | |
| CVarType< char > | |
| CVarType< double > | |
| CVarType< float > | |
| CVarType< int > | |
| CVarType< long > | |
| CVarType< short > | |
| CVarType< unsigned char > | |
| CVarType< unsigned int > | |
| CVarType< unsigned long > | |
| CVarType< unsigned short > | |
| CWSAData | |
| Cowl::TSocketInfo | TSocketInfo encapsulates the structure that contains details of the Windows Socket implementation |
1.18.0