OWLNext    7.0
Borland's Object Windows Library for the modern age
Loading...
Searching...
No Matches
tooltip.h
Go to the documentation of this file.
1//----------------------------------------------------------------------------
2// ObjectWindows
3// Copyright (c) 1995, 1996 by Borland International, All Rights Reserved
4//
5/// \file
6/// Definition of the TTooltip class and helper objects
7//----------------------------------------------------------------------------
8#if !defined(OWL_TOOLTIP_H)
9#define OWL_TOOLTIP_H
10
11#include <owl/private/defs.h>
12#if defined(BI_HAS_PRAGMA_ONCE)
13# pragma once
14#endif
15
16#include <owl/defs.h>
17#include <owl/commctrl.h>
18
19
20namespace owl {
21
22#include <owl/preclass.h>
23
24class _OWLCLASS TFont;
25class _OWLCLASS TTooltip;
26
27//
28/// \class TToolInfo
29// ~~~~~ ~~~~~~~~~
30/// TToolInfo contains information about a particular tool (a tool is
31/// either a window or an application-defined rectangular area within
32/// a window's client area). For example, it contains the text
33/// to be displayed in the tooltip window.
34//
35class _OWLCLASS TToolInfo : public TOOLINFO {
36 public:
37
38 // Default constructor of TToolInfo
39 //
40 TToolInfo(bool allocCache = false);
41
42 // Constructor for a tooltip associated with a rectangular area
43 // within a window's client area. The 'window' receives
44 // 'TTN_NEEDTEXT' notifications if 'txt' is not provided.
45 //
46 TToolInfo(HWND window, const TRect& rect, uint toolId,
48
49 // String overload
50 //
51 TToolInfo(HWND window, const TRect& rect, uint toolId, const tstring& txt);
52
53 // Constructor for a tooltip associated with a rectangular area
54 // within a window's client area. The 'txtRes' specifies the ID
55 // of the string to be used by the tooltip window.
56 //
57 TToolInfo(HWND window, const TRect&, uint toolId,
59
60 // Constructor for tool implemented as windows (eg. child/controls).
61 // 'parent' receives the 'TTN_NEEDTEXT' notification in case where
62 // the default LPTSTR_TEXTCALLBACK is used for the 'txt' parameter.
63 //
66
67 // String overload
68 //
69 TToolInfo(HWND parent, HWND toolHwnd, const tstring& txt);
70
71 // Constructor for tool implemented as windows (eg. child/controls).
72 // 'resId' identifies the resource ID of the string to be used by
73 // the tooltip window.
74 //
76
77 /// \name Set data members of the TOOLINFO structure which identify each tool
78 /// @{
79 void SetToolInfo(HWND window, uint toolId, const TRect& rc);
80 void SetToolInfo(HWND window, uint toolId);
81 void SetToolInfo(HWND toolHwnd, HWND parent);
82 /// @}
83
84 /// \name Set the text associated with a tooltip and the tool rectangles
85 /// @{
86 void SetText(int resId, HINSTANCE hinstance);
87 void SetText(LPCTSTR text, bool copy = true);
88 void SetText(const tstring& text) {SetText(text.c_str(), true);}
89 void SetRect(const TRect& rect);
90 /// @}
91
92 //
93 // Set flag: TTF_SUBCLASS,
94 // use this for controls in Modal Dialog only
95 //
96 void EnableSubclassing(bool enable = true);
97
98 // Helper routine which returns the 'HWND'/rect associated with a
99 // particular tool.
100 //
101 HWND GetToolWindow() const;
102 void GetToolRect(TRect& rect) const;
103
104 // Helper routine to help determine whether a particular
105 // location is pertinent to a tool
106 //
107 bool IsPointInTool(HWND win, const TPoint& pt) const;
108
109 // Copy ctr & assignment operator
110 //
111 TToolInfo(const TToolInfo&);
113
114 // Checks whether two TToolInfo structures refer to the same tool
115 //
116 bool operator==(const TToolInfo& ti) const;
117
118 // Return/clear cached text
119 //
120 LPCTSTR GetCacheText() const;
121 void FlushCacheText();
122
123 private:
124 TAPointer<tchar> CacheText;
125};
126
127//
128/// \class TTooltipHitTestInfo
129// ~~~~~ ~~~~~~~~~~~~~~~~~~~
130/// TTooltipHitTestInfo is a thin [very thin] wrapper around
131/// the TTHITTESTINFO structure, used to determined whether a
132/// point is within the bounding rectangle of a particular tool.
133/// It's a place-holder for future ObjectWindows enhancements to
134/// tooltip hit-testing.
135//
136class _OWLCLASS TTooltipHitTestInfo : public TTHITTESTINFO {
137};
138
139//
140/// \class TTooltipEnabler
141// ~~~~~ ~~~~~~~~~~~~~~~
142/// TTooltipEnabler is the object forwarded along the command-chain to
143/// retrieve the tip text of a tool. The object is not a 'true' command
144/// enabler [i.e. invoking SetCheck or Enable do not modify the state of the
145/// command associated with the tool]; however, by using the 'CommandEnabler'
146/// setup retrieving the text of tools, the potential of the commands are
147/// given first crack at customizing the text.
148//
150 public:
152
153 // Override member functions of TCommandEnabler
154 //
155 virtual void SetText(LPCTSTR text);
156 virtual void SetCheck(int check);
157
158 void SetText(const tstring& text) {SetText(text.c_str());}
159
161
162 /// Reference to structure accompanying a notification requesting
163 /// for the text of a particular tool.
164 //
165 TTooltipText& TipText;
166};
167
168//
169/// \class TTooltip
170// ~~~~~ ~~~~~~~~
171/// TTooltip encapsulates a tooltip window - i.e. a small popup window
172/// that displays a single line of descriptive test giving the purpose
173/// of the item underneath the current cursor location.
174//
176 public:
177 TTooltip(TWindow* parent, bool alwaysTip = true, TModule* module = nullptr);
178
179 //
180 /// Constructor that allows wfAutoCreate to be passed as an argument, so that the tooltip
181 /// is automatically created when the parent is.
182 ///
183 /// No other flags are supported and will cause an assertion in diagnostics builds.
184 /// The tooltip is initialized with the default style TTS_ALWAYSTIP, meaning that the tooltip
185 /// will be active regardless of whether its parent is active or inactive. You can override the
186 /// tooltip styles using ModifyStyle and MofifyExStyle.
187 //
188 TTooltip(TWindow* parent, TWindowFlag, TModule* module = nullptr);
189
190 TTooltip(HWND hWnd, TModule* module = nullptr);
191
192 ~TTooltip();
193
194 //
195 /// Factory for TTooltip
196 /// If the given parent has a valid handle (IsWindow), i.e. has itself already been created,
197 /// then the underlying tool-tip is created immediately by calling Create. Otherwise, the flag
198 /// wfAutoCreate is set, so that the tool-tip is created when the parent is.
199 //
200 static TTooltip* Make(TWindow* parent, bool alwaysTip = true, TModule* = nullptr);
201
202 /// Set state of tooltip
203 //
204 void Activate(bool activate = true);
205
206 // Add/remove/enumerate tools
207 //
208 bool AddTool(const TToolInfo&);
209 void DeleteTool(const TToolInfo&);
210 bool EnumTools(uint index, TToolInfo&) const;
211
212 //
213 /// Adds a tip for the given control.
214 //
215 bool AddTool(HWND ctrl, const tstring& tip, bool enableSubclassing = true);
216
217 //
218 /// Adds a tip for the control identified by the given identifier in the given tool window.
219 //
220 bool AddTool(HWND toolWnd, int ctrlId, const tstring& tip, bool enableSubclassing = true)
221 {return AddTool(::GetDlgItem(toolWnd, ctrlId), tip, enableSubclassing);}
222
223 //
224 /// Adds a tip for the given control.
225 /// The tip is given as a resource string id.
226 //
227 bool AddTool(HWND ctrl, int tipResId, TModule* m = nullptr, bool enableSubclassing = true);
228
229 //
230 /// Adds a tip for the control identified by the given identifier in the given tool window.
231 /// The tip is given as a resource string id.
232 //
233 bool AddTool(HWND toolWnd, int ctrlId, int tipResId, TModule* m = nullptr, bool enableSubclassing = true)
234 {return AddTool(::GetDlgItem(toolWnd, ctrlId), tipResId, m, enableSubclassing);}
235
236 //
237 /// Adds a tip for the given area in the given tool window.
238 /// The tip area (tool) is identified by the given tool ID.
239 //
240 bool AddTool(HWND toolWnd, const TRect& tipArea, uint toolId, const tstring& tip, bool enableSubclassing = true);
241
242 //
243 /// Adds a tip for the given area in the given tool window.
244 /// The tip area (tool) is identified by the given tool ID.
245 /// The tip is given as a string resource id.
246 //
247 bool AddTool(HWND toolWnd, const TRect& tipArea, uint toolId, int tipResId, TModule* m = nullptr, bool enableSubclassing = true);
248
249 // Update/retrive attribute of tools
250 //
251 bool GetCurrentTool(TToolInfo&) const;
252 void GetToolText(TToolInfo&) const;
253 uint GetToolCount() const;
254 bool GetToolInfo(TToolInfo&) const;
255 void SetToolInfo(const TToolInfo&);
256 void UpdateTipText(const TToolInfo&);
257
258 //
259 /// Updates the tip for the given control.
260 //
261 void UpdateTipText(HWND ctrl, const tstring& tip)
262 { UpdateTipText({::GetParent(ctrl), ctrl, tip}); }
263
264 //
265 /// Updates the tip for the control identified by the given identifier in the given tool window.
266 //
268 { UpdateTipText({toolWnd, {}, ctrlId, tip}); }
269
270 //
271 /// Updates the tip for the given control.
272 /// The tip is given as a resource string id.
273 //
274 void UpdateTipText(HWND ctrl, int tipResId, TModule* m = nullptr)
275 { UpdateTipText({::GetParent(ctrl), ctrl, tipResId, m ? m->GetHandle() : GetModule() ? GetModule()->GetHandle() : nullptr}); }
276
277 //
278 /// Updates the tip for the control identified by the given identifier in the given tool window.
279 /// The tip is given as a resource string id.
280 //
282 { UpdateTipText({toolWnd, {}, ctrlId, tipResId, m ? m->GetHandle() : GetModule() ? GetModule()->GetHandle() : nullptr}); }
283
284 bool HitTest(TTooltipHitTestInfo&) const;
285 void NewToolRect(const TToolInfo&);
286 void RelayEvent(MSG&);
287
288 // New IE messages
289 //
290 void GetMargins(int& left, int& top, int& right, int& bottom) const; // Version 4.70
291 void SetMargins(int left, int top, int right, int bottom); // Version 4.70
292
293 void SetDelayTime(uint flag, int delay); // Version 4.70
294 int GetDelayTime(uint flag) const; // Version 4.70
295
296 TResult GetMaxTipWidth() const; // Version 4.70
297 void SetMaxTipWidth(int width); // Version 4.70
298
299 TColor GetBkColor() const;
300 void SetBkColor(const TColor& clr);
301
302 TColor GetTextColor() const;
303 void SetTextColor(const TColor& clr);
304
305 void HideTip();
306 void TrackActivate(const TToolInfo& info, bool activate = true); // Version 4.70.
307 void TrackPosition(const TPoint& pos);
308 void Update();
309
310 protected:
311 // Override TWindow virtual member functions
312 //
313 virtual auto GetWindowClassName() -> TWindowClassName;
314
315 private:
316 // Hidden to prevent accidental copying or assignment
317 //
318 TTooltip(const TTooltip&);
320
321
322};
323
324#include <owl/posclass.h>
325
326
327//----------------------------------------------------------------------------
328// Inline implementation
329//
330
331//
332/// Sets the text of this tool by providing a string resource identifier and the
333/// handle of the instance containing that resource.
334//
340
341//
342/// Sets the bounding rectangle of the tool. The coordinates are relative to the
343/// upper-left corner of the client area of the window.
344/// \note This flag is only valid if the tool is a rectangle within the window and
345/// not a control parented to the window.
346//
347inline void TToolInfo::SetRect(const TRect& rc)
348{
349 rect = rc;
350}
351
352//
353/// Enable Subclassing have to be called for Dialog controls
354//
356{
358}
359
360//
361/// If the IDs of two tools (or the Window Handles of two tools
362/// for cases when 'uFlags & TTF_IDISHWND') are similar and the
363/// handle of the window containing them matches, we'll infer that
364/// the structures are referring to the same tool.
365//
366inline bool TToolInfo::operator==(const TToolInfo& ti) const
367{
368 return (uId == ti.uId && hwnd == ti.hwnd) ? true : false;
369}
370
371//
372//
373//
374inline LPCTSTR
376{
377 return (LPTSTR)(CONST_CAST(TToolInfo*, this)->CacheText);
378}
379
380//
381//
382//
383inline void
385{
386 CacheText = 0;
387}
388
389//
390/// Activates or deactivates the tooltip control. If 'activate' is true,
391/// the tooltip control is activated, If it is false the tooltip control
392/// is deactivated.
393//
398
399//
400/// Registers a tool with the tooltip control.
401/// The given TToolInfo must have been initialized with the information needed for the tooltip
402/// control to display tip text for the tool.
403/// \note Encapsulates the TTM_ADDTOOL message in the Windows API.
404/// \sa https://docs.microsoft.com/en-us/windows/win32/controls/ttm-addtool
405//
406inline bool TTooltip::AddTool(const TToolInfo& ti)
407{
408 return SendMessage(TTM_ADDTOOL, 0, TParam2(&ti)) != 0;
409}
410
411//
412/// Removes a tool from the tooltip control. You must invoke the
413/// 'SetToolHandle' or 'SetToolId' method of TToolInfo to identify
414/// the tool to remove. [i.e. the 'hwnd' or 'uId' members of the
415/// TToolInfo must identify the tool].
416//
418{
420}
421
422//
423/// Retrieves the information that the tooltip control maintains about the specified
424/// tool. Returns true if successul or false otherwise.
425/// \note The index is zero-based and the TToolInfo structure receives the
426/// information about the tool.
427//
428inline bool TTooltip::EnumTools(uint index, TToolInfo& ti) const
429{
430 return CONST_CAST(TTooltip*, this)->SendMessage(TTM_ENUMTOOLS,
431 index, TParam2(&ti)) != 0;
432}
433
434//
435/// Retrieves information about the current tool. The 'TToolInfo'
436/// parameter receives the information. Returns true if successful or
437/// false otherwise.
438//
440{
441 return CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETCURRENTTOOL,
442 0, TParam2(&ti)) != 0;
443}
444
445//
446/// Retrieves the text associated with the specified tool. You must
447/// invoke the 'SetToolHandle' or 'SetToolId' method of TToolInfo to
448/// identify the tool. [i.e. the 'hwnd' or 'uId' members of the
449/// TToolInfo must identify the tool].
450//
452{
453 CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETTEXT, 0, TParam2(&ti));
454}
455
456//
457/// Returns the number of tools currently registered with the tooltip control.
458//
460{
461 return (uint)CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETTOOLCOUNT);
462}
463
464//
465/// Retrieves the information that the tooltip control maintains about
466/// a tool. You must invoke the 'SetToolHandle' or 'SetToolId' method
467/// of TToolInfo to identify the tool. [i.e. the 'hwnd' or 'uId' members
468/// of the TToolInfo must identify the tool].
469//
471{
472 return CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETTOOLINFO, 0,
473 TParam2(&ti)) != 0;
474}
475
476//
477/// Sets the information that the tooltip control maintains for a
478/// particular tool. You must invoke the 'SetToolHandle' or
479/// 'SetToolId' method of TToolInfo to identify the tool.
480/// [i.e. the 'hwnd' or 'uId' members of the TToolInfo must
481/// identify the tool].
482//
484{
486}
487
488//
489/// Updates the tip for the given tool.
490/// The given TToolInfo must have been initialized to identify the tool to update.
491/// \note Encapsulates the TTM_UPDATETIPTEXT message in the Windows API.
492/// \sa https://docs.microsoft.com/en-us/windows/win32/controls/ttm-updatetiptext
493//
498
499//
500/// Determines whether a tool is within a specified point. The method
501/// also retrieves information about the tool if one is identified at
502/// that location. Returns true if a tool if found at the location or
503/// false otherwise.
504//
506{
507 return CONST_CAST(TTooltip*, this)->SendMessage(TTM_HITTEST, 0,
508 TParam2(&ttHTInfo)) != 0;
509}
510
511//
512/// Updates the bounding rectangle of a tool. You must invoke the 'SetToolId'
513/// method of TToolInfo to identify the tool. [i.e. the 'uId' member
514/// of the TToolInfo must identify the tool].
515//
517{
519}
520
521//
522/// Passes a mouse message to the tooltip control for processing.
523//
528
529//
530/// Sets the initial, reshow, and autopopup durations for a tooltip control. The
531/// 'flag' parameter can be one of the following:
532/// - \c \b TTDT_AUTOMATIC: Automatically calculates the initial, reshow, and autopopup
533/// duration based on 'delay'.
534/// - \c \b TTDT_AUTOPOP: Sets the length of time before the tooltip window is hidden if the
535/// cursor remains:
536///
537/// stationary in the tool's bounding rectangle
538///
539/// after the tooltip window has disappeared.
540/// - \c \b TTDT_INITIAL: Sets the length of time that the cursor must remain stationary
541/// within the bounding rectangle before the tooltip window is displayed.
542/// - \c \b TTDT_RESHOW: Sets the length of time before subsequent tooltip windows are
543/// displayed when the cursor is moved from one tool to another.
544///
545/// \note The 'delay' duration is in milliseconds.
546//
551
552// Version 4.70
554{
555 return static_cast<int>(CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETDELAYTIME,flag));
556}
557
558// Version 4.70
559inline void TTooltip::GetMargins(int& left, int& top, int& right, int& bottom) const
560{
561 TRect rec;
562 CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETMARGIN,0,TParam2(&rec));
563 left = rec.left;
564 top = rec.top;
565 right = rec.right;
566 bottom = rec.bottom;
567}
568
569// Version 4.70
570inline void TTooltip::SetMargins(int left, int top, int right, int bottom)
571{
572 TRect rec(left,top,right,bottom);
574}
575
576// Version 4.70
578{
579 return CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETMAXTIPWIDTH);
580}
581
582// Version 4.70
583inline void TTooltip::SetMaxTipWidth(int width)
584{
586}
587
588// Version 4.70
590{
591 return static_cast<COLORREF>(CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETTIPBKCOLOR));
592}
593
594// Version 4.70
599
600// Version 4.70
602{
603 return static_cast<COLORREF>(CONST_CAST(TTooltip*, this)->SendMessage(TTM_GETTIPTEXTCOLOR));
604}
605
606// Version 4.70
611
612// Version 4.70
613inline void TTooltip::HideTip()
614{
616}
617
618// Version 4.70
623
624// Version 4.70
629
630// Version 4.71
631inline void TTooltip::Update()
632{
634}
635
636
637
638} // OWL namespace
639
640
641#endif // OWL_TOOLTIP_H
Class wrapper for management of color values.
Definition color.h:245
Base class for an extensible interface for auto enabling/disabling of commands (menu items,...
Definition window.h:209
TControl unifies its derived control classes, such as TScrollBar, TControlGadget, and TButton.
Definition control.h:38
ObjectWindows dynamic-link libraries (DLLs) construct an instance of TModule, which acts as an object...
Definition module.h:75
TPoint is a support class, derived from tagPOINT.
Definition geometry.h:87
TRect is a mathematical class derived from tagRect.
Definition geometry.h:308
TToolInfo contains information about a particular tool (a tool is either a window or an application-d...
Definition tooltip.h:35
void EnableSubclassing(bool enable=true)
Enable Subclassing have to be called for Dialog controls.
Definition tooltip.h:355
void SetRect(const TRect &rect)
Sets the bounding rectangle of the tool.
Definition tooltip.h:347
bool operator==(const TToolInfo &ti) const
If the IDs of two tools (or the Window Handles of two tools for cases when 'uFlags & TTF_IDISHWND') a...
Definition tooltip.h:366
void SetText(const tstring &text)
Definition tooltip.h:88
void SetText(int resId, HINSTANCE hinstance)
Sets the text of this tool by providing a string resource identifier and the handle of the instance c...
Definition tooltip.h:335
LPCTSTR GetCacheText() const
Definition tooltip.h:375
void FlushCacheText()
Definition tooltip.h:384
TTooltipEnabler is the object forwarded along the command-chain to retrieve the tip text of a tool.
Definition tooltip.h:149
void SetText(const tstring &text)
Definition tooltip.h:158
TTooltipHitTestInfo is a thin [very thin] wrapper around the TTHITTESTINFO structure,...
Definition tooltip.h:136
TTooltip encapsulates a tooltip window - i.e.
Definition tooltip.h:175
void SetDelayTime(uint flag, int delay)
Sets the initial, reshow, and autopopup durations for a tooltip control.
Definition tooltip.h:547
void UpdateTipText(HWND toolWnd, uint ctrlId, const tstring &tip)
Updates the tip for the control identified by the given identifier in the given tool window.
Definition tooltip.h:267
void SetTextColor(const TColor &clr)
Definition tooltip.h:607
void GetMargins(int &left, int &top, int &right, int &bottom) const
Definition tooltip.h:559
void SetMargins(int left, int top, int right, int bottom)
Definition tooltip.h:570
void HideTip()
Definition tooltip.h:613
void UpdateTipText(HWND ctrl, int tipResId, TModule *m=nullptr)
Updates the tip for the given control.
Definition tooltip.h:274
void UpdateTipText(const TToolInfo &)
Updates the tip for the given tool.
Definition tooltip.h:494
bool AddTool(HWND toolWnd, int ctrlId, int tipResId, TModule *m=nullptr, bool enableSubclassing=true)
Adds a tip for the control identified by the given identifier in the given tool window.
Definition tooltip.h:233
uint GetToolCount() const
Returns the number of tools currently registered with the tooltip control.
Definition tooltip.h:459
bool EnumTools(uint index, TToolInfo &) const
Retrieves the information that the tooltip control maintains about the specified tool.
Definition tooltip.h:428
bool AddTool(const TToolInfo &)
Registers a tool with the tooltip control.
Definition tooltip.h:406
int GetDelayTime(uint flag) const
Definition tooltip.h:553
bool GetCurrentTool(TToolInfo &) const
Retrieves information about the current tool.
Definition tooltip.h:439
void RelayEvent(MSG &)
Passes a mouse message to the tooltip control for processing.
Definition tooltip.h:524
void GetToolText(TToolInfo &) const
Retrieves the text associated with the specified tool.
Definition tooltip.h:451
TResult GetMaxTipWidth() const
Definition tooltip.h:577
void UpdateTipText(HWND ctrl, const tstring &tip)
Updates the tip for the given control.
Definition tooltip.h:261
void NewToolRect(const TToolInfo &)
Updates the bounding rectangle of a tool.
Definition tooltip.h:516
bool HitTest(TTooltipHitTestInfo &) const
Determines whether a tool is within a specified point.
Definition tooltip.h:505
void SetToolInfo(const TToolInfo &)
Sets the information that the tooltip control maintains for a particular tool.
Definition tooltip.h:483
void SetMaxTipWidth(int width)
Definition tooltip.h:583
void SetBkColor(const TColor &clr)
Definition tooltip.h:595
void TrackPosition(const TPoint &pos)
Definition tooltip.h:625
void DeleteTool(const TToolInfo &)
Removes a tool from the tooltip control.
Definition tooltip.h:417
void Update()
Definition tooltip.h:631
bool GetToolInfo(TToolInfo &) const
Retrieves the information that the tooltip control maintains about a tool.
Definition tooltip.h:470
void Activate(bool activate=true)
Set state of tooltip.
Definition tooltip.h:394
TColor GetTextColor() const
Definition tooltip.h:601
void UpdateTipText(HWND toolWnd, uint ctrlId, int tipResId, TModule *m=nullptr)
Updates the tip for the control identified by the given identifier in the given tool window.
Definition tooltip.h:281
void TrackActivate(const TToolInfo &info, bool activate=true)
Definition tooltip.h:619
TColor GetBkColor() const
Definition tooltip.h:589
bool AddTool(HWND toolWnd, int ctrlId, const tstring &tip, bool enableSubclassing=true)
Adds a tip for the control identified by the given identifier in the given tool window.
Definition tooltip.h:220
TTooltipText identifies a tool for which text is to be displayed.
Definition commctrl.h:153
Type-safe encapsulation of a Windows class name, a union between ATOM and LPCTSTR.
Definition module.h:47
TWindow, derived from TEventHandler and TStreamableBase, provides window-specific behavior and encaps...
Definition window.h:414
TResult SendMessage(TMsgId, TParam1=0, TParam2=0) const
Sends a message (msg) to a specified window or windows.
Definition window.cpp:3288
Definition of classes for CommonControl encapsulation.
int operator==(const TBitSet< T > &bs1, const TBitSet< T > &bs2)
Definition bitset.h:86
TWindowFlag
Define bit masks for the internally used flag attributes of TWindow.
Definition window.h:58
Object Windows Library (OWLNext Core)
Definition animctrl.h:22
uint32 MkUint32(uint16 lo, uint16 hi)
Definition defs.h:261
LPARAM TParam2
Second parameter type.
Definition dispatch.h:55
WPARAM TParam1
First parameter type.
Definition dispatch.h:54
LRESULT TResult
Result type.
Definition dispatch.h:52
std::string tstring
Definition defs.h:79
unsigned int uint
Definition number.h:25
General definitions used by all ObjectWindows programs.
#define protected_data
Definition defs.h:208
#define CONST_CAST(targetType, object)
Definition defs.h:273
#define _OWLCLASS
Definition defs.h:338