Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members

FXTreeList.h
Go to the documentation of this file.
1 /********************************************************************************
2 * *
3 * T r e e L i s t W i d g e t *
4 * *
5 *********************************************************************************
6 * Copyright (C) 1997,2006 by Jeroen van der Zijp. All Rights Reserved. *
7 *********************************************************************************
8 * This library is free software; you can redistribute it and/or *
9 * modify it under the terms of the GNU Lesser General Public *
10 * License as published by the Free Software Foundation; either *
11 * version 2.1 of the License, or (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
16 * Lesser General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU Lesser General Public *
19 * License along with this library; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. *
21 *********************************************************************************
22 * $Id: FXTreeList.h,v 1.101 2006/01/22 17:58:11 fox Exp $ *
23 ********************************************************************************/
24 #ifndef FXTREELIST_H
25 #define FXTREELIST_H
26 
27 #ifndef FXSCROLLAREA_H
28 #include "FXScrollArea.h"
29 #endif
30 
31 namespace FX {
32 
33 
34 class FXIcon;
35 class FXFont;
36 class FXTreeList;
37 class FXDirList;
38 
39 
40 /// Tree list styles
41 enum {
42  TREELIST_EXTENDEDSELECT = 0, /// Extended selection mode allows for drag-selection of ranges of items
43  TREELIST_SINGLESELECT = 0x00100000, /// Single selection mode allows up to one item to be selected
44  TREELIST_BROWSESELECT = 0x00200000, /// Browse selection mode enforces one single item to be selected at all times
45  TREELIST_MULTIPLESELECT = 0x00300000, /// Multiple selection mode is used for selection of individual items
46  TREELIST_AUTOSELECT = 0x00400000, /// Automatically select under cursor
47  TREELIST_SHOWS_LINES = 0x00800000, /// Lines shown
48  TREELIST_SHOWS_BOXES = 0x01000000, /// Boxes to expand shown
49  TREELIST_ROOT_BOXES = 0x02000000, /// Display root boxes also
51  };
52 
53 
54 /// Tree list Item
55 class FXAPI FXTreeItem : public FXObject {
57  friend class FXTreeList;
58  friend class FXDirList;
59 protected:
60  FXTreeItem *parent; // Parent item
61  FXTreeItem *prev; // Previous item
62  FXTreeItem *next; // Next item
63  FXTreeItem *first; // First child item
64  FXTreeItem *last; // Last child item
65  FXString label; // Text of item
66  FXIcon *openIcon; // Icon of item
67  FXIcon *closedIcon; // Icon of item
68  void *data; // Item user data pointer
69  FXuint state; // Item state flags
70  FXint x,y;
71 private:
73  FXTreeItem& operator=(const FXTreeItem&);
74 protected:
75  FXTreeItem():parent(NULL),prev(NULL),next(NULL),first(NULL),last(NULL),openIcon(NULL),closedIcon(NULL),data(NULL),state(0),x(0),y(0){}
76  virtual void draw(const FXTreeList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
77  virtual FXint hitItem(const FXTreeList* list,FXint x,FXint y) const;
78 public:
79  enum{
80  SELECTED = 1, /// Selected
81  FOCUS = 2, /// Focus
82  DISABLED = 4, /// Disabled
83  OPENED = 8, /// Opened
84  EXPANDED = 16, /// Expanded
85  HASITEMS = 32, /// Has virtual subitems
86  DRAGGABLE = 64, /// Draggable
87  OPENICONOWNED = 128, /// Open icon owned by item
88  CLOSEDICONOWNED = 256 /// Close icon owned by item
89  };
90 public:
91 
92  /// Constructor
93  FXTreeItem(const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL):parent(NULL),prev(NULL),next(NULL),first(NULL),last(NULL),label(text),openIcon(oi),closedIcon(ci),data(ptr),state(0),x(0),y(0){}
94 
95  /// Get parent item
96  FXTreeItem* getParent() const { return parent; }
97 
98  /// Get next sibling item
99  FXTreeItem* getNext() const { return next; }
100 
101  /// Get previous sibling item
102  FXTreeItem* getPrev() const { return prev; }
103 
104  /// Get first child item
105  FXTreeItem* getFirst() const { return first; }
106 
107  /// Get las child item
108  FXTreeItem* getLast() const { return last; }
109 
110  /// Get item below this one in list
111  FXTreeItem* getBelow() const;
113  /// Get item above this one in list
114  FXTreeItem* getAbove() const;
115 
116  /// Get number of children of item
117  FXint getNumChildren() const;
119  /// Change item label
120  virtual void setText(const FXString& txt);
121 
122  /// Get item label
123  const FXString& getText() const { return label; }
125  /// Change open icon, deleting the old icon if it was owned
126  virtual void setOpenIcon(FXIcon* icn,FXbool owned=FALSE);
128  /// Get open icon
129  FXIcon* getOpenIcon() const { return openIcon; }
131  /// Change closed icon, deleting the old icon if it was owned
132  virtual void setClosedIcon(FXIcon* icn,FXbool owned=FALSE);
133 
134  /// Get closed icon
135  FXIcon* getClosedIcon() const { return closedIcon; }
137  /// Change item user data
138  void setData(void* ptr){ data=ptr; }
139 
140  /// Get item user data
141  void* getData() const { return data; }
143  /// Make item draw as focused
144  virtual void setFocus(FXbool focus);
145 
146  /// Return true if item has focus
147  FXbool hasFocus() const { return (state&FOCUS)!=0; }
149  /// Select item
150  virtual void setSelected(FXbool selected);
151 
152  /// Return true if this item is selected
153  FXbool isSelected() const { return (state&SELECTED)!=0; }
155  /// Make item show as open
156  virtual void setOpened(FXbool opened);
157 
158  /// Return true if this item is open
159  FXbool isOpened() const { return (state&OPENED)!=0; }
161  /// Expand or collapse item
162  virtual void setExpanded(FXbool expanded);
163 
164  /// Return true if this item is expanded into sub items
165  FXbool isExpanded() const { return (state&EXPANDED)!=0; }
167  /// Enable or disable item
168  virtual void setEnabled(FXbool enabled);
170  /// Return true if this item is enabled
171  FXbool isEnabled() const { return (state&DISABLED)==0; }
172 
173  /// Make item draggable
174  virtual void setDraggable(FXbool draggable);
175 
176  /// Return true if this item is draggable
177  FXbool isDraggable() const { return (state&DRAGGABLE)!=0; }
178 
179  /// Return TRUE if subitems, real or imagined
180  FXbool hasItems() const { return (state&HASITEMS)!=0; }
181 
182  /// Change has items flag
183  void setHasItems(FXbool flag);
184 
185  /// Return true if descendent of parent item
186  FXbool isChildOf(const FXTreeItem* item) const;
187 
188  /// Return true if ancestor of child item
189  FXbool isParentOf(const FXTreeItem* item) const;
190 
191  /// Return width of item as drawn in list
192  virtual FXint getWidth(const FXTreeList* list) const;
193 
194  /// Return height of item as drawn in list
195  virtual FXint getHeight(const FXTreeList* list) const;
196 
197  /// Create server-side resources
198  virtual void create();
199 
200  /// Detach server-side resources
201  virtual void detach();
202 
203  /// Destroy server-side resources
204  virtual void destroy();
205 
206  /// Save to stream
207  virtual void save(FXStream& store) const;
209  /// Load from stream
210  virtual void load(FXStream& store);
211 
212  /// Destroy item and free icons if owned
213  virtual ~FXTreeItem();
214  };
215 
216 
217 
218 /// Tree item collate function
219 typedef FXint (*FXTreeListSortFunc)(const FXTreeItem*,const FXTreeItem*);
220 
221 
222 
223 /**
224 * A Tree List Widget organizes items in a hierarchical, tree-like fashion.
225 * Subtrees can be collapsed or expanded by double-clicking on an item
226 * or by clicking on the optional plus button in front of the item.
227 * Each item may have a text and optional open-icon as well as a closed-icon.
228 * The items may be connected by optional lines to show the hierarchical
229 * relationship.
230 * When an item's selected state changes, the treelist emits a SEL_SELECTED
231 * or SEL_DESELECTED message. If an item is opened or closed, a message
232 * of type SEL_OPENED or SEL_CLOSED is sent. When the subtree under an
233 * item is expanded, a SEL_EXPANDED or SEL_COLLAPSED message is issued.
234 * A change of the current item is signified by the SEL_CHANGED message.
235 * In addition, the tree list sends SEL_COMMAND messages when the user
236 * clicks on an item, and SEL_CLICKED, SEL_DOUBLECLICKED, and SEL_TRIPLECLICKED
237 * when the user clicks once, twice, or thrice, respectively.
238 * When items are added or removed, the tree list sends messages of the
239 * type SEL_INSERTED or SEL_DELETED.
240 * In each of these cases, a pointer to the item, if any, is passed in the
241 * 3rd argument of the message.
242 */
243 class FXAPI FXTreeList : public FXScrollArea {
245 protected:
246  FXTreeItem *firstitem; // First root item
247  FXTreeItem *lastitem; // Last root item
248  FXTreeItem *anchoritem; // Selection anchor item
249  FXTreeItem *currentitem; // Current item
250  FXTreeItem *extentitem; // Selection extent
251  FXTreeItem *cursoritem; // Item under cursor
252  FXTreeItem *viewableitem; // Visible item
253  FXFont *font; // Font
254  FXTreeListSortFunc sortfunc; // Item sort function
255  FXColor textColor; // Text color
256  FXColor selbackColor; // Selected background color
257  FXColor seltextColor; // Selected text color
258  FXColor lineColor; // Line color
259  FXint treeWidth; // Tree width
260  FXint treeHeight; // Tree height
261  FXint visible; // Number of visible items
262  FXint indent; // Parent to child indentation
263  FXint grabx; // Grab point x
264  FXint graby; // Grab point y
265  FXString lookup; // Lookup string
266  FXString tip;
267  FXString help; // Help string
268  FXbool state; // State of item
269 protected:
270  FXTreeList();
271  virtual FXTreeItem* createItem(const FXString& text,FXIcon* oi,FXIcon* ci,void* ptr);
272  void sort(FXTreeItem*& f1,FXTreeItem*& t1,FXTreeItem*& f2,FXTreeItem*& t2,int n);
273  void recompute();
274 private:
275  FXTreeList(const FXTreeList&);
276  FXTreeList& operator=(const FXTreeList&);
277 public:
278  long onPaint(FXObject*,FXSelector,void*);
279  long onEnter(FXObject*,FXSelector,void*);
280  long onLeave(FXObject*,FXSelector,void*);
281  long onUngrabbed(FXObject*,FXSelector,void*);
282  long onMotion(FXObject*,FXSelector,void*);
283  long onKeyPress(FXObject*,FXSelector,void*);
284  long onKeyRelease(FXObject*,FXSelector,void*);
285  long onLeftBtnPress(FXObject*,FXSelector,void*);
286  long onLeftBtnRelease(FXObject*,FXSelector,void*);
287  long onRightBtnPress(FXObject*,FXSelector,void*);
288  long onRightBtnRelease(FXObject*,FXSelector,void*);
289  long onQueryTip(FXObject*,FXSelector,void*);
290  long onQueryHelp(FXObject*,FXSelector,void*);
291  long onTipTimer(FXObject*,FXSelector,void*);
292  long onFocusIn(FXObject*,FXSelector,void*);
293  long onFocusOut(FXObject*,FXSelector,void*);
294  long onAutoScroll(FXObject*,FXSelector,void*);
295  long onClicked(FXObject*,FXSelector,void*);
296  long onDoubleClicked(FXObject*,FXSelector,void*);
297  long onTripleClicked(FXObject*,FXSelector,void*);
298  long onCommand(FXObject*,FXSelector,void*);
299  long onLookupTimer(FXObject*,FXSelector,void*);
300 public:
301  static FXint ascending(const FXTreeItem*,const FXTreeItem*);
302  static FXint descending(const FXTreeItem*,const FXTreeItem*);
303  static FXint ascendingCase(const FXTreeItem*,const FXTreeItem*);
304  static FXint descendingCase(const FXTreeItem*,const FXTreeItem*);
305 public:
306  enum {
307  ID_LOOKUPTIMER=FXScrollArea::ID_LAST,
308  ID_LAST
309  };
310 public:
311 
312  /// Construct a new, initially empty tree list
315  /// Create server-side resources
316  virtual void create();
318  /// Detach server-side resources
319  virtual void detach();
320 
321  /// Perform layout
322  virtual void layout();
323 
324  /// Return default width
325  virtual FXint getDefaultWidth();
326 
327  /// Return default height
328  virtual FXint getDefaultHeight();
329 
330  /// Compute and return content width
331  virtual FXint getContentWidth();
332 
333  /// Return content height
334  virtual FXint getContentHeight();
335 
336  /// Recalculate layout
337  virtual void recalc();
338 
339  /// Tree list can receive focus
340  virtual bool canFocus() const;
341 
342  /// Move the focus to this window
343  virtual void setFocus();
344 
345  /// Remove the focus from this window
346  virtual void killFocus();
347 
348  /// Return number of items
349  FXint getNumItems() const;
350 
351  /// Return number of visible items
352  FXint getNumVisible() const { return visible; }
353 
354  /// Change number of visible items
355  void setNumVisible(FXint nvis);
356 
357  /// Return first root item
358  FXTreeItem* getFirstItem() const { return firstitem; }
360  /// Return last root item
361  FXTreeItem* getLastItem() const { return lastitem; }
363  /// Fill tree list by appending items from array of strings
364  FXint fillItems(FXTreeItem* father,const FXchar** strings,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
365 
366  /// Fill tree list by appending items from newline separated strings
367  FXint fillItems(FXTreeItem* father,const FXString& strings,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
368 
369  /// Insert [possibly subclassed] item under father before other item
370  FXTreeItem* insertItem(FXTreeItem* other,FXTreeItem* father,FXTreeItem* item,FXbool notify=FALSE);
371 
372  /// Insert item with given text and optional icons, and user-data pointer under father before other item
373  FXTreeItem* insertItem(FXTreeItem* other,FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
374 
375  /// Append [possibly subclassed] item as last child of father
376  FXTreeItem* appendItem(FXTreeItem* father,FXTreeItem* item,FXbool notify=FALSE);
377 
378  /// Append item with given text and optional icons, and user-data pointer as last child of father
379  FXTreeItem* appendItem(FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
380 
381  /// Prepend [possibly subclassed] item as first child of father
382  FXTreeItem* prependItem(FXTreeItem* father,FXTreeItem* item,FXbool notify=FALSE);
383 
384  /// Prepend item with given text and optional icons, and user-data pointer as first child of father
385  FXTreeItem* prependItem(FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
386 
387  /// Move item under father before other item
388  FXTreeItem *moveItem(FXTreeItem* other,FXTreeItem* father,FXTreeItem* item);
389 
390  /// Extract item
391  FXTreeItem* extractItem(FXTreeItem* item,FXbool notify=FALSE);
392 
393  /// Remove item
394  void removeItem(FXTreeItem* item,FXbool notify=FALSE);
395 
396  /// Remove items in range [fm, to] inclusively
397  void removeItems(FXTreeItem* fm,FXTreeItem* to,FXbool notify=FALSE);
398 
399  /// Remove all items from list
400  void clearItems(FXbool notify=FALSE);
401 
402  /// Return item width
403  FXint getItemWidth(const FXTreeItem* item) const { return item->getWidth(this); }
404 
405  /// Return item height
406  FXint getItemHeight(const FXTreeItem* item) const { return item->getHeight(this); }
407 
408  /// Get item at x,y, if any
409  virtual FXTreeItem* getItemAt(FXint x,FXint y) const;
410 
411  /**
412  * Search items by name, beginning from item start. If the start item
413  * is NULL the search will start at the first, top-most item in the list.
414  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the search
415  * direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
416  * to control whether the search wraps at the start or end of the list.
417  * The option SEARCH_IGNORECASE causes a case-insensitive match. Finally,
418  * passing SEARCH_PREFIX causes searching for a prefix of the item name.
419  * Return NULL if no matching item is found.
420  */
421  FXTreeItem* findItem(const FXString& name,FXTreeItem* start=NULL,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
422 
423  /**
424  * Search items by associated user data, beginning from item start. If the
425  * start item is NULL the search will start at the first, top-most item
426  * in the list. Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control
427  * the search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
428  * to control whether the search wraps at the start or end of the list.
429  */
430  FXTreeItem* findItemByData(const void *ptr,FXTreeItem* start=NULL,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
431 
432  /// Scroll to make item visible
433  virtual void makeItemVisible(FXTreeItem* item);
434 
435  /// Change item's text
436  void setItemText(FXTreeItem* item,const FXString& text);
437 
438  /// Return item's text
439  FXString getItemText(const FXTreeItem* item) const;
440 
441  /// Change item's open icon
442  void setItemOpenIcon(FXTreeItem* item,FXIcon* icon,FXbool owned=FALSE);
443 
444  /// Return item's open icon, deleting the old icon if it was owned
445  FXIcon* getItemOpenIcon(const FXTreeItem* item) const;
446 
447  /// Chance item's closed icon, deleting the old icon if it was owned
448  void setItemClosedIcon(FXTreeItem* item,FXIcon* icon,FXbool owned=FALSE);
449 
450  /// Return item's closed icon
451  FXIcon* getItemClosedIcon(const FXTreeItem* item) const;
452 
453  /// Change item user-data pointer
454  void setItemData(FXTreeItem* item,void* ptr) const;
455 
456  /// Return item user-data pointer
457  void* getItemData(const FXTreeItem* item) const;
458 
459  /// Return TRUE if item is selected
460  FXbool isItemSelected(const FXTreeItem* item) const;
461 
462  /// Return TRUE if item is current
463  FXbool isItemCurrent(const FXTreeItem* item) const;
464 
465  /// Return TRUE if item is visible
466  FXbool isItemVisible(const FXTreeItem* item) const;
467 
468  /// Return TRUE if item opened
469  FXbool isItemOpened(const FXTreeItem* item) const;
470 
471  /// Return TRUE if item expanded
472  FXbool isItemExpanded(const FXTreeItem* item) const;
473 
474  /// Return TRUE if item is a leaf-item, i.e. has no children
475  FXbool isItemLeaf(const FXTreeItem* item) const;
476 
477  /// Return TRUE if item is enabled
478  FXbool isItemEnabled(const FXTreeItem* item) const;
480  /// Return item hit code: 0 outside, 1 icon, 2 text, 3 box
481  FXint hitItem(const FXTreeItem* item,FXint x,FXint y) const;
482 
483  /// Repaint item
484  void updateItem(FXTreeItem* item) const;
486  /// Enable item
487  virtual FXbool enableItem(FXTreeItem* item);
489  /// Disable item
490  virtual FXbool disableItem(FXTreeItem* item);
491 
492  /// Select item
493  virtual FXbool selectItem(FXTreeItem* item,FXbool notify=FALSE);
494 
495  /// Deselect item
496  virtual FXbool deselectItem(FXTreeItem* item,FXbool notify=FALSE);
497 
498  /// Toggle item selection
499  virtual FXbool toggleItem(FXTreeItem* item,FXbool notify=FALSE);
501  /// Extend selection from anchor item to item
502  virtual FXbool extendSelection(FXTreeItem* item,FXbool notify=FALSE);
504  /// Deselect all items
505  virtual FXbool killSelection(FXbool notify=FALSE);
506 
507  /// Open item
508  virtual FXbool openItem(FXTreeItem* item,FXbool notify=FALSE);
510  /// Close item
511  virtual FXbool closeItem(FXTreeItem* item,FXbool notify=FALSE);
512 
513  /// Collapse tree
514  virtual FXbool collapseTree(FXTreeItem* tree,FXbool notify=FALSE);
516  /// Expand tree
517  virtual FXbool expandTree(FXTreeItem* tree,FXbool notify=FALSE);
519  /// Change current item
520  virtual void setCurrentItem(FXTreeItem* item,FXbool notify=FALSE);
521 
522  /// Return current item, if any
523  FXTreeItem* getCurrentItem() const { return currentitem; }
525  /// Change anchor item
526  void setAnchorItem(FXTreeItem* item);
527 
528  /// Return anchor item, if any
529  FXTreeItem* getAnchorItem() const { return anchoritem; }
531  /// Return item under cursor, if any
532  FXTreeItem* getCursorItem() const { return cursoritem; }
533 
534  /// Sort all items recursively
535  void sortItems();
537  /// Sort root items
538  void sortRootItems();
539 
540  /// Sort children of item
541  void sortChildItems(FXTreeItem* item);
542 
543  /// Return sort function
544  FXTreeListSortFunc getSortFunc() const { return sortfunc; }
545 
546  /// Change sort function
547  void setSortFunc(FXTreeListSortFunc func){ sortfunc=func; }
548 
549  /// Change text font
550  void setFont(FXFont* fnt);
552  /// Return text font
553  FXFont* getFont() const { return font; }
554 
555  /// Change parent-child indent amount
556  void setIndent(FXint in);
557 
558  /// Return parent-child indent amount
559  FXint getIndent() const { return indent; }
560 
561  /// Return normal text color
562  FXColor getTextColor() const { return textColor; }
563 
564  /// Change normal text color
565  void setTextColor(FXColor clr);
566 
567  /// Return selected text background
568  FXColor getSelBackColor() const { return selbackColor; }
569 
570  /// Change selected text background
571  void setSelBackColor(FXColor clr);
572 
573  /// Return selected text color
574  FXColor getSelTextColor() const { return seltextColor; }
575 
576  /// Change selected text color
577  void setSelTextColor(FXColor clr);
578 
579  /// Return line color
580  FXColor getLineColor() const { return lineColor; }
581 
582  /// Change line color
583  void setLineColor(FXColor clr);
584 
585  /// Return list style
586  FXuint getListStyle() const;
587 
588  /// Change list style
589  void setListStyle(FXuint style);
590 
591  /// Set the status line help text for this list
592  void setHelpText(const FXString& text);
593 
594  /// Get the status line help text for this list
595  const FXString& getHelpText() const { return help; }
596 
597  /// Save object to a stream
598  virtual void save(FXStream& store) const;
599 
600  /// Load object from a stream
601  virtual void load(FXStream& store);
602 
603  /// Destructor
604  virtual ~FXTreeList();
605  };
606 
607 }
608 
609 #endif
Multiple selection mode is used for selection of individual items.
Definition: FXTreeList.h:48
Search forward (default)
Definition: fxdefs.h:363
char FXchar
Definition: fxdefs.h:380
Tree list Item.
Definition: FXTreeList.h:63
FXint(* FXTreeListSortFunc)(const FXTreeItem *, const FXTreeItem *)
Tree item collate function.
Definition: FXTreeList.h:208
Definition: FXWindow.h:241
unsigned int FXuint
Definition: fxdefs.h:389
FXuint FXSelector
Association key.
Definition: FXObject.h:53
A Tree List Widget organizes items in a hierarchical, tree-like fashion.
Definition: FXTreeList.h:235
#define FXAPI
Definition: fxdefs.h:122
FXuchar FXbool
Definition: fxdefs.h:386
Definition: FXTreeList.h:53
Base composite.
Definition: FXComposite.h:35
#define NULL
Definition: fxdefs.h:41
FXuint FXColor
Definition: fxdefs.h:447
FXString name(const FXString &file)
Return name and extension part of the path name.
virtual FXint getWidth(const FXTreeList *list) const
Return width of item as drawn in list.
Automatically select under cursor.
Definition: FXTreeList.h:49
A stream is a way to serialize data and objects into a byte stream.
Definition: FXStream.h:99
Browse selection mode enforces one single item to be selected at all times.
Definition: FXTreeList.h:47
Abstract Device Context.
Definition: FXDC.h:191
Lines shown.
Definition: FXTreeList.h:50
Boxes to expand shown.
Definition: FXTreeList.h:51
Definition: FX4Splitter.h:31
int FXint
Definition: fxdefs.h:390
An Icon is an image with two additional server-side resources: a shape bitmap, which is used to mask ...
Definition: FXIcon.h:45
Single selection mode allows up to one item to be selected.
Definition: FXTreeList.h:46
The scroll area widget manages a content area and a viewport area through which the content is viewed...
Definition: FXScrollArea.h:75
#define FALSE
Definition: fxdefs.h:35
Extended selection mode allows for drag-selection of ranges of items.
Definition: FXTreeList.h:45
Object is the base class for all objects in FOX; in order to receive messages from the user interface...
Definition: FXObject.h:166
Wrap around to start.
Definition: fxdefs.h:366
A Directory List widget provides a tree-structured view of the file system.
Definition: FXDirList.h:122
virtual FXint getHeight(const FXTreeList *list) const
Return height of item as drawn in list.
Font class.
Definition: FXFont.h:142
#define FXDECLARE(classname)
Macro to set up class declaration.
Definition: FXObject.h:92
Display root boxes also.
Definition: FXTreeList.h:52
FXString provides essential string manipulation capabilities.
Definition: FXString.h:33

Copyright © 1997-2005 Jeroen van der Zijp