]> Creatis software - bbtk.git/blob - doc/bouml/bbtkk/128770
mhb
[bbtk.git] / doc / bouml / bbtkk / 128770
1 format 66
2 "treemultictrl" // bbtk::kernel::src::ThirdParty::wx::treemultictrl
3   revision 1
4   modified_by 2 "davila"
5   // class settings
6   //class diagram settings
7   draw_all_relations default hide_attributes default hide_operations default show_members_full_definition default show_members_visibility default show_members_stereotype default show_members_multiplicity default show_members_initialization default show_attribute_modifiers default member_max_width 0 show_parameter_dir default show_parameter_name default package_name_in_tab default class_drawing_mode default drawing_language default show_context_mode default auto_label_position default show_relation_modifiers default show_infonote default shadow default show_stereotype_properties default
8   //use case diagram settings
9   package_name_in_tab default show_context default auto_label_position default draw_all_relations default class_drawing_mode default shadow default show_stereotype_properties default
10   //sequence diagram settings
11   show_full_operations_definition default write_horizontally default class_drawing_mode default drawing_language default draw_all_relations default shadow default show_stereotype_properties default
12   //collaboration diagram settings
13   show_full_operations_definition default show_hierarchical_rank default write_horizontally default drawing_language default package_name_in_tab default show_context default draw_all_relations default shadow default show_stereotype_properties default
14   //object diagram settings
15    write_horizontally default package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default show_stereotype_properties default
16   //component diagram settings
17   package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default
18   draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
19   //deployment diagram settings
20   package_name_in_tab default show_context default write_horizontally default auto_label_position default draw_all_relations default shadow default
21   draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
22   //state diagram settings
23   package_name_in_tab default show_context default auto_label_position default write_trans_label_horizontally default show_trans_definition default draw_all_relations default shadow default
24   show_activities default region_horizontally default drawing_language default show_stereotype_properties default
25   //activity diagram settings
26   package_name_in_tab default show_context default show_opaque_action_definition default auto_label_position default write_flow_label_horizontally default draw_all_relations default shadow default
27   show_infonote default drawing_language default show_stereotype_properties default
28   
29   classview 128258 "treemultictrl"
30     //class diagram settings
31     draw_all_relations default hide_attributes default hide_operations default show_members_full_definition default show_members_visibility default show_members_stereotype default show_members_multiplicity default show_members_initialization default show_attribute_modifiers default member_max_width 0 show_parameter_dir default show_parameter_name default package_name_in_tab default class_drawing_mode default drawing_language default show_context_mode default auto_label_position default show_relation_modifiers default show_infonote default shadow default show_stereotype_properties default
32     //collaboration diagram settings
33     show_full_operations_definition default show_hierarchical_rank default write_horizontally default drawing_language default package_name_in_tab default show_context default draw_all_relations default shadow default show_stereotype_properties default
34     //object diagram settings
35      write_horizontally default package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default show_stereotype_properties default
36     //sequence diagram settings
37     show_full_operations_definition default write_horizontally default class_drawing_mode default drawing_language default draw_all_relations default shadow default show_stereotype_properties default
38     //state diagram settings
39     package_name_in_tab default show_context default auto_label_position default write_trans_label_horizontally default show_trans_definition default draw_all_relations default shadow default
40     show_activities default region_horizontally default drawing_language default show_stereotype_properties default
41     //class settings
42     //activity diagram settings
43     package_name_in_tab default show_context default show_opaque_action_definition default auto_label_position default write_flow_label_horizontally default draw_all_relations default shadow default
44     show_infonote default drawing_language default show_stereotype_properties default
45     class 139778 "TreeMultiItemBase"
46       visibility package 
47       cpp_decl "${comment}${template}class ${name}${inherit} {
48 ${members}};
49 ${inlines}
50 "
51       java_decl ""
52       php_decl ""
53       python_2_2 python_decl ""
54       idl_decl ""
55       explicit_switch_type ""
56       
57       operation 161026 "TreeMultiItemBase"
58         preserve_cpp_body_indent protected explicit_return_type ""
59         nparams 1
60           param inout name "parent" type class_ref 139906 // TreeMultiItemNode
61         cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}${)}${volatile}${throw};
62 "
63         cpp_def "//* TreeMultiItemBase
64
65 //  * This class is the node of the whole tree. All the other classes in the
66
67 //  * tree descend from this node. It contains the type of the class without
68 //  * using RTTI. NOTE: this class cannot be constructed directly
69 //  
70
71 ${comment}${inline}${class}::${name}${(}${t0} * ${p0}${)}
72         : _excluded(false)
73
74         , _x(0)
75         , _y(0)
76         , _width(0)
77
78         , _height(0)
79
80         , _parent(parent)
81
82         , m_Selected(false)
83
84 #if(CHECKBOXVIEW)
85
86         , _checkbox(false)
87
88         , _checkboxState(0)
89
90 #endif
91 ${throw}{
92 ${body}}
93 "
94         
95         
96         
97         
98       end
99
100       attribute 139778 "_name"
101         protected explicit_type "wxString"
102         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
103 "
104         java_decl ""
105         php_decl ""
106         python_decl ""
107         idl_decl ""
108       end
109
110       attribute 139906 "_excluded"
111         protected explicit_type "bool"
112         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
113 "
114         java_decl ""
115         php_decl ""
116         python_decl ""
117         idl_decl ""
118       end
119
120       attribute 140034 "_type"
121         protected explicit_type "int"
122         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
123 "
124         java_decl ""
125         php_decl ""
126         python_decl ""
127         idl_decl ""
128       end
129
130       attribute 140162 "_checkbox"
131         protected explicit_type "bool"
132         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
133 "
134         java_decl ""
135         php_decl ""
136         python_decl ""
137         idl_decl ""
138       end
139
140       attribute 140290 "_checkboxState"
141         protected explicit_type "int"
142         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
143 "
144         java_decl ""
145         php_decl ""
146         python_decl ""
147         idl_decl ""
148       end
149
150       operation 161154 "~TreeMultiItemBase"
151         preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
152         nparams 0
153         cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
154 "
155         cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
156 ${body}}
157 "
158         
159         
160         
161         
162       end
163
164       operation 161282 "GetType"
165         const cpp_inline public explicit_return_type "int"
166         nparams 0
167         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return _type; };
168 "
169         
170         
171         
172         
173         comment " type of tree item"
174       end
175
176       operation 161410 "GetParent"
177         const cpp_inline public return_type class_ref 139906 // TreeMultiItemNode
178         nparams 0
179         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} { return _parent; };
180 "
181         
182         
183         
184         
185       end
186
187       operation 161538 "GetName"
188         const cpp_inline public explicit_return_type "wxString"
189         nparams 0
190         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
191                 return _name;
192         };
193 "
194         
195         
196         
197         
198         comment "* Get name of this node "
199       end
200
201       operation 161666 "SetName"
202         cpp_inline public explicit_return_type "void"
203         nparams 1
204           param in name "NewName" explicit_type "wxString"
205         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
206     this->_name = NewName;
207   };
208 "
209         
210         
211         
212         
213         comment "* Set name of the item "
214       end
215
216       operation 161794 "IsTreeMultiItemRoot"
217         const cpp_virtual cpp_inline public return_type class_ref 140034 // TreeMultiItemRoot
218         nparams 0
219         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
220                 return 0;
221         };
222 "
223         
224         
225         
226         
227         comment "* returns the instance pointer if the current node is
228         a TreeMultiItemRoot, and NULL when it's not.
229         "
230       end
231
232       operation 161922 "IsTreeMultiItemWindow"
233         const cpp_virtual cpp_inline public return_type class_ref 140162 // TreeMultiItemWindow
234         nparams 0
235         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
236                 return 0;
237         };
238 "
239         
240         
241         
242         
243         comment "* returns the instance pointer if the current node is
244         a TreeMultiItemWindow, and NULL when it's not.
245         "
246       end
247
248       operation 162050 "IsTreeMultiItemNode"
249         const cpp_virtual cpp_inline public return_type class_ref 139906 // TreeMultiItemNode
250         nparams 0
251         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
252                 return 0;
253         };
254 "
255         
256         
257         
258         
259         comment "* returns the instance pointer if the current node is
260         a TreeMultiItemNode, and NULL when it's not.
261         "
262       end
263
264       operation 162178 "SetExcluded"
265         cpp_inline public explicit_return_type "void"
266         nparams 1
267           param in name "excluded" explicit_type "bool"
268         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
269                 _excluded = excluded;
270         };
271 "
272         
273         
274         
275         
276         comment "* Sets or resets the excluded flag. When excluded node is not visible "
277       end
278
279       operation 162306 "SetX"
280         cpp_inline public explicit_return_type "void"
281         nparams 1
282           param in name "x" explicit_type "int"
283         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
284                 _x = x;
285         };
286 "
287         
288         
289         
290         
291         comment "* Get / Set routine for X "
292       end
293
294       operation 162434 "GetX"
295         const cpp_inline public explicit_return_type "int"
296         nparams 0
297         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
298                 return _x;
299         };
300 "
301         
302         
303         
304         
305       end
306
307       operation 162562 "SetY"
308         cpp_inline public explicit_return_type "void"
309         nparams 1
310           param in name "y" explicit_type "int"
311         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
312                 _y = y;
313         };
314 "
315         
316         
317         
318         
319         comment "* Get / Set routine for Y "
320       end
321
322       operation 162690 "GetY"
323         const cpp_inline public explicit_return_type "int"
324         nparams 0
325         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
326                 return _y;
327         };
328 "
329         
330         
331         
332         
333       end
334
335       operation 162818 "SetHeight"
336         cpp_inline public explicit_return_type "void"
337         nparams 1
338           param in name "height" explicit_type "int"
339         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
340                 _height = height;
341         };
342 "
343         
344         
345         
346         
347         comment "* Get / Set routine for height "
348       end
349
350       operation 162946 "GetHeight"
351         const cpp_inline public explicit_return_type "int"
352         nparams 0
353         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
354                 return _height;
355         };
356 "
357         
358         
359         
360         
361       end
362
363       operation 163074 "SetWidth"
364         cpp_inline public explicit_return_type "void"
365         nparams 1
366           param in name "width" explicit_type "int"
367         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
368                 _width = width;
369         };
370 "
371         
372         
373         
374         
375         comment "* Get / Set routine for width "
376       end
377
378       operation 163202 "GetWidth"
379         const cpp_inline public explicit_return_type "int"
380         nparams 0
381         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
382                 return _width;
383         };
384 "
385         
386         
387         
388         
389       end
390
391       operation 163330 "IsVisible"
392         preserve_cpp_body_indent public explicit_return_type "bool"
393         nparams 0
394         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
395 "
396         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
397   ${body}}
398 "
399         
400         
401         
402         
403         comment "* Returns true when this item is drawn somewhere in the
404             tree. Whenever a parent of this node is collapsed, it
405             is not visible and it is not necessary to perform i.e.
406             redraw actions. 
407                 
408                 It also returns false when this node is excluded from the
409                 tree. 
410                 
411                 \\sa wxTreeMultiCtrl::Exclude(), wxTreeMultiCtrl::Include())
412         "
413       end
414
415       operation 163458 "IsExcluded"
416         const cpp_inline public explicit_return_type "bool"
417         nparams 0
418         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
419                 return _excluded;
420         };
421 "
422         
423         
424         
425         
426         comment " Returns if this node is excluded from the tree. If this item
427            is a Node, then all kids are excluded as well "
428       end
429
430       operation 163586 "IsSelected"
431         const cpp_inline public explicit_return_type "bool"
432         nparams 1
433           param in name "" explicit_type "void"
434         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
435     return this->m_Selected;
436   };
437 "
438         
439         
440         
441         
442         comment " item selection status handling
443 * checks if the item is selected "
444       end
445
446       operation 163714 "Select"
447         cpp_inline public explicit_return_type "void"
448         nparams 1
449           param in name "" explicit_type "void"
450         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
451     this->m_Selected = true;
452   };
453 "
454         
455         
456         
457         
458         comment "* mark the current item as selected "
459       end
460
461       operation 163842 "ToggleSelection"
462         cpp_inline public explicit_return_type "void"
463         nparams 1
464           param in name "" explicit_type "void"
465         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
466     this->m_Selected = !(this->m_Selected);
467   };
468 "
469         
470         
471         
472         
473         comment "* toggle the selection status "
474       end
475
476       operation 163970 "Unselect"
477         cpp_inline public explicit_return_type "void"
478         nparams 1
479           param in name "" explicit_type "void"
480         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
481     this->m_Selected = false;
482   };
483 "
484         
485         
486         
487         
488         comment "* unmark the item "
489       end
490
491       operation 164098 "SetCheckbox"
492         cpp_inline public explicit_return_type "void"
493         nparams 1
494           param in name "value" explicit_type "bool"
495         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
496                 _checkbox = value;
497         };
498 "
499         
500         
501         
502         
503         comment "* Sets checkbox or not. This does not influence the state of the checkbox "
504       end
505
506       operation 164226 "GetCheckbox"
507         const cpp_inline public explicit_return_type "bool"
508         nparams 0
509         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
510                 return _checkbox;
511         };
512 "
513         
514         
515         
516         
517         comment "* Returns current state of the checkbox view "
518       end
519
520       operation 164354 "SetCheckboxState"
521         cpp_virtual cpp_inline public explicit_return_type "void"
522         nparams 1
523           param in name "state" explicit_type "int"
524         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
525                 wxCHECK2(state < 3 && state >= 0, return);
526                 _checkboxState = state;
527         };
528 "
529         
530         
531         
532         
533         comment "* Sets checkbox state. If 0 it's unchecked, 1 = checked and 2 = tristate "
534       end
535
536       operation 164482 "GetCheckboxState"
537         const cpp_inline public explicit_return_type "int"
538         nparams 0
539         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
540                 return _checkboxState;
541         };
542 "
543         
544         
545         
546         
547         comment "* Returns current state of checkbox "
548       end
549
550       classrelation 135170 // _parent (<unidirectional association>)
551         relation 135170 --->
552           a role_name "_parent" private
553             cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
554 "
555             classrelation_ref 135170 // _parent (<unidirectional association>)
556           b parent class_ref 139906 // TreeMultiItemNode
557       end
558
559       attribute 140418 "m_Selected"
560         private explicit_type "bool"
561         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
562 "
563         java_decl ""
564         php_decl ""
565         python_decl ""
566         idl_decl ""
567       end
568     end
569
570     class 139906 "TreeMultiItemNode"
571       visibility package 
572       cpp_decl "${comment}${template}class ${name}${inherit} {
573 ${members}};
574 ${inlines}
575 "
576       java_decl ""
577       php_decl ""
578       python_2_2 python_decl ""
579       idl_decl ""
580       explicit_switch_type ""
581       
582       classrelation 135298 // <generalisation>
583         relation 135298 ---|>
584           a public
585             cpp default "${type}"
586             classrelation_ref 135298 // <generalisation>
587           b parent class_ref 139778 // TreeMultiItemBase
588       end
589
590       attribute 140546 "_items"
591         private explicit_type "TreeMultiItemBaseArray"
592         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
593 "
594         java_decl ""
595         php_decl ""
596         python_decl ""
597         idl_decl ""
598       end
599
600       attribute 140674 "_caption"
601         private explicit_type "wxString"
602         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
603 "
604         java_decl ""
605         php_decl ""
606         python_decl ""
607         idl_decl ""
608       end
609
610       attribute 140802 "_nodeExpanded"
611         private explicit_type "bool"
612         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
613 "
614         java_decl ""
615         php_decl ""
616         python_decl ""
617         idl_decl ""
618       end
619
620       attribute 140930 "m_Attributes"
621         private explicit_type "wxTreeItemAttr"
622         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
623 "
624         java_decl ""
625         php_decl ""
626         python_decl ""
627         idl_decl ""
628       end
629
630       operation 164610 "TreeMultiItemNode"
631         preserve_cpp_body_indent public explicit_return_type ""
632         nparams 3
633           param inout name "parent" type class_ref 139906 // TreeMultiItemNode
634           param in name "caption" explicit_type "wxString"
635             defaultvalue "wxEmptyString"
636           param in name "name" explicit_type "wxString"
637             defaultvalue "wxEmptyString"
638         cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}, const ${t2} & ${p2}${v2}${)}${volatile}${throw};
639 "
640         cpp_def "//* TreeMultiItemNode
641 //  * This class is a container holder for multiple TreeMultiItemBase classes.
642 //  * Since both a TreeMultiItemNode and a TreeMultiItemWindow are a descendant
643 //  * from a TreeMultiItemBase class, it can hold multiple of these.
644 //  * In the case of a directory tree structure, it can hold multiple
645 //  * directories, and leafs (files).
646 //  
647 // default constructor for container composite
648
649 ${comment}${inline}${class}::${name}${(}${t0} * ${p0}, const ${t1} & ${p1}, const ${t2} & ${p2}${)}
650         : TreeMultiItemBase(parent)
651         , _caption(caption)
652         , _nodeExpanded(true)
653
654 ${throw}{
655 ${body}}
656 "
657         
658         
659         
660         
661       end
662
663       operation 164738 "~TreeMultiItemNode"
664         preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
665         nparams 0
666         cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
667 "
668         cpp_def "//------------------------------------------------------------
669
670 ${comment}${inline}${class}::${name}${(}${)}${throw}{
671 ${body}}
672 "
673         
674         
675         
676         
677       end
678
679       operation 164866 "IsTreeMultiItemNode"
680         const cpp_virtual cpp_inline public return_type class_ref 139906 // TreeMultiItemNode
681         nparams 0
682         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
683                 return (TreeMultiItemNode *)this;
684         };
685 "
686         
687         
688         
689         
690         comment " isClass method"
691       end
692
693       operation 164994 "AddNode"
694         preserve_cpp_body_indent public explicit_return_type "void"
695         nparams 1
696           param inout name "node" type class_ref 139778 // TreeMultiItemBase
697         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
698 "
699         cpp_def "//------------------------------------------------------------
700
701 ${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
702   ${body}}
703 "
704         
705         
706         
707         
708         comment " add methods
709 "
710       end
711
712       operation 165122 "InsertNode"
713         preserve_cpp_body_indent public explicit_return_type "void"
714         nparams 2
715           param inout name "NodePtr" type class_ref 139778 // TreeMultiItemBase
716           param in name "Position" explicit_type "size_t"
717         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
718 "
719         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
720   ${body}}
721 "
722         
723         
724         
725         
726       end
727
728       operation 165250 "Clear"
729         preserve_cpp_body_indent public explicit_return_type "void"
730         nparams 0
731         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
732 "
733         cpp_def "//------------------------------------------------------------
734
735 ${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
736   ${body}}
737 "
738         
739         
740         
741         
742         comment " delete methods
743 "
744       end
745
746       operation 165378 "DeleteNode"
747         preserve_cpp_body_indent public explicit_return_type "void"
748         nparams 1
749           param inout name "node" type class_ref 139778 // TreeMultiItemBase
750         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
751 "
752         cpp_def "//------------------------------------------------------------
753
754
755 ${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
756   ${body}}
757 "
758         
759         
760         
761         
762       end
763
764       operation 165506 "DeleteNode"
765         preserve_cpp_body_indent public explicit_return_type "void"
766         nparams 1
767           param in name "index" explicit_type "int"
768         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
769 "
770         cpp_def "//------------------------------------------------------------
771
772 ${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
773   ${body}}
774 "
775         
776         
777         
778         
779       end
780
781       operation 165634 "RemoveNode"
782         preserve_cpp_body_indent public return_type class_ref 139778 // TreeMultiItemBase
783         nparams 1
784           param inout name "node" type class_ref 139778 // TreeMultiItemBase
785         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
786 "
787         cpp_def "//------------------------------------------------------------
788
789 ${comment}${inline}${type} * ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
790   ${body}}
791 "
792         
793         
794         
795         
796       end
797
798       operation 165762 "RemoveNode"
799         preserve_cpp_body_indent public return_type class_ref 139778 // TreeMultiItemBase
800         nparams 1
801           param in name "index" explicit_type "int"
802         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
803 "
804         cpp_def "//------------------------------------------------------------
805
806 ${comment}${inline}${type} * ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
807   ${body}}
808 "
809         
810         
811         
812         
813       end
814
815       operation 165890 "GetNodeCount"
816         preserve_cpp_body_indent const public explicit_return_type "int"
817         nparams 0
818         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
819 "
820         cpp_def "//------------------------------------------------------------
821
822 ${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
823   ${body}}
824 "
825         
826         
827         
828         
829         comment " get methods"
830       end
831
832       operation 166018 "GetNode"
833         preserve_cpp_body_indent const public return_type class_ref 139778 // TreeMultiItemBase
834         nparams 1
835           param in name "index" explicit_type "int"
836         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
837 "
838         cpp_def "//------------------------------------------------------------
839
840 ${comment}${inline}${type} * ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
841   ${body}}
842 "
843         
844         
845         
846         
847       end
848
849       operation 166146 "Index"
850         preserve_cpp_body_indent const public explicit_return_type "int"
851         nparams 2
852           param inout name "node" type class_ref 139778 // TreeMultiItemBase
853           param in name "searchFromEnd" explicit_type "bool"
854             defaultvalue "false"
855         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
856 "
857         cpp_def "//------------------------------------------------------------
858
859 ${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
860   ${body}}
861 "
862         
863         
864         
865         
866       end
867
868       operation 166274 "GetNodeNext"
869         preserve_cpp_body_indent const public return_type class_ref 139778 // TreeMultiItemBase
870         nparams 1
871           param inout name "cookie" explicit_type "int"
872         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
873 "
874         cpp_def "//------------------------------------------------------------
875
876 ${comment}${inline}${type} * ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
877   ${body}}
878 "
879         
880         
881         
882         
883       end
884
885       operation 166402 "First"
886         preserve_cpp_body_indent const public return_type class_ref 139778 // TreeMultiItemBase
887         nparams 0
888         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
889 "
890         cpp_def "//------------------------------------------------------------
891
892
893 ${comment}${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
894   ${body}}
895 "
896         
897         
898         
899         
900       end
901
902       operation 166530 "Last"
903         preserve_cpp_body_indent const public return_type class_ref 139778 // TreeMultiItemBase
904         nparams 0
905         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
906 "
907         cpp_def "// TreeMultiItemNode::First() const 
908
909 ${comment}${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
910   ${body}}
911 "
912         
913         
914         
915         
916       end
917
918       operation 166658 "Fold"
919         cpp_inline public explicit_return_type "void"
920         nparams 1
921           param in name "expand" explicit_type "bool"
922         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
923                 if(_nodeExpanded != expand)
924                         _nodeExpanded = expand;
925         };
926 "
927         
928         
929         
930         
931         comment "* Fold function sets or clears the expanded flag. Note when excluded from drawing, this
932
933             will have no effect on redraw "
934       end
935
936       operation 166786 "GetCaption"
937         const cpp_inline public explicit_return_type "wxString"
938         nparams 0
939         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
940                 return _caption;
941         };
942 "
943         
944         
945         
946         
947         comment "* Return caption "
948       end
949
950       operation 166914 "IsExpanded"
951         const cpp_inline public explicit_return_type "bool"
952         nparams 0
953         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
954                 return _nodeExpanded;
955         };
956 "
957         
958         
959         
960         
961         comment "* Returns true if the node is expanded. Subnodes can still be collapsed though "
962       end
963     end
964
965     class 140034 "TreeMultiItemRoot"
966       visibility package 
967       cpp_decl "${comment}${template}class ${name}${inherit} {
968 ${members}};
969 ${inlines}
970 "
971       java_decl ""
972       php_decl ""
973       python_2_2 python_decl ""
974       idl_decl ""
975       explicit_switch_type ""
976       
977       comment "* This class is the root class. It can hold many of the TreeMultiItemWindow and
978
979  * TreeMultiItemNode classes.
980
981  "
982       classrelation 135426 // <generalisation>
983         relation 135426 ---|>
984           a public
985             cpp default "${type}"
986             classrelation_ref 135426 // <generalisation>
987           b parent class_ref 139906 // TreeMultiItemNode
988       end
989
990       operation 167042 "TreeMultiItemRoot"
991         preserve_cpp_body_indent public explicit_return_type ""
992         nparams 0
993         cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw};
994 "
995         cpp_def "//* TreeMultiItemRoot
996
997 // * This class is the class you use to create a tree. It contains all the
998
999 // * public methods from a TreeMultiItemNode, but you can add more to it 
1000
1001 // * because it is the root. A typical addition is the load entry for a 
1002
1003 // * directory, or other type of enumeration. You could store the base path
1004
1005 // * of a relative tree in this class.
1006
1007 // 
1008
1009 ${comment}${inline}${class}::${name}${(}${)}
1010
1011         : TreeMultiItemNode(0, _T(\"\"), _T(\"\"))
1012
1013 ${throw}{
1014 ${body}}
1015 "
1016         
1017         
1018         
1019         
1020       end
1021
1022       operation 167170 "~TreeMultiItemRoot"
1023         preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
1024         nparams 0
1025         cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
1026 "
1027         cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
1028 ${body}}
1029 "
1030         
1031         
1032         
1033         
1034       end
1035
1036       operation 167298 "IsTreeMultiItemRoot"
1037         const cpp_virtual cpp_inline public return_type class_ref 140034 // TreeMultiItemRoot
1038         nparams 0
1039         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1040
1041                 return (TreeMultiItemRoot *)this;
1042
1043         };
1044 "
1045         
1046         
1047         
1048         
1049         comment " IsClass method
1050 "
1051       end
1052     end
1053
1054     class 140162 "TreeMultiItemWindow"
1055       visibility package 
1056       cpp_decl "${comment}${template}class ${name}${inherit} {
1057 ${members}};
1058 ${inlines}
1059 "
1060       java_decl ""
1061       php_decl ""
1062       python_2_2 python_decl ""
1063       idl_decl ""
1064       explicit_switch_type ""
1065       
1066       classrelation 135554 // <generalisation>
1067         relation 135554 ---|>
1068           a public
1069             cpp default "${type}"
1070             classrelation_ref 135554 // <generalisation>
1071           b parent class_ref 139778 // TreeMultiItemBase
1072       end
1073
1074       classrelation 135682 // _window (<unidirectional association>)
1075         relation 135682 --->
1076           a role_name "_window" private
1077             cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
1078 "
1079             classrelation_ref 135682 // _window (<unidirectional association>)
1080           b parent class_ref 136322 // wxWindow
1081       end
1082
1083       attribute 141058 "_span"
1084         private explicit_type "bool"
1085         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
1086 "
1087         java_decl ""
1088         php_decl ""
1089         python_decl ""
1090         idl_decl ""
1091       end
1092
1093       operation 167426 "TreeMultiItemWindow"
1094         preserve_cpp_body_indent public explicit_return_type ""
1095         nparams 2
1096           param inout name "parent" type class_ref 139906 // TreeMultiItemNode
1097           param in name "name" explicit_type "wxString"
1098             defaultvalue "wxEmptyString"
1099         cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw};
1100 "
1101         cpp_def "//* TreeMultiItemWindow
1102
1103 //  *   This class is a possible end node for the tree. If you want multiple
1104
1105 //  *   types of end-nodes you should copy this file and adjust it with a 
1106
1107 //  *   different class name.
1108
1109 //  
1110
1111 ${comment}${inline}${class}::${name}${(}${t0} * ${p0}, const ${t1} & ${p1}${)}
1112
1113         :  TreeMultiItemBase(parent)
1114
1115         , _window(0)
1116
1117         , _topSpacing(0)
1118
1119         , _frontSpacing(0)
1120
1121         , _span(false)
1122
1123 ${throw}{
1124 ${body}}
1125 "
1126         
1127         
1128         
1129         
1130       end
1131
1132       operation 167554 "~TreeMultiItemWindow"
1133         preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
1134         nparams 0
1135         cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
1136 "
1137         cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
1138 ${body}}
1139 "
1140         
1141         
1142         
1143         
1144       end
1145
1146       operation 167682 "IsTreeMultiItemWindow"
1147         const cpp_virtual cpp_inline public return_type class_ref 140162 // TreeMultiItemWindow
1148         nparams 0
1149         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1150
1151                 return (TreeMultiItemWindow *)this;
1152
1153         };
1154 "
1155         
1156         
1157         
1158         
1159         comment " IsClass method
1160 "
1161       end
1162
1163       operation 167810 "AssignWindow"
1164         preserve_cpp_body_indent public explicit_return_type "void"
1165         nparams 1
1166           param inout name "wnd" type class_ref 136322 // wxWindow
1167         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
1168 "
1169         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
1170   ${body}}
1171 "
1172         
1173         
1174         
1175         
1176         comment "* Assigns the given window to this TreeMultiItemWindow, and also destroys the 
1177
1178                 present window. If the assigned window is 0, this item is not drawn
1179
1180                 and removed from the tree visually "
1181       end
1182
1183       operation 167938 "GetWindow"
1184         cpp_inline public return_type class_ref 136322 // wxWindow
1185         nparams 0
1186         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1187
1188                 return _window;
1189
1190         };
1191 "
1192         
1193         
1194         
1195         
1196         comment "* Get window method "
1197       end
1198
1199       operation 168066 "SetFrontSpacing"
1200         cpp_inline public explicit_return_type "void"
1201         nparams 1
1202           param in name "frontSpacing" explicit_type "int"
1203         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1204
1205                 _frontSpacing = frontSpacing;
1206
1207         };
1208 "
1209         
1210         
1211         
1212         
1213         comment " Sets front spacing "
1214       end
1215
1216       operation 168194 "GetFrontSpacing"
1217         const cpp_inline public explicit_return_type "int"
1218         nparams 0
1219         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1220
1221                 return _frontSpacing;
1222
1223         };
1224 "
1225         
1226         
1227         
1228         
1229         comment " Gets front spacing "
1230       end
1231
1232       operation 168322 "SetTopSpacing"
1233         cpp_inline public explicit_return_type "void"
1234         nparams 1
1235           param in name "topSpacing" explicit_type "int"
1236         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1237
1238                 _topSpacing = topSpacing;
1239
1240         };
1241 "
1242         
1243         
1244         
1245         
1246         comment " Sets top spacing "
1247       end
1248
1249       operation 168450 "GetTopSpacing"
1250         const cpp_inline public explicit_return_type "int"
1251         nparams 0
1252         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1253
1254                 return _topSpacing;
1255
1256         };
1257 "
1258         
1259         
1260         
1261         
1262         comment " Gets top spacing "
1263       end
1264
1265       operation 168578 "SetHorizontalSpan"
1266         cpp_inline public explicit_return_type "void"
1267         nparams 1
1268           param in name "span" explicit_type "bool"
1269         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1270
1271                 _span = span;
1272
1273         };
1274 "
1275         
1276         
1277         
1278         
1279         comment " Sets horizontal span, meaning when this is set the window
1280
1281            attached may be resized horizontally when the window is resized "
1282       end
1283
1284       operation 168706 "GetHorizontalSpan"
1285         const cpp_inline public explicit_return_type "bool"
1286         nparams 0
1287         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1288
1289                 return _span;
1290
1291         };
1292 "
1293         
1294         
1295         
1296         
1297         comment " Sets horizontal span, meaning when this is set the window
1298
1299            attached may be resized horizontally when the window is resized "
1300       end
1301
1302       operation 168834 "SetCheckboxState"
1303         preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
1304         nparams 1
1305           param in name "state" explicit_type "int"
1306         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
1307 "
1308         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
1309   ${body}}
1310 "
1311         
1312         
1313         
1314         
1315         comment "* Inherited from base, to enable or disable window "
1316       end
1317     end
1318
1319     class 140290 "anonymous1"
1320       visibility package stereotype "enum"
1321       cpp_decl "${comment}enum  {
1322 ${items}
1323 };
1324 "
1325       java_decl ""
1326       php_decl ""
1327       python_2_2 python_decl ""
1328       idl_decl ""
1329       explicit_switch_type ""
1330       
1331       comment "* \\defgroup hitflags wxTreeMultiCtrl HitTest flags
1332     @{
1333 "
1334       attribute 141186 "wxTMC_HITTEST_GUTTER"
1335         public type class_ref 140290 // anonymous1
1336         init_value "= 1"
1337         cpp_decl "  ${name}${value},${comment}"
1338         java_decl ""
1339         php_decl ""
1340         python_decl ""
1341         idl_decl ""
1342       end
1343
1344       attribute 141314 "wxTMC_HITTEST_WINDOW"
1345         public type class_ref 140290 // anonymous1
1346         cpp_decl "  ${name}${value},${comment}"
1347         java_decl ""
1348         php_decl ""
1349         python_decl ""
1350         idl_decl ""
1351       end
1352
1353       attribute 141442 "wxTMC_HITTEST_CAPTION"
1354         public type class_ref 140290 // anonymous1
1355         cpp_decl "  ${name}${value},${comment}"
1356         java_decl ""
1357         php_decl ""
1358         python_decl ""
1359         idl_decl ""
1360       end
1361
1362       attribute 141570 "wxTMC_HITTEST_CHECKBOX"
1363         public type class_ref 140290 // anonymous1
1364         cpp_decl "  ${name}${value},${comment}"
1365         java_decl ""
1366         php_decl ""
1367         python_decl ""
1368         idl_decl ""
1369       end
1370     end
1371
1372     class 140418 "wxTreeMultiItem"
1373       visibility package 
1374       cpp_decl "${comment}${template}class ${name}${inherit} {
1375 ${members}};
1376 ${inlines}
1377 "
1378       java_decl ""
1379       php_decl ""
1380       python_2_2 python_decl ""
1381       idl_decl ""
1382       explicit_switch_type ""
1383       
1384       comment "/ wxCoord was found in the gutter of the node (in front of the [+])
1385 / wxCoord was found inside a window, or behind it, on a Window node
1386 / wxCoord was found on a caption of a Node or Root item
1387 / wxCoord was found on a checkbox (only when item really has a checkbox)
1388 * @}
1389
1390 * @defgroup classes wxTreeMultiCtrl Classes
1391     These classes are all the available classes in the wxTreeMultiCtrl you should know about.
1392     @{
1393
1394     @}
1395
1396 * \\class wxTreeMultiItem
1397     \\ingroup classes
1398     \\brief An intermediate class which is used to return as 'item' value for the wxTreeMultiCtrl. This class
1399     is comparable with wxTreeItemId.
1400
1401     The wxTreeMultiItem is used to pass information to the user about the tree node in question. It can also be used point out where the
1402     subnodes should be added.
1403
1404     For example:
1405     \\code
1406
1407         wxTreeMultiItem item = MyMultiTreeCtrl->AddRoot(\"This is the first root\");
1408
1409         // now add a node to the root
1410         if(item.IsOk())
1411             MyMultiTreeCtrl->AppendWindow(item, new wxStaticText(MyMultiTreeCtrl, -1, \"This is a static text\");
1412
1413
1414     \\endcode
1415
1416     The wxTreeMultiItem comes in three internal types which are used in the wxTreeMultiCtrl. For functions such as
1417     wxTreeMultiCtrl::AddRoot, a Root item is returned. For functions such as wxTreeMultiCtrl::AppendWindow, a
1418     Window node is returned. For functions such as wxTreeMultiCtrl::AppendNode, a Node item is returned.
1419
1420     \\li A Root item represents a top level item. Special operations on this item is adding multiple nodes to it from a
1421     top level.
1422
1423     \\li A Node item represents a container item which has multiple sub items which can both be Window items, or Node items.
1424     A root item is a special type of Node item, so all operations which are only for Node items, are also for Root items.
1425
1426     \\li A Window node represents an end node, which points to a wxWindow which represents the visual contents of this node.
1427     This type of node can hold any wxWindow derived class.
1428
1429 "
1430       classrelation 135810 // _item (<unidirectional association>)
1431         relation 135810 --->
1432           a role_name "_item" private
1433             cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
1434 "
1435             classrelation_ref 135810 // _item (<unidirectional association>)
1436           b parent class_ref 139778 // TreeMultiItemBase
1437       end
1438
1439       operation 168962 "wxTreeMultiItem"
1440         cpp_inline public explicit_return_type ""
1441         nparams 0
1442         cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} {
1443         _item = 0;
1444     };
1445 "
1446         
1447         
1448         
1449         
1450         comment "* Default declaration constructor, and should be used when declaring an item which gets assigned a new
1451         value by e.g. wxTreeMultiCtrl::AppendNode. "
1452       end
1453
1454       operation 169090 "wxTreeMultiItem"
1455         cpp_inline public explicit_return_type ""
1456         nparams 1
1457           param inout name "ptr" type class_ref 139778 // TreeMultiItemBase
1458         cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}${)}${volatile}${throw} {
1459         _item = ptr;
1460     };
1461 "
1462         
1463         
1464         
1465         
1466       end
1467
1468       operation 169218 "GetItem"
1469         const cpp_inline public return_type class_ref 139778 // TreeMultiItemBase
1470         nparams 0
1471         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1472
1473         return _item;
1474
1475     };
1476 "
1477         
1478         
1479         
1480         
1481         comment " Returns the TreeMultiItemBase class. This shoult *NOT* be
1482
1483  used if you don't know what you are doing! This means never use it. */
1484 "
1485       end
1486
1487       operation 169346 "operator ="
1488         cpp_inline public explicit_return_type "void"
1489         nparams 1
1490           param in name "item" type class_ref 140418 // wxTreeMultiItem
1491         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1492         _item = item._item;
1493
1494     };
1495 "
1496         
1497         
1498         
1499         
1500         comment "* The copy operator. Used in assigning one wxTreeMultiItem to another, usually in returning wxTreeMultiItem
1501         classes from the wxTreeMultiCtrl.
1502     "
1503       end
1504
1505       operation 169474 "operator =="
1506         const cpp_inline public explicit_return_type "bool"
1507         nparams 1
1508           param in name "item" type class_ref 140418 // wxTreeMultiItem
1509         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return (this->GetItem() == item.GetItem());};
1510 "
1511         
1512         
1513         
1514         
1515         comment "* Equality operator. It returns true if the items are identical or if both items are invalid. "
1516       end
1517
1518       operation 169602 "operator !="
1519         const cpp_inline public explicit_return_type "bool"
1520         nparams 1
1521           param in name "item" type class_ref 140418 // wxTreeMultiItem
1522         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return (this->GetItem() != item.GetItem());};
1523 "
1524         
1525         
1526         
1527         
1528         comment "* Inequality operator. It returns true if the items are different or one of them is invalid. "
1529       end
1530
1531       operation 169730 "GetParent"
1532         const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
1533         nparams 0
1534         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1535
1536                 wxCHECK(IsOk(), wxTreeMultiItem(0));
1537
1538                 return wxTreeMultiItem(_item->GetParent());
1539
1540         };
1541 "
1542         
1543         
1544         
1545         
1546         comment "* Returns the parent of the current wxTreeMultiItem. This means the wxTreeMultiNode is returned. It can
1547
1548             be useful to check or clear the checkbox at this level. "
1549       end
1550
1551       operation 169858 "IsOk"
1552         const cpp_inline public explicit_return_type "bool"
1553         nparams 0
1554         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1555         return _item != 0;
1556     };
1557 "
1558         
1559         
1560         
1561         
1562         comment "* Validates if the wxTreeMultiItem is a valid instance to use in the wxTreeMultiCtrl. Returns TRUE when there
1563         is a member value is associated with it, or FALSE when not. This value can also be checked when this class is returned from a wxTreeMultiCtrl operation. For example:
1564
1565         \\code
1566
1567             wxTreeMultiItem item = MyTreeMultiCtrl->FindNode(\"NAME\");
1568             if(item.IsOk())
1569             {
1570                 // Found the node, now do something with it
1571             }
1572             else
1573             {
1574                 // Sorry, not found
1575             }
1576
1577         \\endcode
1578
1579     "
1580       end
1581
1582       operation 169986 "IsWindowItem"
1583         const cpp_inline public explicit_return_type "bool"
1584         nparams 0
1585         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1586         if(_item && _item->IsTreeMultiItemWindow())
1587             return true;
1588         return false;
1589     };
1590 "
1591         
1592         
1593         
1594         
1595         comment "* Returns TRUE when the wxTreeMultiItem is a Window item. This means the item is both valid, and points to a
1596         window node. This means it can be used in functions that expect a Window node. If the item is invalid or a Window
1597         item, FALSE is returned
1598         \\sa wxTreeMultiCtrl::AppendWindow
1599     "
1600       end
1601
1602       operation 170114 "IsNodeItem"
1603         const cpp_inline public explicit_return_type "bool"
1604         nparams 0
1605         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1606         if(_item && (_item->IsTreeMultiItemNode() || _item->IsTreeMultiItemRoot()))
1607             return true;
1608         return false;
1609     };
1610 "
1611         
1612         
1613         
1614         
1615         comment "* Returns TRUE when the wxTreeMultiItem is a Node item. This means the item is both valid, and points to a
1616         node element (i.e. setting the caption, counting node children, etc). If the item is invalid or not a Node
1617         item, FALSE is returned.
1618         When the item is actually a root item (specialised node type), this also returns TRUE.
1619         \\sa wxTreeMultiCtrl::AppendNode wxTreeMultiCtrl::AddRoot
1620     "
1621       end
1622
1623       operation 170242 "IsRootItem"
1624         const cpp_inline public explicit_return_type "bool"
1625         nparams 0
1626         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1627         if(_item && _item->IsTreeMultiItemRoot())
1628             return true;
1629         return false;
1630     };
1631 "
1632         
1633         
1634         
1635         
1636         comment "* Returns True when the wxTreeMultiItem is a Root (top node) item. This means the item is both valid,
1637         and points to a root element (this item is always shown as first node in the tree). A root node is
1638         always visible, but can contain other collapsed children. If the item is invalid or not a Root node,
1639         FALSE is returned.
1640     "
1641       end
1642
1643       operation 170370 "IsExpanded"
1644         const cpp_inline public explicit_return_type "bool"
1645         nparams 0
1646         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1647         wxCHECK(_item, false);
1648         TreeMultiItemNode *n = _item->IsTreeMultiItemNode();
1649         wxCHECK(n, false);
1650
1651         return n->IsExpanded();
1652     };
1653 "
1654         
1655         
1656         
1657         
1658         comment "* Returns TRUE if the node is expanded, else FALSE if it is collapsed. If the item is not a Root or Node
1659         item, an assertion failure is generated (in debug mode) or FALSE is returned (in release mode).
1660
1661         \\sa wxTreeMultiCtrl::Expand, wxTreeMultiCtrl::Collapse, wxTreeMultiCtrl::CollapseAndReset
1662     "
1663       end
1664
1665       operation 170498 "IsExcluded"
1666         cpp_inline public explicit_return_type "bool"
1667         nparams 0
1668         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1669         wxCHECK(_item, false);
1670         return _item->IsExcluded();
1671
1672     };
1673 "
1674         
1675         
1676         
1677         
1678         comment "* Returns true if this node is excluded from drawing. Please note that when this node is not visible
1679         due to a higher excluded parent node but not literally excluded itself, it will return false (not excluded).
1680         Use wxTreeMultiCtrl::GetExcludedParent() to get the node that hides this one. "
1681       end
1682
1683       operation 170626 "IsSelected"
1684         const cpp_inline public explicit_return_type "bool"
1685         nparams 1
1686           param in name "" explicit_type "void"
1687         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1688
1689       wxCHECK(this->GetItem(),false);
1690
1691       return this->GetItem()->IsSelected();
1692
1693     };
1694 "
1695         
1696         
1697         
1698         
1699         comment "* Returns true if the item is selected.
1700
1701        Please note that currently only nodes can be selected.
1702
1703    "
1704       end
1705
1706       operation 170754 "IsVisible"
1707         cpp_inline public explicit_return_type "bool"
1708         nparams 0
1709         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1710         wxCHECK(_item, false);
1711         return _item->IsVisible();
1712     };
1713 "
1714         
1715         
1716         
1717         
1718         comment "* Returns true if this node is visible. Please note that when this node is a child node of a collapsed
1719
1720         node, it is not visible. Also if this node is a child node of an excluded node, it is also not visible.
1721
1722         It does <b>NOT</b> return false when it's drawn somewhere outside of the visible area. "
1723       end
1724     end
1725
1726     class 140546 "wxTreeMultiWindowInfo"
1727       visibility package 
1728       cpp_decl "${comment}${template}class ${name}${inherit} {
1729 ${members}};
1730 ${inlines}
1731 "
1732       java_decl ""
1733       php_decl ""
1734       python_2_2 python_decl ""
1735       idl_decl ""
1736       explicit_switch_type ""
1737       
1738       comment "* \\class wxTreeMultiWindowInfo
1739
1740     \\ingroup classes
1741
1742     \\brief This class contains information for every Window node to be added.
1743
1744
1745     This class can be used to modify the behaviour of the Window node to be added, and can be reused to pass along
1746     upon every wxTreeMultiCtrl::AppendWindow call. For example:
1747
1748     \\code
1749
1750         wxTreeMultiWindowInfo wndinfo;
1751
1752         MyTreeMultiCtrl->AppendWindow(item, new wxStaticText(MyTreeMultiCtrl,
1753                                       -1, \"Press this button\"), \"\", wndinfo));
1754
1755         // now adjust the spacing of our next window to add, by indenting
1756         // 4 times the indent size
1757
1758         wndinfo.Indent(4);
1759         MyTreeMultiCtrl->AppendWindow(item, new wxButton(MyTreeMultiCtrl,
1760                                       -1, \"Apply\"), \"\", wndinfo);
1761
1762     \\endcode
1763
1764     The class is created to prevent long parameter lists in the functions. Other ways to manipulate a newly added
1765     Window node are;
1766
1767     \\li Change top spacing of the Window node to be added
1768     \\li Change front spacing (indent) of the Window node
1769     \\li Set extra flags for this Window node
1770
1771 -------------------------------------------------------------------------------------------------------------------"
1772       attribute 141698 "_flags"
1773         private explicit_type "int"
1774         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
1775 "
1776         java_decl ""
1777         php_decl ""
1778         python_decl ""
1779         idl_decl ""
1780       end
1781
1782       attribute 141826 "_topSpacing"
1783         private explicit_type "int"
1784         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
1785 "
1786         java_decl ""
1787         php_decl ""
1788         python_decl ""
1789         idl_decl ""
1790       end
1791
1792       attribute 141954 "_checkState"
1793         private explicit_type "bool"
1794         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
1795 "
1796         java_decl ""
1797         php_decl ""
1798         python_decl ""
1799         idl_decl ""
1800       end
1801
1802       operation 170882 "wxTreeMultiWindowInfo"
1803         cpp_inline public explicit_return_type ""
1804         nparams 4
1805           param in name "flags" explicit_type "int"
1806           param in name "frontSpacing" explicit_type "int"
1807           param in name "topSpacing" explicit_type "int"
1808           param in name "checkState" explicit_type "bool"
1809             defaultvalue "false"
1810         cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}${)}${volatile}${throw} : _flags(flags)
1811
1812         , _frontSpacing(frontSpacing)
1813
1814         , _frontSpacingOrg(frontSpacing)
1815
1816         , _topSpacing(topSpacing)
1817
1818         , _checkState(checkState)
1819
1820 #else
1821
1822     wxTreeMultiWindowInfo(int flags, int frontSpacing, int topSpacing)
1823
1824         : _flags(flags)
1825
1826         , _frontSpacing(frontSpacing)
1827
1828         , _frontSpacingOrg(frontSpacing)
1829
1830         , _topSpacing(topSpacing)
1831
1832 #endif
1833
1834     {
1835
1836         // constructor
1837
1838     };
1839 "
1840         
1841         
1842         
1843         
1844       end
1845
1846       operation 171010 "Indent"
1847         cpp_inline public explicit_return_type "int"
1848         nparams 1
1849           param in name "num" explicit_type "int"
1850             defaultvalue "1"
1851         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1852         if(num > 0)
1853             _frontSpacing += (_frontSpacingOrg * num);
1854         return _frontSpacing;
1855     };
1856 "
1857         
1858         
1859         
1860         
1861         comment "* Adds indent to original front spacing and increments it with that value (quick extra indent).
1862         The original value of FrontSpacing (see SetFrontSpacing() gets indented by multiplying
1863         the 'num' factor (default = 1) times the indent value. So if the FrontSpacing was set to 10,
1864         and Indent(2) is called, the new indent will be 30. (10 + 2 * 10). The original FrontSpacing
1865         value is remembered, so calling Outdent(2) will bring it back to 10 (30 - (2*10). Calling
1866         SetFrontSpacing with a new value, deletes the old indent.
1867
1868         \\sa Outdent, SetFrontSpacing
1869     "
1870       end
1871
1872       operation 171138 "Outdent"
1873         cpp_inline public explicit_return_type "int"
1874         nparams 1
1875           param in name "num" explicit_type "int"
1876             defaultvalue "1"
1877         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1878         _frontSpacing -= (_frontSpacingOrg * num);
1879         if(_frontSpacing < 0)
1880             _frontSpacing = 0;
1881         return _frontSpacing;
1882     };
1883 "
1884         
1885         
1886         
1887         
1888         comment "* Reduces indent a number of times, by subtracting 'num' times the original FrontSpacing value from
1889         the current FrontSpacing value (quick extra indent). Thus if the original FrontSpacing was set to
1890         10, and the current indent value is 40, Outdent(2) will do 40 - (2 * 10) = 20
1891
1892         \\sa Indent, SetFrontSpacing
1893     "
1894       end
1895
1896       operation 171266 "SetFrontSpacing"
1897         cpp_inline public explicit_return_type "void"
1898         nparams 1
1899           param in name "frontSpacing" explicit_type "int"
1900         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1901         _frontSpacing = frontSpacing;
1902         _frontSpacingOrg = frontSpacing;
1903     };
1904 "
1905         
1906         
1907         
1908         
1909         comment "* Sets FrontSpacing value. This also resets the current indent level.  "
1910       end
1911
1912       operation 171394 "GetFrontSpacing"
1913         const cpp_inline public explicit_return_type "int"
1914         nparams 0
1915         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1916         return _frontSpacing;
1917     };
1918 "
1919         
1920         
1921         
1922         
1923         comment "* Gets front spacing. This will return the current indent level set. If Indent or Outdent is used,
1924         this level represents the current Indent level."
1925       end
1926
1927       operation 171522 "SetTopSpacing"
1928         cpp_inline public explicit_return_type "void"
1929         nparams 1
1930           param in name "topSpacing" explicit_type "int"
1931         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1932         _topSpacing = topSpacing;
1933         if(_topSpacing < 0)
1934             _topSpacing = 0;
1935     };
1936 "
1937         
1938         
1939         
1940         
1941         comment "* Sets top spacing. This means the number of pixels spacing between the last node and the next one to
1942         be added.
1943     "
1944       end
1945
1946       operation 171650 "GetTopSpacing"
1947         const cpp_inline public explicit_return_type "int"
1948         nparams 0
1949         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1950         return _topSpacing;
1951     };
1952 "
1953         
1954         
1955         
1956         
1957         comment " Gets top spacing currently set. "
1958       end
1959
1960       operation 171778 "SetFlags"
1961         cpp_inline public explicit_return_type "int"
1962         nparams 1
1963           param in name "flags" explicit_type "int"
1964         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
1965         int tmp = _flags;
1966         _flags = flags;
1967         return tmp;
1968     };
1969 "
1970         
1971         
1972         
1973         
1974         comment "* Sets the current flags set, and returns previous flags state.
1975         \\sa @link wndflags wxTreeMultiWindowInfo flags@endlink
1976     "
1977       end
1978
1979       operation 171906 "GetFlags"
1980         const cpp_inline public explicit_return_type "int"
1981         nparams 0
1982         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
1983         return _flags;
1984     };
1985 "
1986         
1987         
1988         
1989         
1990         comment "* Gets the current flags set.
1991         \\sa @link wndflags wxTreeMultiWindowInfo flags@endlink
1992     "
1993       end
1994
1995       operation 172034 "AddFlag"
1996         cpp_inline public explicit_return_type "int"
1997         nparams 1
1998           param in name "flag_mask" explicit_type "int"
1999         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
2000         int tmp = _flags;
2001         _flags |= flag_mask;
2002         return tmp;
2003     };
2004 "
2005         
2006         
2007         
2008         
2009         comment "* Or's the given flag with the current flagset, and adds it. The
2010         old flag set is returned before the OR is applied.
2011         \\sa @link wndflags wxTreeMultiWindowInfo flags@endlink
2012     "
2013       end
2014
2015       operation 172162 "RemoveFlag"
2016         cpp_inline public explicit_return_type "int"
2017         nparams 1
2018           param in name "flag_mask" explicit_type "int"
2019         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
2020         int tmp = _flags;
2021         _flags &= ~(flag_mask);
2022         return tmp;
2023     };
2024 "
2025         
2026         
2027         
2028         
2029         comment "* And's the given flag in a negated manner and removes this flag set from
2030         the current flags.  The old flag set is returned.
2031         \\sa @link wndflags wxTreeMultiWindowInfo flags@endlink
2032     "
2033       end
2034
2035       operation 172290 "SetDefaultCheckState"
2036         cpp_inline public explicit_return_type "void"
2037         nparams 1
2038           param in name "checkState" explicit_type "bool"
2039             defaultvalue "true"
2040         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
2041         _checkState = checkState;
2042     };
2043 "
2044         
2045         
2046         
2047         
2048         comment "* Sets the default checkstate if checkboxes if SetCheckboxView is chosen. For all the
2049         items to be added (even captions) this checkstate is chosen. The default checkstate
2050         is false. <b>This needs USE_CHECKBOXVIEW set to YES, or CHECKBOXVIEW=1 during compile</b> "
2051       end
2052
2053       operation 172418 "GetDefaultCheckState"
2054         const cpp_inline public explicit_return_type "bool"
2055         nparams 0
2056         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
2057         return _checkState;
2058     };
2059 "
2060         
2061         
2062         
2063         
2064         comment "* Gets the default checkstate of the item. <b>This needs USE_CHECKBOXVIEW set to YES, or CHECKBOXVIEW=1 during compile</b>
2065         \\sa SetDefaultCheckState "
2066       end
2067     end
2068
2069     class 140674 "wxTreeMultiCtrl"
2070       visibility package 
2071       cpp_decl "${comment}${template}class ${name}${inherit} {
2072 ${members}};
2073 ${inlines}
2074 "
2075       java_decl ""
2076       php_decl ""
2077       python_2_2 python_decl ""
2078       idl_decl ""
2079       explicit_switch_type ""
2080       
2081       comment "* \\class wxTreeMultiCtrl
2082     \\ingroup classes
2083     \\brief This is the visual control, which will contain all the logic for the tree mechanism.
2084
2085     The wxTreeMultiCtrl is the container class which can be filled in to get the tree shaped structure in
2086     which the controls are displayed. The user can add / delete new nodes at runtime, expand or collapse
2087     nodes, perform get or set actions on the controls inside, and iterate over the items.
2088
2089     A typical usage of the wxTreeCtrl is;
2090
2091     \\code
2092     wxTreeMultiCtrl *tmc = new wxTreeMultiCtrl(this, -1);
2093
2094     // add root
2095     wxTreeMultiItem item = tmc->AddRoot(\"This is the first root\");
2096
2097     // create a wxTreeMultiWindowInfo object for indenting etc
2098     wxTreeMultiWindowInfo wndinfo;
2099
2100     // add subitem to root
2101     tmc->AppendWindow(item, new wxButton(tmc, -1, \"Press this\"), \"\", wndinfo);
2102
2103     // indent a few
2104     wndinfo.Indent(4);
2105
2106     // add a new one
2107     tmc->AddWindow(item, new wxCheckBox(tmc, ID_MYCHECK, \"Check this!\"), \"\", wndinfo);
2108
2109     // now check the value of the checkbox
2110     tmc->SetBooleanValue(ID_MYCHECK, true);
2111
2112     \\endcode
2113
2114     <b>IMPORTANT:</b> Every control added to the wxTreeMultiCtrl has to be child of the wxTreeMultiCtrl.
2115
2116 "
2117       classrelation 135938 // <generalisation>
2118         relation 135938 ---|>
2119           a public
2120             cpp default "${type}"
2121             classrelation_ref 135938 // <generalisation>
2122           b parent class_ref 140802 // typedef23
2123       end
2124
2125       attribute 142082 "_style"
2126         private explicit_type "long"
2127         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2128 "
2129         java_decl ""
2130         php_decl ""
2131         python_decl ""
2132         idl_decl ""
2133       end
2134
2135       attribute 142210 "_captionHeight"
2136         private explicit_type "int"
2137         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2138 "
2139         java_decl ""
2140         php_decl ""
2141         python_decl ""
2142         idl_decl ""
2143       end
2144
2145       attribute 142338 "_gutterWidth"
2146         private explicit_type "int"
2147         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2148 "
2149         java_decl ""
2150         php_decl ""
2151         python_decl ""
2152         idl_decl ""
2153       end
2154
2155       attribute 142466 "_iconWidth"
2156         private explicit_type "int"
2157         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2158 "
2159         java_decl ""
2160         php_decl ""
2161         python_decl ""
2162         idl_decl ""
2163       end
2164
2165       attribute 142594 "_iconHeight"
2166         private explicit_type "int"
2167         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2168 "
2169         java_decl ""
2170         php_decl ""
2171         python_decl ""
2172         idl_decl ""
2173       end
2174
2175       attribute 142722 "_maxHeight"
2176         private explicit_type "int"
2177         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2178 "
2179         java_decl ""
2180         php_decl ""
2181         python_decl ""
2182         idl_decl ""
2183       end
2184
2185       attribute 142850 "_spacingY"
2186         private explicit_type "int"
2187         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2188 "
2189         java_decl ""
2190         php_decl ""
2191         python_decl ""
2192         idl_decl ""
2193       end
2194
2195       attribute 142978 "_create_called"
2196         private explicit_type "bool"
2197         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2198 "
2199         java_decl ""
2200         php_decl ""
2201         python_decl ""
2202         idl_decl ""
2203       end
2204
2205       attribute 143106 "_checkboxView"
2206         private explicit_type "bool"
2207         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2208 "
2209         java_decl ""
2210         php_decl ""
2211         python_decl ""
2212         idl_decl ""
2213       end
2214
2215       attribute 143234 "m_HilightBrush"
2216         private explicit_type "wxBrush"
2217         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
2218 "
2219         java_decl ""
2220         php_decl ""
2221         python_decl ""
2222         idl_decl ""
2223       end
2224
2225       attribute 143362 "_captionFont"
2226         private explicit_type "wxFont"
2227         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2228 "
2229         java_decl ""
2230         php_decl ""
2231         python_decl ""
2232         idl_decl ""
2233       end
2234
2235       attribute 143490 "m_SelectedItems"
2236         private explicit_type "wxArrayTreeMultiItem"
2237         cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
2238 "
2239         java_decl ""
2240         php_decl ""
2241         python_decl ""
2242         idl_decl ""
2243       end
2244
2245       operation 172546 "DoFold"
2246         preserve_cpp_body_indent private explicit_return_type "void"
2247         nparams 3
2248           param inout name "item" type class_ref 139778 // TreeMultiItemBase
2249           param in name "expand" explicit_type "bool"
2250           param in name "recursive" explicit_type "bool"
2251         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
2252 "
2253         cpp_def "// wxTreeMultiCtrl::Unselect(wxTreeMultiItem const&) 
2254
2255 ${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
2256   ${body}}
2257 "
2258         
2259         
2260         
2261         
2262         comment "* Does the actual collapsing / expanding. So that Expand and Collapse aren't using the same code twice "
2263       end
2264
2265       operation 172674 "RedrawFromNode"
2266         preserve_cpp_body_indent private explicit_return_type "void"
2267         nparams 1
2268           param inout name "n" type class_ref 139906 // TreeMultiItemNode
2269         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2270 "
2271         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
2272   ${body}}
2273 "
2274         
2275         
2276         
2277         
2278         comment "* Redraws and recalculates the nodes from the current node. It will also clear all 'dirty' flags when
2279         they are recalculated "
2280       end
2281
2282       operation 172802 "RedrawFromParentNode"
2283         preserve_cpp_body_indent private explicit_return_type "void"
2284         nparams 1
2285           param inout name "n" type class_ref 139778 // TreeMultiItemBase
2286         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2287 "
2288         cpp_def "// wxTreeMultiCtrl::InsertWindow(TreeMultiItemNode*, size_t, wxWindow*, wxString const&, wxTreeMultiWindowInfo const&, int) 
2289
2290 ${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
2291   ${body}}
2292 "
2293         
2294         
2295         
2296         
2297         comment "* Redraws from parent node of this node "
2298       end
2299
2300       operation 172930 "DrawCheckbox"
2301         preserve_cpp_body_indent private explicit_return_type "void"
2302         nparams 3
2303           param inout name "b" type class_ref 139778 // TreeMultiItemBase
2304           param inout name "dc" explicit_type "wxDC"
2305           param in name "convertScrolled" explicit_type "bool"
2306             defaultvalue "false"
2307         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} & ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
2308 "
2309         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} & ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
2310   ${body}}
2311 "
2312         
2313         
2314         
2315         
2316         comment "* Draws checkbox belonging to this node, in the given state "
2317       end
2318
2319       operation 173058 "RecalculateNodePositions"
2320         preserve_cpp_body_indent private explicit_return_type "void"
2321         nparams 0
2322         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
2323 "
2324         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
2325   ${body}}
2326 "
2327         
2328         
2329         
2330         
2331         comment "* Recalculate the space needed based on every node. It goes as follows.
2332         - A foldable node (TreeMultiItemNode) is as high as the 'Jg' y-size. This type only has a caption plus a
2333           picture which explains the state ([+] or [-]), the width will be the caption length
2334         - A window node will be as high as the y size of the window. The X size is the total length of the
2335           window.
2336         - For every child node an indent will be added to the x size.
2337
2338         Only visible nodes will be recalculated. Non visible (collapsed) children will be skipped  "
2339       end
2340
2341       operation 173186 "CalculateNodeDimensions"
2342         preserve_cpp_body_indent private explicit_return_type "int"
2343         nparams 3
2344           param inout name "b" type class_ref 139778 // TreeMultiItemBase
2345           param in name "currentY" explicit_type "int"
2346           param in name "level" explicit_type "int"
2347         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
2348 "
2349         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
2350   ${body}}
2351 "
2352         
2353         
2354         
2355         
2356         comment "* Recurses into the whole tree and provides every node with the proper x and y values. All non visible items
2357         are skipped (so when it encounters a collapsed node, it's children are not calculated). Returns the last Y "
2358       end
2359
2360       operation 173314 "DrawNode"
2361         preserve_cpp_body_indent private explicit_return_type "void"
2362         nparams 2
2363           param inout name "b" type class_ref 139778 // TreeMultiItemBase
2364           param inout name "dc" explicit_type "wxDC"
2365         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
2366 "
2367         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
2368   ${body}}
2369 "
2370         
2371         
2372         
2373         
2374       end
2375
2376       operation 173442 "SetWindowBackgroundColour"
2377         preserve_cpp_body_indent private explicit_return_type "void"
2378         nparams 3
2379           param inout name "wnd" type class_ref 136322 // wxWindow
2380           param in name "col" explicit_type "wxColour"
2381           param in name "flags" explicit_type "int"
2382         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
2383 "
2384         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, const ${t1} & ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
2385   ${body}}
2386 "
2387         
2388         
2389         
2390         
2391         comment "* Sets background colour of all the windows and subwindows in this wxWindow. This is very handy
2392         for wxPanel derived classes which need to be made equal to the background colour of the wxTreeMultiCtrl "
2393       end
2394
2395       operation 173570 "ShowTreeMultiWindow"
2396         preserve_cpp_body_indent private explicit_return_type "void"
2397         nparams 2
2398           param inout name "window" type class_ref 140162 // TreeMultiItemWindow
2399           param in name "show" explicit_type "bool"
2400             defaultvalue "true"
2401         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
2402 "
2403         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
2404   ${body}}
2405 "
2406         
2407         
2408         
2409         
2410         comment "* Shows or hides the assigned window (if there is any) "
2411       end
2412
2413       operation 173698 "UpdateAllWindowVisibility"
2414         preserve_cpp_body_indent private explicit_return_type "void"
2415         nparams 0
2416         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
2417 "
2418         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
2419   ${body}}
2420 "
2421         
2422         
2423         
2424         
2425         comment "* Goes down the tree, and if a window is not visible (thus all it's children aren't too) it will hide
2426         the window so it is not shown on the control "
2427       end
2428
2429       operation 173826 "UpdateTreeMultiWindowVisibility"
2430         preserve_cpp_body_indent private explicit_return_type "void"
2431         nparams 2
2432           param inout name "b" type class_ref 139778 // TreeMultiItemBase
2433           param in name "show" explicit_type "bool"
2434         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
2435 "
2436         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
2437   ${body}}
2438 "
2439         
2440         
2441         
2442         
2443         comment "* Hides tree multi window. It this is a TreeMultiItemNode, hide all subwindows as well. "
2444       end
2445
2446       operation 173954 "RecalculateVirtualSize"
2447         preserve_cpp_body_indent private explicit_return_type "void"
2448         nparams 0
2449         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
2450 "
2451         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
2452   ${body}}
2453 "
2454         
2455         
2456         
2457         
2458         comment "* Recalculates totally needed virtual size of the wxTreeMultiCtrl. It will scan for
2459         the largest window, with the biggest size, and report that back "
2460       end
2461
2462       extra_member 128258 "using"
2463         
2464         cpp "  using wxScrolledWindow::AdjustScrollbars;" ""
2465         java ""
2466         php ""
2467         python ""
2468         idl ""
2469       end
2470
2471       operation 174082 "AdjustScrollbars"
2472         preserve_cpp_body_indent cpp_virtual private explicit_return_type "void"
2473         nparams 2
2474           param in name "x" explicit_type "int"
2475           param in name "y" explicit_type "int"
2476         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
2477 "
2478         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
2479   ${body}}
2480 "
2481         
2482         
2483         
2484         
2485       end
2486
2487       operation 174210 "RecalculateVirtualSizeFromNode"
2488         preserve_cpp_body_indent private explicit_return_type "void"
2489         nparams 3
2490           param in name "node" type class_ref 139906 // TreeMultiItemNode
2491           param inout name "x" explicit_type "int"
2492           param inout name "y" explicit_type "int"
2493         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} * ${p0}${v0}, ${t1} & ${p1}${v1}, ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
2494 "
2495         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} * ${p0}, ${t1} & ${p1}, ${t2} & ${p2}${)}${const}${throw}${staticnl}{
2496   ${body}}
2497 "
2498         
2499         
2500         
2501         
2502         comment "* Recalculates and accumulates largest x and y "
2503       end
2504
2505       operation 174338 "FindNodeByPoint"
2506         preserve_cpp_body_indent private return_type class_ref 139778 // TreeMultiItemBase
2507         nparams 3
2508           param inout name "b" type class_ref 139778 // TreeMultiItemBase
2509           param in name "pt" explicit_type "wxPoint"
2510           param inout name "area" explicit_type "int"
2511         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
2512 "
2513         cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${t0} * ${p0}, const ${t1} & ${p1}, ${t2} & ${p2}${)}${const}${throw}${staticnl}{
2514   ${body}}
2515 "
2516         
2517         
2518         
2519         
2520         comment "* Scans for TreeMultiItemBase node that contains x,y and in area returns a hittest constant to
2521
2522         indicate what matched "
2523       end
2524
2525       operation 174466 "FindWindowNode"
2526         preserve_cpp_body_indent private return_type class_ref 140418 // wxTreeMultiItem
2527         nparams 2
2528           param inout name "wnd" type class_ref 136322 // wxWindow
2529           param inout name "n" type class_ref 139906 // TreeMultiItemNode
2530             defaultvalue "0"
2531         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
2532 "
2533         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} * ${p1}${)}${const}${volatile}${throw}${staticnl}{
2534   ${body}}
2535 "
2536         
2537         
2538         
2539         
2540         comment "* Scans for TreeMultiItemWindow that holds the wxWindow pointer. Does not scan in panels or does
2541
2542         a deep search. Reason, this function is used to advance to next TreeMultiItemWindow for focus
2543
2544         on this wxScrolledWindow. If a sub window is found, it will skip other windows on that same level "
2545       end
2546
2547       operation 174594 "FindNextVisibleWindowItem"
2548         preserve_cpp_body_indent private return_type class_ref 140162 // TreeMultiItemWindow
2549         nparams 2
2550           param inout name "b" type class_ref 139778 // TreeMultiItemBase
2551           param in name "index" explicit_type "int"
2552             defaultvalue "-1"
2553         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
2554 "
2555         cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
2556   ${body}}
2557 "
2558         
2559         
2560         
2561         
2562         comment "* Finds next visible window item in chain. If not found use FindFirstVisibleItem to start from the
2563         beginning "
2564       end
2565
2566       operation 174722 "AdjustIconsDeltaY"
2567         preserve_cpp_body_indent private explicit_return_type "void"
2568         nparams 0
2569         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
2570 "
2571         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
2572   ${body}}
2573 "
2574         
2575         
2576         
2577         
2578         comment "* Adjust the centering of the bitmap icons (collapse / expand) when the caption font changes. They need to
2579
2580         be centered in the middle of the font, so a bit of deltaY adjustment is needed "
2581       end
2582
2583       operation 174850 "CalculateNodeSpanning"
2584         preserve_cpp_body_indent private explicit_return_type "void"
2585         nparams 1
2586           param inout name "b" type class_ref 139778 // TreeMultiItemBase
2587         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2588 "
2589         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
2590   ${body}}
2591 "
2592         
2593         
2594         
2595         
2596         comment "* Calculate the spanning of the individual nodes "
2597       end
2598
2599       operation 174978 "SetRecursiveCheckState"
2600         preserve_cpp_body_indent private explicit_return_type "void"
2601         nparams 2
2602           param inout name "n" type class_ref 139906 // TreeMultiItemNode
2603           param in name "check" explicit_type "bool"
2604         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
2605 "
2606         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
2607   ${body}}
2608 "
2609         
2610         
2611         
2612         
2613         comment "* Recurse to all the children and set the checkbox state (even when there is no checkbox) "
2614       end
2615
2616       operation 175106 "ScanTristateCheckstates"
2617         preserve_cpp_body_indent private explicit_return_type "void"
2618         nparams 1
2619           param inout name "b" type class_ref 139778 // TreeMultiItemBase
2620         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2621 "
2622         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
2623   ${body}}
2624 "
2625         
2626         
2627         
2628         
2629         comment "* From current checked node, all children will be scanned and the parent node of this node
2630         will get tristate if the checked items are scattered (some are some aren't). If all nodes in this
2631         node are checked, the parent node gets checked all the way up to the last one that matches
2632         criteria. If all are cleared, parent node gets cleared "
2633       end
2634
2635       operation 175234 "InsertNode"
2636         preserve_cpp_body_indent private return_type class_ref 140418 // wxTreeMultiItem
2637         nparams 4
2638           param inout name "ParentPtr" type class_ref 139906 // TreeMultiItemNode
2639           param in name "Position" explicit_type "size_t"
2640           param in name "Caption" explicit_type "wxString"
2641           param in name "Name" explicit_type "wxString"
2642         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
2643 "
2644         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}${)}${const}${throw}${staticnl}{
2645   ${body}}
2646 "
2647         
2648         
2649         
2650         
2651         comment "* \\name Private add and delete methods
2652
2653        @{
2654
2655    
2656 * Inserts a node into the parent's node at the specified position.
2657
2658        As this is a private method error checking is limited. Therefore, it has to be guaranteed that this method
2659
2660        is only called with a valid parent node pointer.
2661
2662        The position is zero based. In case the position is equal or larger than the current number of
2663
2664        parent's elements the new node is appended.
2665
2666        The newly inserted node is being returned.
2667
2668    "
2669       end
2670
2671       operation 175362 "InsertWindow"
2672         preserve_cpp_body_indent private return_type class_ref 140418 // wxTreeMultiItem
2673         nparams 6
2674           param inout name "ParentPtr" type class_ref 139906 // TreeMultiItemNode
2675           param in name "Position" explicit_type "size_t"
2676           param inout name "WindowPtr" type class_ref 136322 // wxWindow
2677           param in name "Name" explicit_type "wxString"
2678           param in name "Info" type class_ref 140546 // wxTreeMultiWindowInfo
2679           param in name "Flags" explicit_type "int"
2680         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} * ${p2}${v2}, const ${t3} & ${p3}${v3}, const ${t4} & ${p4}${v4}, ${t5} ${p5}${v5}${)}${const}${volatile}${throw}${abstract};
2681 "
2682         cpp_def "// wxTreeMultiCtrl::InsertNode(TreeMultiItemNode*, size_t, wxString const&, wxString const&) 
2683
2684 ${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, ${t2} * ${p2}, const ${t3} & ${p3}, const ${t4} & ${p4}, ${t5} ${p5}${)}${const}${throw}${staticnl}{
2685   ${body}}
2686 "
2687         
2688         
2689         
2690         
2691         comment "* Inserts a window into the parent's node at the specified position.
2692
2693        As this is a private method error checking is limited. Therefore, it has to be guaranteed that this method
2694
2695        is only called with a valid parent node and window pointer.
2696
2697        The position is zero based. In case the position is equal or larger than the current number of
2698
2699        parent's elements the new node is appended.
2700
2701        The newly inserted window is being returned.
2702
2703    "
2704       end
2705
2706       operation 175490 "Init"
2707         preserve_cpp_body_indent private explicit_return_type "void"
2708         nparams 0
2709         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
2710 "
2711         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
2712   ${body}}
2713 "
2714         
2715         
2716         
2717         
2718         comment "* @}
2719
2720    "
2721       end
2722
2723       operation 175618 "OnPaint"
2724         private explicit_return_type "void"
2725         nparams 1
2726           param inout name "event" explicit_type "wxPaintEvent"
2727         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2728 "
2729         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
2730   ${body}}
2731 "
2732         
2733         
2734         
2735         
2736         comment " handlers
2737 ---------
2738 virtual void OnDraw(wxDC& dc);
2739 "
2740       end
2741
2742       operation 175746 "OnMouseClick"
2743         preserve_cpp_body_indent private explicit_return_type "void"
2744         nparams 1
2745           param inout name "event" explicit_type "wxMouseEvent"
2746         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2747 "
2748         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
2749   ${body}}
2750 "
2751         
2752         
2753         
2754         
2755       end
2756
2757       operation 175874 "OnRightMouseClick"
2758         preserve_cpp_body_indent private explicit_return_type "void"
2759         nparams 1
2760           param inout name "Event" explicit_type "wxMouseEvent"
2761         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2762 "
2763         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
2764   ${body}}
2765 "
2766         
2767         
2768         
2769         
2770       end
2771
2772       operation 176002 "OnKey"
2773         preserve_cpp_body_indent private explicit_return_type "void"
2774         nparams 1
2775           param inout name "event" explicit_type "wxKeyEvent"
2776         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2777 "
2778         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
2779   ${body}}
2780 "
2781         
2782         
2783         
2784         
2785       end
2786
2787       operation 176130 "OnSize"
2788         private explicit_return_type "void"
2789         nparams 1
2790           param inout name "event" explicit_type "wxSizeEvent"
2791         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
2792 "
2793         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
2794   ${body}}
2795 "
2796         
2797         
2798         
2799         
2800       end
2801
2802       operation 176258 "RecalculateSpanSizes"
2803         preserve_cpp_body_indent private explicit_return_type "void"
2804         nparams 0
2805         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
2806 "
2807         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
2808   ${body}}
2809 "
2810         
2811         
2812         
2813         
2814         comment "* Recalculates the spanning controls "
2815       end
2816
2817       operation 176386 "wxTreeMultiCtrl"
2818         cpp_inline public explicit_return_type ""
2819         nparams 0
2820         cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : _create_called(false)
2821     {
2822
2823         Init();
2824     };
2825 "
2826         
2827         
2828         
2829         
2830         comment "* Two step constructor. Call Create when this constructor is called to build up the
2831         wxTreeMultiCtrl
2832     "
2833       end
2834
2835       operation 176514 "wxTreeMultiCtrl"
2836         cpp_inline public explicit_return_type ""
2837         nparams 7
2838           param inout name "parent" type class_ref 136322 // wxWindow
2839           param in name "id" explicit_type "wxWindowID"
2840             defaultvalue "-1"
2841           param in name "pos" explicit_type "wxPoint"
2842             defaultvalue "wxDefaultPosition"
2843           param in name "size" explicit_type "wxSize"
2844             defaultvalue "wxDefaultSize"
2845           param in name "style" explicit_type "long"
2846             defaultvalue "wxTMC_DEFAULT_STYLE"
2847           param in name "validator" explicit_type "wxValidator"
2848             defaultvalue "wxDefaultValidator"
2849           param in name "name" explicit_type "wxString"
2850             defaultvalue "wxTreeMultiCtrlNameStr"
2851         cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}, ${t4} ${p4}${v4}, const ${t5} & ${p5}${v5}, const ${t6} & ${p6}${v6}${)}${volatile}${throw} : _style(style | wxTAB_TRAVERSAL)
2852         , _create_called(false)
2853     {
2854         Create(parent, id, pos, size, style, validator, name);
2855     };
2856 "
2857         
2858         
2859         
2860         
2861         comment "* The default constructor. The style wxTAB_TRAVERSAL is enforced to make sure that the
2862         focus handling is being done correctly. The styles to be used are styles valid for
2863         the wxWindow and wxScrolledWindow
2864     "
2865       end
2866
2867       operation 176642 "~wxTreeMultiCtrl"
2868         preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
2869         nparams 0
2870         cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
2871 "
2872         cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
2873 ${body}}
2874 "
2875         
2876         
2877         
2878         
2879         comment "* Destructor "
2880       end
2881
2882       operation 176770 "Create"
2883         public explicit_return_type "bool"
2884         nparams 7
2885           param inout name "parent" type class_ref 136322 // wxWindow
2886           param in name "id" explicit_type "wxWindowID"
2887             defaultvalue "-1"
2888           param in name "pos" explicit_type "wxPoint"
2889             defaultvalue "wxDefaultPosition"
2890           param in name "size" explicit_type "wxSize"
2891             defaultvalue "wxDefaultSize"
2892           param in name "style" explicit_type "long"
2893             defaultvalue "wxTMC_DEFAULT_STYLE"
2894           param in name "validator" explicit_type "wxValidator"
2895             defaultvalue "wxDefaultValidator"
2896           param in name "name" explicit_type "wxString"
2897             defaultvalue "wxTreeMultiCtrlNameStr"
2898         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}, ${t4} ${p4}${v4}, const ${t5} & ${p5}${v5}, const ${t6} & ${p6}${v6}${)}${const}${volatile}${throw}${abstract};
2899 "
2900         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}, ${t4} ${p4}, const ${t5} & ${p5}, const ${t6} & ${p6}${)}${const}${throw}${staticnl}{
2901   ${body}}
2902 "
2903         
2904         
2905         
2906         
2907         comment "* Two step creation. Whenever the control is created without any parameters, use Create to actually
2908         create it. Don't access the control's public methods before this is called
2909
2910         \\sa wxTreeMultiCtrl()
2911     "
2912       end
2913
2914       operation 176898 "AddRoot"
2915         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
2916         nparams 2
2917           param in name "caption" explicit_type "wxString"
2918           param in name "name" explicit_type "wxString"
2919             defaultvalue "wxEmptyString"
2920         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
2921 "
2922         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
2923   ${body}}
2924 "
2925         
2926         
2927         
2928         
2929         comment " accessors
2930 ----------
2931 * @name Add and delete methods
2932         To add and delete node items like a Root item, Window item or Node item. This allows the user to
2933         manipulate the tree, and build it up.
2934         @{
2935     
2936 * Adds a root node to the wxTreeMultiItem. There can be many root nodes. Use this wxTreeMultiNode pointer to add
2937         more subnodes to it. "
2938       end
2939
2940       operation 177026 "AppendWindow"
2941         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
2942         nparams 5
2943           param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
2944           param inout name "window" type class_ref 136322 // wxWindow
2945             defaultvalue "NULL"
2946           param in name "name" explicit_type "wxString"
2947             defaultvalue "wxEmptyString"
2948           param in name "info" type class_ref 140546 // wxTreeMultiWindowInfo
2949             defaultvalue "wxTreeMultiWindowInfoDefault"
2950           param in name "flags" explicit_type "int"
2951             defaultvalue "0"
2952         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} * ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}, ${t4} ${p4}${v4}${)}${const}${volatile}${throw}${abstract};
2953 "
2954         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} * ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}, ${t4} ${p4}${)}${const}${throw}${staticnl}{
2955   ${body}}
2956 "
2957         
2958         
2959         
2960         
2961         comment "* Adds a window to the tree control. Use this wxTreeMultiItem method to add a window class to the
2962
2963         current wxTreeMultiItem. The wxTreeMultiItem must point to a Node class. If this is not the case
2964
2965         an empty wxTreeMultiItem is returned. The mask is used to override the mask settings of the
2966
2967         wxTreeMultiWindowInfo class. This can be handy to set or clear extra flags only needed for certain
2968
2969         situations "
2970       end
2971
2972       operation 177154 "InsertWindow"
2973         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
2974         nparams 6
2975           param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
2976           param in name "Position" explicit_type "size_t"
2977           param inout name "window" type class_ref 136322 // wxWindow
2978             defaultvalue "NULL"
2979           param in name "name" explicit_type "wxString"
2980             defaultvalue "wxEmptyString"
2981           param in name "info" type class_ref 140546 // wxTreeMultiWindowInfo
2982             defaultvalue "wxTreeMultiWindowInfoDefault"
2983           param in name "flags" explicit_type "int"
2984             defaultvalue "0"
2985         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} * ${p2}${v2}, const ${t3} & ${p3}${v3}, const ${t4} & ${p4}${v4}, ${t5} ${p5}${v5}${)}${const}${volatile}${throw}${abstract};
2986 "
2987         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}, ${t2} * ${p2}, const ${t3} & ${p3}, const ${t4} & ${p4}, ${t5} ${p5}${)}${const}${throw}${staticnl}{
2988   ${body}}
2989 "
2990         
2991         
2992         
2993         
2994         comment "* Adds a window to the tree control. Use this method to add a window class at the specified position
2995
2996        of the parent's wxTreeMultiItem. In case the position is smaller than the current number of children all elements
2997
2998        are shifted upwards, otherwise the new window is appended to the parent's wxTreeMultiItem.
2999
3000        The parent wxTreeMultiItem must point to a Node class. If this is not the case an
3001
3002        empty wxTreeMultiItem is returned.
3003
3004    "
3005       end
3006
3007       operation 177282 "PrependWindow"
3008         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
3009         nparams 5
3010           param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
3011           param inout name "window" type class_ref 136322 // wxWindow
3012             defaultvalue "NULL"
3013           param in name "name" explicit_type "wxString"
3014             defaultvalue "wxEmptyString"
3015           param in name "info" type class_ref 140546 // wxTreeMultiWindowInfo
3016             defaultvalue "wxTreeMultiWindowInfoDefault"
3017           param in name "flags" explicit_type "int"
3018             defaultvalue "0"
3019         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} * ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}, ${t4} ${p4}${v4}${)}${const}${volatile}${throw}${abstract};
3020 "
3021         cpp_def "// wxTreeMultiCtrl::InsertWindow(wxTreeMultiItem const&, size_t, wxWindow*, wxString const&, wxTreeMultiWindowInfo const&, int) 
3022
3023 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} * ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}, ${t4} ${p4}${)}${const}${throw}${staticnl}{
3024   ${body}}
3025 "
3026         
3027         
3028         
3029         
3030         comment "* Adds a window to the tree control. Use this method to add a window class as the first element
3031
3032        of the parent's wxTreeMultiItem. The parent wxTreeMultiItem must point to a Node class. If this is not the case an
3033
3034        empty wxTreeMultiItem is returned.
3035
3036    "
3037       end
3038
3039       operation 177410 "AppendNode"
3040         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
3041         nparams 3
3042           param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
3043           param in name "caption" explicit_type "wxString"
3044             defaultvalue "wxEmptyString"
3045           param in name "name" explicit_type "wxString"
3046             defaultvalue "wxEmptyString"
3047         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, const ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
3048 "
3049         cpp_def "// wxTreeMultiCtrl::PrependWindow(wxTreeMultiItem const&, wxWindow*, const wxString &, wxTreeMultiWindowInfo const&, int) 
3050
3051 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, const ${t2} & ${p2}${)}${const}${throw}${staticnl}{
3052   ${body}}
3053 "
3054         
3055         
3056         
3057         
3058         comment "* Adds a node to the tree control. Use this wxTreeMultiItem method to add a recursive subnode class as the last element
3059
3060         of the parent's wxTreeMultiItem. The parent wxTreeMultiItem must point to a Node class. If this is not the case
3061
3062         an empty wxTreeMultiItem is returned. A node can contain multiple nodes or window classes "
3063       end
3064
3065       operation 177538 "InsertNode"
3066         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
3067         nparams 4
3068           param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
3069           param in name "Position" explicit_type "size_t"
3070           param in name "caption" explicit_type "wxString"
3071           param in name "name" explicit_type "wxString"
3072         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
3073 "
3074         cpp_def "// wxTreeMultiCtrl::AppendNode(wxTreeMultiItem const&, const wxString &, const wxString&) 
3075
3076 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}${)}${const}${throw}${staticnl}{
3077   ${body}}
3078 "
3079         
3080         
3081         
3082         
3083         comment "* Adds a node to the tree control. Use this method to add a recursive subnode class at the specified position
3084
3085        of the parent's wxTreeMultiItem. In case the position is smaller than the current number of nodes all elements
3086
3087        are shifted upwards, otherwise the new node is appended to the parent's wxTreeMultiItem.
3088
3089        The parent wxTreeMultiItem must point to a Node class. If this is not the case an
3090
3091        empty wxTreeMultiItem is returned. A node can contain multiple nodes or window classes.
3092
3093    "
3094       end
3095
3096       operation 177666 "PrependNode"
3097         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
3098         nparams 3
3099           param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
3100           param in name "caption" explicit_type "wxString"
3101             defaultvalue "wxEmptyString"
3102           param in name "name" explicit_type "wxString"
3103             defaultvalue "wxEmptyString"
3104         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, const ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
3105 "
3106         cpp_def "// wxTreeMultiCtrl::InsertNode(wxTreeMultiItem const&, size_t, wxString const&, wxString const&) 
3107
3108 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, const ${t2} & ${p2}${)}${const}${throw}${staticnl}{
3109   ${body}}
3110 "
3111         
3112         
3113         
3114         
3115         comment "* Adds a node to the tree control. Use this method to add a recursive subnode class as the first element
3116
3117        of the parent's wxTreeMultiItem. The parent wxTreeMultiItem must point to a Node class. If this is not the case an
3118
3119        empty wxTreeMultiItem is returned. A node can contain multiple nodes or window classes.
3120
3121    "
3122       end
3123
3124       operation 177794 "Delete"
3125         preserve_cpp_body_indent public explicit_return_type "bool"
3126         nparams 1
3127           param inout name "item" type class_ref 140418 // wxTreeMultiItem
3128         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3129 "
3130         cpp_def "// wxTreeMultiCtrl::PrependNode(wxTreeMultiItem const&, wxString const&, wxString const&) 
3131
3132 ${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
3133   ${body}}
3134 "
3135         
3136         
3137         
3138         
3139         comment "* Delete item from the tree control. Whenever it is present, delete it. If not, return false. After
3140
3141         deletion the wxTreeMultiItem is 0, thus IsOk will return false "
3142       end
3143
3144       operation 177922 "DeleteAllItems"
3145         cpp_inline public explicit_return_type "void"
3146         nparams 1
3147           param in name "" explicit_type "void"
3148         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
3149
3150       this->_root.Clear();
3151
3152       this->m_SelectedItems.Clear();
3153
3154       Refresh();
3155
3156     };
3157 "
3158         
3159         
3160         
3161         
3162         comment "* Deletes all the items from the wxTreeMultiCtrl. "
3163       end
3164
3165       operation 178050 "DeleteChildren"
3166         preserve_cpp_body_indent public explicit_return_type "void"
3167         nparams 1
3168           param in name "item" type class_ref 140418 // wxTreeMultiItem
3169         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3170 "
3171         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
3172   ${body}}
3173 "
3174         
3175         
3176         
3177         
3178         comment "* Deletes all children of the current node. The wxTreeMultiItem needs to be of type Node to
3179         do this. Call GetParentNode to get the parent wxTreeMultiItem which is always a node. "
3180       end
3181
3182       operation 178178 "ExpandNodes"
3183         preserve_cpp_body_indent public explicit_return_type "void"
3184         nparams 1
3185           param in name "recursive" explicit_type "bool"
3186             defaultvalue "false"
3187         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3188 "
3189         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3190   ${body}}
3191 "
3192         
3193         
3194         
3195         
3196         comment "* @}
3197     
3198 * @name Expand and collapse methods
3199          These methods are all for items of type Node.
3200         @{
3201     
3202 * Expand all nodes and subnodes. Recursive = true means all subnodes are also expanded. "
3203       end
3204
3205       operation 178306 "CollapseNodes"
3206         preserve_cpp_body_indent public explicit_return_type "void"
3207         nparams 1
3208           param in name "recursive" explicit_type "bool"
3209             defaultvalue "false"
3210         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3211 "
3212         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3213   ${body}}
3214 "
3215         
3216         
3217         
3218         
3219         comment "* Collapses all nodes and subnodes. Recursive = true means all subnodes are also expanded. "
3220       end
3221
3222       operation 178434 "Expand"
3223         preserve_cpp_body_indent public explicit_return_type "void"
3224         nparams 2
3225           param in name "item" type class_ref 140418 // wxTreeMultiItem
3226           param in name "recursive" explicit_type "bool"
3227         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
3228 "
3229         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
3230   ${body}}
3231 "
3232         
3233         
3234         
3235         
3236         comment "* Expands given node, and with recursive, also the subnodes "
3237       end
3238
3239       operation 178562 "Collapse"
3240         preserve_cpp_body_indent public explicit_return_type "void"
3241         nparams 2
3242           param in name "item" type class_ref 140418 // wxTreeMultiItem
3243           param in name "recursive" explicit_type "bool"
3244         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
3245 "
3246         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
3247   ${body}}
3248 "
3249         
3250         
3251         
3252         
3253         comment "* Collapses given node, and with recursive, also the subnodes. If this item is not a node, but a window.
3254         the parent is resolved and that node is collapsed "
3255       end
3256
3257       operation 178690 "CollapseAndReset"
3258         preserve_cpp_body_indent public explicit_return_type "void"
3259         nparams 1
3260           param in name "item" type class_ref 140418 // wxTreeMultiItem
3261         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3262 "
3263         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
3264   ${body}}
3265 "
3266         
3267         
3268         
3269         
3270         comment "* Collapses this node and removes all children from it. This is only applicable on
3271         wxTreeMultiItems which are of type Node / Root. "
3272       end
3273
3274       operation 178818 "Fold"
3275         cpp_inline public explicit_return_type "void"
3276         nparams 2
3277           param in name "item" type class_ref 140418 // wxTreeMultiItem
3278           param in name "expand" explicit_type "bool"
3279             defaultvalue "true"
3280         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
3281         if(expand)
3282             Expand(item, false);
3283         else
3284             Collapse(item, false);
3285     };
3286 "
3287         
3288         
3289         
3290         
3291         comment "* Folds the given node. The same as Expand and Collapse, but the state can be
3292         given through a parameter "
3293       end
3294
3295       operation 178946 "GetSelectedItemCount"
3296         const cpp_inline public explicit_return_type "size_t"
3297         nparams 1
3298           param in name "" explicit_type "void"
3299         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return this->m_SelectedItems.GetCount();};
3300 "
3301         
3302         
3303         
3304         
3305         comment "* @}
3306
3307     
3308 * @name Selection manipulation
3309
3310          These methods allow you to select, unselect or test wxTreeMultiItems on selection.
3311
3312          Currently only items of type Node can be manipulated.
3313
3314         @{
3315
3316     
3317 * Returns the number of selected items. "
3318       end
3319
3320       operation 179074 "GetFirstSelectedItem"
3321         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
3322         nparams 1
3323           param in name "" explicit_type "void"
3324         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3325 "
3326         cpp_def "// Selection manipulation
3327
3328
3329 ${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3330   ${body}}
3331 "
3332         
3333         
3334         
3335         
3336         comment "* Returns the first selected item.
3337
3338        If there is no selected item an invalid tree multi item is returned.
3339
3340    "
3341       end
3342
3343       operation 179202 "GetLastSelectedItem"
3344         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
3345         nparams 1
3346           param in name "" explicit_type "void"
3347         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3348 "
3349         cpp_def "// wxTreeMultiCtrl::GetFirstSelectedItem(void) const 
3350
3351 ${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3352   ${body}}
3353 "
3354         
3355         
3356         
3357         
3358         comment "* Returns the last selected item.
3359
3360        If there is no selected item an invalid tree multi item is returned.
3361
3362    "
3363       end
3364
3365       operation 179330 "GetSelectedItem"
3366         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
3367         nparams 1
3368           param in name "Index" explicit_type "size_t"
3369         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3370 "
3371         cpp_def "// wxTreeMultiCtrl::GetLastSelectedItem(void) const 
3372
3373 ${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3374   ${body}}
3375 "
3376         
3377         
3378         
3379         
3380         comment "* Returns a selected item with the specified index.
3381
3382        If there is no selected item with the passed index an invalide tree multi item is returned.
3383
3384    "
3385       end
3386
3387       operation 179458 "GetSelectedItemIndex"
3388         preserve_cpp_body_indent const public explicit_return_type "size_t"
3389         nparams 1
3390           param in name "Item" type class_ref 140418 // wxTreeMultiItem
3391         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3392 "
3393         cpp_def "// wxTreeMultiCtrl::GetSelectedItem(size_t Index) const 
3394
3395 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
3396   ${body}}
3397 "
3398         
3399         
3400         
3401         
3402         comment "* Returns the index of the selected item.
3403
3404        In case the item is not selected \"GetSelectedItemCount()\" - which is an invalid index - is returned.
3405
3406    "
3407       end
3408
3409       operation 179586 "SelectItem"
3410         preserve_cpp_body_indent public explicit_return_type "void"
3411         nparams 3
3412           param in name "Item" type class_ref 140418 // wxTreeMultiItem
3413           param in name "UnselectOthers" explicit_type "bool"
3414             defaultvalue "true"
3415           param in name "ExpandSelection" explicit_type "bool"
3416             defaultvalue "false"
3417         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
3418 "
3419         cpp_def "// wxTreeMultiCtrl::GetSelectedItemIndex(wxTreeMultiItem const&) const 
3420
3421 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
3422   ${body}}
3423 "
3424         
3425         
3426         
3427         
3428         comment "* Selects the specified item AND in case
3429
3430         - UnselectOthers is set all other selected items are going to be unselected;
3431
3432         - ExpandSelection is set all items between the last selected item and the passed item
3433
3434           are selected, too (in case there this is the first selection all items between the first root
3435
3436           and the passed item are selected).
3437
3438        If the passed item is already selected the other parameters are ignored.
3439
3440        Please not that currently only nodes can be selected, therefore, if any other item is passed nothing will happen.
3441
3442    "
3443       end
3444
3445       operation 179714 "UnselectAll"
3446         preserve_cpp_body_indent public explicit_return_type "void"
3447         nparams 1
3448           param in name "" explicit_type "void"
3449         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3450 "
3451         cpp_def "// wxTreeMultiCtrl::SelectItem(wxTreeMultiItem const&, bool, bool) 
3452
3453 ${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3454   ${body}}
3455 "
3456         
3457         
3458         
3459         
3460         comment "* Unselect all selected items. "
3461       end
3462
3463       operation 179842 "Unselect"
3464         preserve_cpp_body_indent public explicit_return_type "void"
3465         nparams 1
3466           param in name "Item" type class_ref 140418 // wxTreeMultiItem
3467         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3468 "
3469         cpp_def "// wxTreeMultiCtrl::UnselectAll(void) 
3470
3471 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
3472   ${body}}
3473 "
3474         
3475         
3476         
3477         
3478         comment "* Unselect specified item "
3479       end
3480
3481       operation 179970 "Exclude"
3482         preserve_cpp_body_indent public explicit_return_type "void"
3483         nparams 1
3484           param in name "item" type class_ref 140418 // wxTreeMultiItem
3485         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3486 "
3487         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
3488   ${body}}
3489 "
3490         
3491         
3492         
3493         
3494         comment "* @}
3495
3496     
3497 * \\name Visibility manipulation
3498
3499         These methods allow you to manipulate a certain wxTreeMultiItem to temporarily exclude or to include
3500
3501         the node from drawing. Whenever it is excluded, all operations can still be performed, however
3502
3503         the node may not be visible.
3504         @{
3505     
3506 * Excludes this node from drawing. When excluded, the node will dissapear from the control but is still
3507         physically present in the tree itself. If this node is a composite node with children, they will all be
3508         hidden from the control. "
3509       end
3510
3511       operation 180098 "Include"
3512         preserve_cpp_body_indent public explicit_return_type "void"
3513         nparams 1
3514           param in name "item" type class_ref 140418 // wxTreeMultiItem
3515         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3516 "
3517         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
3518   ${body}}
3519 "
3520         
3521         
3522         
3523         
3524         comment "* Includes an excluded node. If the node was already present on the drawing, nothing happens. If the
3525         node is included after exclusion it will become visible. If the parent node is still excluded or
3526         collapsed (not visible) this will not show, until the parent node shows "
3527       end
3528
3529       operation 180226 "GetExcludedParent"
3530         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
3531         nparams 1
3532           param in name "item" type class_ref 140418 // wxTreeMultiItem
3533         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3534 "
3535         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
3536   ${body}}
3537 "
3538         
3539         
3540         
3541         
3542         comment "* Returns the parent that is responsible for excluding this node. If there is no excluded node as parent,
3543         the wxTreeMultiItem is zero. "
3544       end
3545
3546       operation 180354 "HitTest"
3547         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
3548         nparams 2
3549           param in name "pt" explicit_type "wxPoint"
3550           param inout name "flags" explicit_type "int"
3551         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
3552 "
3553         cpp_def "// wxTreeMultiCtrl::OnRightMouseClick(wxMouseEvent&) 
3554
3555 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
3556   ${body}}
3557 "
3558         
3559         
3560         
3561         
3562         comment "* @}
3563     
3564 * Checks if the point is under one of the given areas. The returned areas can be
3565         \\li wxTMC_HITTEST_GUTTER If the front part of the item is clicked (where the node is)
3566         \\li wxTMC_HITTEST_WINDOW If located in the window area
3567         \\li wxTMC_HITTEST_CAPTION If located on the caption of the MultiTreeItemNode
3568
3569
3570         Returned is the item which is located under the mouse, or none (IsOk = false) if
3571
3572         no item under the mouse "
3573       end
3574
3575       operation 180482 "FindItem"
3576         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
3577         nparams 4
3578           param in name "item" type class_ref 140418 // wxTreeMultiItem
3579           param in name "name" explicit_type "wxString"
3580           param in name "ignoreCase" explicit_type "bool"
3581             defaultvalue "false"
3582           param in name "skipFirst" explicit_type "bool"
3583             defaultvalue "false"
3584         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
3585 "
3586         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, ${t2} ${p2}, ${t3} ${p3}${)}${const}${throw}${staticnl}{
3587   ${body}}
3588 "
3589         
3590         
3591         
3592         
3593         comment "* @name Find methods
3594
3595          These methods are used for finding a node in the wxTreeMultiCtrl.
3596
3597         @{
3598     
3599 * Searches for the given name from the given level and lower. It will return a wxTreeMultiItem which needs
3600         to be checked with IsOk() to see if it is a correct item. IsRootItem, IsNodeItem and IsWindowItem can be
3601         used to determine the type of item. If the search returned an item which doesn't satisfy the query, you can
3602         restart the search from here, with skip = true to skip the passed item. "
3603       end
3604
3605       operation 180610 "FindItem"
3606         cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
3607         nparams 2
3608           param in name "name" explicit_type "wxString"
3609           param in name "ignoreCase" explicit_type "bool"
3610             defaultvalue "false"
3611         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
3612         return FindItem(wxTreeMultiItem(&_root), name, ignoreCase, false);
3613     };
3614 "
3615         
3616         
3617         
3618         
3619         comment "* Searches all nodes for the given name and returns the one found. This is a specialised method for FindItem "
3620       end
3621
3622       operation 180738 "GetChildrenCount"
3623         cpp_inline public explicit_return_type "int"
3624         nparams 1
3625           param in name "item" type class_ref 140418 // wxTreeMultiItem
3626         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
3627         if(item.IsNodeItem())
3628         {
3629             TreeMultiItemNode *n = (TreeMultiItemNode *)item.GetItem();
3630             return n->GetNodeCount();
3631         }
3632
3633         return -1;
3634     };
3635 "
3636         
3637         
3638         
3639         
3640         comment "* @}
3641     
3642 * Returns the number of children in this node. If this node is not of type Node, count returns -1. "
3643       end
3644
3645       operation 180866 "GetFocus"
3646         preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
3647         nparams 0
3648         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
3649 "
3650         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
3651   ${body}}
3652 "
3653         
3654         
3655         
3656         
3657         comment "* This method finds the current focused window, and returns the wxTreeMultiItem that has this window as pointer.
3658         If the wxTreeMultiItem is not ok, the focused window is on a sub-panel, or not on this control. If the focus is
3659         on a sub-panel, this panel will handle the focusing. If you are still interested in this window, try
3660         wxWindow::FindFocus which will always return with a pointer if a wxWindow has focus "
3661       end
3662
3663       operation 180994 "GetBooleanValue"
3664         preserve_cpp_body_indent public explicit_return_type "bool"
3665         nparams 1
3666           param in name "wndId" explicit_type "int"
3667         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3668 "
3669         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3670   ${body}}
3671 "
3672         
3673         
3674         
3675         
3676         comment "* @name Smart window Get/Set methods
3677          These methods are used for quickly getting or setting primitive values, like boolean, string, or selections into
3678          primitive wxWindow controls like a wxRadioButton, wxCheckBox, wxTextCtrl, etc.
3679          The methods allow you to quickly set e.g. a boolean value by using the wxWindow ID of the control. A type
3680          check is performed before the value is actually set with the appropiate method for it. If it fails, an assertion
3681          will follow in debug mode. If you want to get values back similar get methods are present to return values.
3682          This allows the user to quickly retrieve or set values by ID, without the fuss of remembering the pointer or
3683          node ID of the wxTreeMultiCtrl.
3684         @{
3685     
3686 * This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
3687         AppendWindow). When it is found, it is type casted towards a <b>wxCheckBox</b> and <b>wxRadioButton</b>. Whenever
3688         it finds a proper type it will return true or false. Whenever no proper type is found, it will return with false.
3689         In debug mode it will cause an assertion failure as well, to notify the developer something is wrong.
3690
3691         \\sa SetBooleanValue
3692     "
3693       end
3694
3695       operation 181122 "GetTextValue"
3696         preserve_cpp_body_indent public explicit_return_type "wxString"
3697         nparams 1
3698           param in name "wndId" explicit_type "int"
3699         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3700 "
3701         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3702   ${body}}
3703 "
3704         
3705         
3706         
3707         
3708         comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
3709         AppendWindow). When it is found, it is type casted towards a <b>wxTextCtrl</b>, <b>wxChoice</b> and <b>wxComboBox</b>.
3710         Whenever it finds a proper type it will return the (selected) text in the control. Whenever no proper type is found,
3711         it will return with an empty string. In debug mode it will cause an exception error as well if the cast fails, to notify
3712         the developer something is wrong.
3713
3714         \\sa SetTextValue
3715     "
3716       end
3717
3718       operation 181250 "SetBooleanValue"
3719         preserve_cpp_body_indent public explicit_return_type "void"
3720         nparams 2
3721           param in name "wndId" explicit_type "int"
3722           param in name "value" explicit_type "bool"
3723             defaultvalue "true"
3724         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
3725 "
3726         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
3727   ${body}}
3728 "
3729         
3730         
3731         
3732         
3733         comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
3734         AppendWindow). When it is found, it is type casted towards a <b>wxCheckBox</b> and <b>wxRadioButton</b>. Whenever
3735         it finds a proper type it set the control's value to the given boolean parameter. Nothing happens when no proper type
3736         is found, however debug mode it will cause an assertion failure.
3737
3738         \\sa GetBooleanValue
3739     "
3740       end
3741
3742       operation 181378 "SetTextValue"
3743         preserve_cpp_body_indent public explicit_return_type "void"
3744         nparams 2
3745           param in name "wndId" explicit_type "int"
3746           param in name "value" explicit_type "wxString"
3747             defaultvalue "wxEmptyString"
3748         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
3749 "
3750         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, const ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
3751   ${body}}
3752 "
3753         
3754         
3755         
3756         
3757         comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
3758         AppendWindow). When it is found, it is type casted towards a <b>wxTextCtrl</b>. If the control is not found or
3759         of the wrong type, an asserion failure (in debug mode) follows. <br><i><b>NOTE: </b></i> this method
3760         does not typecast to wxChoice or wxComboBox and the likes. If a selection in one of those needs to be set, use the
3761         SetSelectionValue / GetSelectionValue combination.
3762         \\sa GetTextValue, GetSelectionValue, SetSelectionValue
3763     "
3764       end
3765
3766       operation 181506 "GetWindow"
3767         cpp_inline public return_type class_ref 136322 // wxWindow
3768         nparams 1
3769           param in name "item" type class_ref 140418 // wxTreeMultiItem
3770         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
3771         if(item.IsWindowItem())
3772             return ((TreeMultiItemWindow *)item.GetItem())->GetWindow();
3773         return 0;
3774     };
3775 "
3776         
3777         
3778         
3779         
3780         comment "* Retrieves the wxWindow * associated with the wxTreeMultiItem. This only works for Window typed wxTreeMultiItem
3781         classes. If this type does not match or no window is associated, 0 is returned. "
3782       end
3783
3784       operation 181634 "SetSelectionValue"
3785         preserve_cpp_body_indent public explicit_return_type "void"
3786         nparams 2
3787           param in name "wndId" explicit_type "int"
3788           param in name "sel" explicit_type "int"
3789         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
3790 "
3791         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
3792   ${body}}
3793 "
3794         
3795         
3796         
3797         
3798         comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
3799         AppendWindow). When it is found, it is type casted towards a <b>wxListBox, wxChoice, wxComboBox</b>.
3800         If the control is not found or of the wrong type, an asserion failure (in debug mode) follows. If it is found
3801         the selection is set in the control.
3802     "
3803       end
3804
3805       operation 181762 "GetSelectionValue"
3806         preserve_cpp_body_indent public explicit_return_type "int"
3807         nparams 1
3808           param in name "wndId" explicit_type "int"
3809         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
3810 "
3811         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
3812   ${body}}
3813 "
3814         
3815         
3816         
3817         
3818         comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
3819         AppendWindow). When it is found, it is type casted towards a <b>wxListBox, wxChoice, wxComboBox</b>.
3820         If the control is not found or of the wrong type, an asserion failure (in debug mode) follows. In release mode -1 is
3821         returned. If it is found the selection index is returned.
3822     "
3823       end
3824
3825       operation 181890 "GetSelectionValues"
3826         preserve_cpp_body_indent public explicit_return_type "void"
3827         nparams 2
3828           param in name "wndId" explicit_type "int"
3829           param inout name "sels" explicit_type "wxArrayInt"
3830         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
3831 "
3832         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
3833   ${body}}
3834 "
3835         
3836         
3837         
3838         
3839         comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
3840         AppendWindow). When it is found, it is type casted towards a <b>wxListBox</b>. If the control is not found or
3841         of the wrong type, an asserion failure (in debug mode) follows. In release mode an empty wxArrayInt is returned.
3842         If it is found the selections are stored in the wxArrayInt. This is only valid for wxListBox classes with multiple
3843         selection flag set.
3844     "
3845       end
3846
3847       operation 182018 "GetCheckboxState"
3848         public explicit_return_type "int"
3849         nparams 1
3850           param in name "item" type class_ref 140418 // wxTreeMultiItem
3851         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
3852 "
3853         cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
3854   ${body}}
3855 "
3856         
3857         
3858         
3859         
3860         comment "* Gets the checkbox state of the wxTreeMultiItem pointed out by \"item\". If the item does not have a checkbox
3861         associated (or the item is not ok), it will return -1. If the checkbox is checked it will return 1,
3862
3863         unchecked is 0, and tri-state (usually only for caption nodes) it will return 2. <b>This needs USE_CHECKBOXVIEW
3864
3865         set to YES, or CHECKBOXVIEW=1 during compile</b>"
3866       end
3867
3868       operation 182146 "SetCheckboxState"
3869         cpp_inline public explicit_return_type "void"
3870         nparams 2
3871           param in name "item" type class_ref 140418 // wxTreeMultiItem
3872           param in name "state" explicit_type "int"
3873         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
3874                 wxCHECK2( item.IsOk(), return );
3875                 TreeMultiItemBase *b = item.GetItem();
3876                 if( b->GetCheckbox() )
3877                         b->SetCheckboxState( state );
3878                 RedrawFromNode( item.GetItem()->GetParent() );
3879         };
3880 "
3881         
3882         
3883         
3884         
3885         comment "* Sets the checkbox state of the wxTreeMultiItem pointed out by \"item\". If the item does not have a checkbox
3886         associated (or the item is not ok), it will simply ignore this. <b>This needs USE_CHECKBOXVIEW
3887         set to YES, or CHECKBOXVIEW=1 during compile</b>. Contributed by Thomas Enickl."
3888       end
3889
3890       operation 182274 "SetSpacingY"
3891         cpp_inline public explicit_return_type "void"
3892         nparams 1
3893           param in name "spacingY" explicit_type "int"
3894         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
3895         if(spacingY >= 0)
3896         {
3897             _spacingY = spacingY;
3898             RedrawFromNode(0);
3899         }
3900     };
3901 "
3902         
3903         
3904         
3905         
3906         comment "* @}
3907     
3908 * @name Extended visibility and manipulation methods
3909         These methods alter the wxTreeMultiCtrl appearance, or add more functionality like checkboxes before each node.
3910         @{
3911     
3912 * Sets the Y spacing of the wxTreeMultiCtrl to a new size. This can be used to give the controls some more
3913         spacing in between "
3914       end
3915
3916       operation 182402 "GetSpacingY"
3917         const cpp_inline public explicit_return_type "int"
3918         nparams 0
3919         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
3920         return _spacingY;
3921     };
3922 "
3923         
3924         
3925         
3926         
3927         comment "* Gets the Y spacing of the wxTreeMultiCtrl. "
3928       end
3929
3930       operation 182530 "SetCheckboxView"
3931         cpp_inline public explicit_return_type "void"
3932         nparams 1
3933           param in name "value" explicit_type "bool"
3934         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
3935         _checkboxView = value;
3936     };
3937 "
3938         
3939         
3940         
3941         
3942         comment "* This method toggles the checkbox view mode. Whenever set to true, the next window item, or caption node item
3943         will get a checkbox. <b>This needs USE_CHECKBOXVIEW set to YES, or CHECKBOXVIEW=1 during compile</b>
3944         \\sa GetCheckboxView, wxTreeMultiWindowInfo::SetDefaultCheckState
3945     "
3946       end
3947
3948       operation 182658 "GetCheckboxView"
3949         const cpp_inline public explicit_return_type "bool"
3950         nparams 0
3951         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
3952         return _checkboxView;
3953     };
3954 "
3955         
3956         
3957         
3958         
3959         comment "* This method returns the checkbox state currently used. <b>This needs USE_CHECKBOXVIEW set to YES, or
3960         CHECKBOXVIEW=1 during compile</b>
3961         \\sa SetCheckboxView, wxTreeMultiWindowInfo::SetDefaultCheckState, wxTreeMultiWindowInfo::GetDefaultCheckState
3962     "
3963       end
3964
3965       operation 182786 "GetFirstRoot"
3966         const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
3967         nparams 1
3968           param in name "" explicit_type "void"
3969         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return wxTreeMultiItem(this->_root.First());};
3970 "
3971         
3972         
3973         
3974         
3975         comment "* @}
3976     
3977 * @name Iteration methods
3978
3979         Allows the user to iterate through a wxTreeMultiCtrl node, and get all the children or siblings.
3980
3981         To start an iteration from the lowest level the functions GetFirstRoot and GetLastRoot are provided.
3982
3983         @{
3984
3985     
3986 * Returns the first root. "
3987       end
3988
3989       operation 182914 "GetLastRoot"
3990         const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
3991         nparams 1
3992           param in name "" explicit_type "void"
3993         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return wxTreeMultiItem(this->_root.Last());};
3994 "
3995         
3996         
3997         
3998         
3999         comment "* Returns the last root. "
4000       end
4001
4002       operation 183042 "GetParent"
4003         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
4004         nparams 1
4005           param in name "item" type class_ref 140418 // wxTreeMultiItem
4006         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
4007 "
4008         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
4009   ${body}}
4010 "
4011         
4012         
4013         
4014         
4015         comment "* Returns the items parent. "
4016       end
4017
4018       operation 183170 "GetFirstChild"
4019         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
4020         nparams 2
4021           param in name "item" type class_ref 140418 // wxTreeMultiItem
4022           param inout name "cookie" explicit_type "int"
4023         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
4024 "
4025         cpp_def "// wxTreeMultiCtrl::GetParent(wxTreeMultiItem const& item) const 
4026
4027 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
4028   ${body}}
4029 "
4030         
4031         
4032         
4033         
4034         comment "* Returns the first child of this node. The type of wxTreeMultiItem needs to be of Node. Whenever not succesful,
4035
4036         the item returned is not ok (IsOk = false). Upon success, a valid child is returned. The cookie variable doesn't
4037
4038         need to be initialized "
4039       end
4040
4041       operation 183298 "GetNextChild"
4042         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
4043         nparams 2
4044           param in name "item" type class_ref 140418 // wxTreeMultiItem
4045           param inout name "cookie" explicit_type "int"
4046         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
4047 "
4048         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
4049   ${body}}
4050 "
4051         
4052         
4053         
4054         
4055         comment "* Returns the next child in the iteration on the level of 'item'. Make sure you called GetFirstChild first
4056         before calling this one "
4057       end
4058
4059       operation 183426 "GetLastChild"
4060         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
4061         nparams 1
4062           param in name "item" type class_ref 140418 // wxTreeMultiItem
4063         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
4064 "
4065         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
4066   ${body}}
4067 "
4068         
4069         
4070         
4071         
4072         comment "* Returns the last child of this node. The type of 'item' needs to be of Node. Whenever not succesful,
4073         the item returned is not ok (IsOk = false). Upon success, a valid last child is returned. "
4074       end
4075
4076       operation 183554 "GetNextSibling"
4077         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
4078         nparams 1
4079           param in name "item" type class_ref 140418 // wxTreeMultiItem
4080         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
4081 "
4082         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
4083   ${body}}
4084 "
4085         
4086         
4087         
4088         
4089         comment "* Returns the next sibling of the passed item. "
4090       end
4091
4092       operation 183682 "GetPrevSibling"
4093         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
4094         nparams 1
4095           param in name "item" type class_ref 140418 // wxTreeMultiItem
4096         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
4097 "
4098         cpp_def "// wxTreeMultiCtrl::GetNextSibling(wxTreeMultiItem const&) const 
4099
4100 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
4101   ${body}}
4102 "
4103         
4104         
4105         
4106         
4107         comment "* Returns the previous sibling of the passed item. "
4108       end
4109
4110       operation 183810 "GetNext"
4111         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
4112         nparams 1
4113           param in name "item" type class_ref 140418 // wxTreeMultiItem
4114         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
4115 "
4116         cpp_def "// wxTreeMultiCtrl::GetPrevSibling(wxTreeMultiItem const&) const 
4117
4118 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
4119   ${body}}
4120 "
4121         
4122         
4123         
4124         
4125         comment "* Returns the next item. \"Next\" is defined by the following order:
4126
4127         - in case the current item has a child it is the first child of the current item;
4128
4129         - in case the current item has a next sibling as the next sibling;
4130
4131         - as the parent's (or one of its ancestor's) next sibling.
4132
4133    "
4134       end
4135
4136       operation 183938 "GetPrevious"
4137         preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
4138         nparams 1
4139           param in name "item" type class_ref 140418 // wxTreeMultiItem
4140         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
4141 "
4142         cpp_def "// wxTreeMultiCtrl::GetNextSibling(wxTreeMultiItem const&) const 
4143
4144 ${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
4145   ${body}}
4146 "
4147         
4148         
4149         
4150         
4151         comment "* Returns the previous item. \"Previous\" is defined by the following order:
4152
4153         - in case the current item has a child it is the last child of the current item;
4154
4155         - in case the current item has a previous sibling it is the previous sibling;
4156
4157         - as the parent's (or one of its ancestor's) previous sibling.
4158
4159    "
4160       end
4161
4162       operation 184066 "GetCaptionFont"
4163         const cpp_inline public explicit_return_type "wxFont"
4164         nparams 0
4165         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
4166         return _captionFont;
4167     };
4168 "
4169         
4170         
4171         
4172         
4173         comment "* @}
4174
4175     
4176 * @name Get and set methods
4177         These methods allow you to set or get certain properties of the wxTreeMultiCtrl.
4178         @{
4179     
4180 * Get the currently used font for the caption headers in the wxTreeMultiCtrl. If you want to alter this
4181         font, simply obtain it and copy it to a local font. After that, set this font back using SetCaptionFont()
4182     "
4183       end
4184
4185       operation 184194 "SetCaptionFont"
4186         preserve_cpp_body_indent public explicit_return_type "void"
4187         nparams 1
4188           param in name "font" explicit_type "wxFont"
4189         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
4190 "
4191         cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
4192   ${body}}
4193 "
4194         
4195         
4196         
4197         
4198         comment "* Sets the font to be used for the text caption headers. This triggers a complete redraw because x,y sizes can
4199         differ, and ofcourse all nodes need to be updated. You can call this method at any time not only at the
4200         beginning. "
4201       end
4202
4203       operation 184322 "OnDraw"
4204         preserve_cpp_body_indent public explicit_return_type "void"
4205         nparams 1
4206           param inout name "dc" explicit_type "wxDC"
4207         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
4208 "
4209         cpp_def "// wxTreeMultiCtrl::GetPrevious(wxTreeMultiItem const&) const 
4210 // WDR: handler implementations for wxTreeMultiCtrl
4211
4212
4213 ${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
4214   ${body}}
4215 "
4216         
4217         
4218         
4219         
4220         comment "* @}
4221
4222     "
4223       end
4224     end
4225
4226     class 140802 "typedef23"
4227       visibility package stereotype "typedef" explicit_base_type "wxScrolledWindow"
4228       cpp_decl "${comment}typedef ${type} ${name};
4229 "
4230       java_decl ""
4231       php_decl ""
4232       python_2_2 python_decl ""
4233       idl_decl ""
4234       explicit_switch_type ""
4235       
4236     end
4237
4238     class 140930 "wxTreeMultiEvent"
4239       visibility package 
4240       cpp_decl "${comment}${template}class ${name}${inherit} {
4241 ${members}};
4242 ${inlines}
4243 "
4244       java_decl ""
4245       php_decl ""
4246       python_2_2 python_decl ""
4247       idl_decl ""
4248       explicit_switch_type ""
4249       
4250       comment "*
4251    \\section treemultievent Event handlers for wxTreeMultiCtrl
4252    
4253    Event handlers for wxTreeMultiCtrl are similar to wxTreeEvents. But they are
4254    optimized for the wxTreeMultiCtrl class.
4255 "
4256       classrelation 136066 // <generalisation>
4257         relation 136066 ---|>
4258           a public
4259             cpp default "${type}"
4260             classrelation_ref 136066 // <generalisation>
4261           b parent class_ref 141058 // typedef24
4262       end
4263
4264       operation 184450 "wxTreeMultiEvent"
4265         preserve_cpp_body_indent public explicit_return_type ""
4266         nparams 2
4267           param in name "InitEventType" explicit_type "wxEventType"
4268             defaultvalue "wxEVT_NULL"
4269           param in name "InitItem" type class_ref 140418 // wxTreeMultiItem
4270             defaultvalue "wxTreeMultiItem()"
4271         cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw};
4272 "
4273         cpp_def "// constructors / destructor:
4274
4275 ${comment}${inline}${class}::${name}${(}${t0} ${p0}, const ${t1} & ${p1}${)}
4276                  :wxNotifyEvent(InitEventType), m_Item(InitItem)
4277 ${throw}{
4278 ${body}}
4279 "
4280         
4281         
4282         
4283         
4284         comment "WXDLLEXPORT
4285 /
4286 / The default constructor
4287 /"
4288       end
4289
4290       operation 184578 "Clone"
4291         const cpp_virtual cpp_inline public explicit_return_type "wxEvent"
4292         nparams 0
4293         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {return new wxTreeMultiEvent(*this);};
4294 "
4295         
4296         
4297         
4298         
4299         comment " inherited functions:
4300  wxEvent:
4301  cloning:"
4302       end
4303
4304       operation 184706 "GetItem"
4305         const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
4306         nparams 1
4307           param in name "" explicit_type "void"
4308         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
4309     return this->m_Item;
4310   };
4311 "
4312         
4313         
4314         
4315         
4316         comment " item handling:"
4317       end
4318
4319       operation 184834 "SetItem"
4320         cpp_inline public explicit_return_type "void"
4321         nparams 1
4322           param in name "NewItem" type class_ref 140418 // wxTreeMultiItem
4323         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
4324     this->m_Item = NewItem;
4325   };
4326 "
4327         
4328         
4329         
4330         
4331       end
4332
4333       operation 184962 "GetOldItem"
4334         const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
4335         nparams 1
4336           param in name "" explicit_type "void"
4337         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
4338     return this->m_OldItem;
4339   };
4340 "
4341         
4342         
4343         
4344         
4345         comment " old item handling:"
4346       end
4347
4348       operation 185090 "SetOldItem"
4349         cpp_inline public explicit_return_type "void"
4350         nparams 1
4351           param in name "NewItem" type class_ref 140418 // wxTreeMultiItem
4352         cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
4353     this->m_OldItem = NewItem;
4354   };
4355 "
4356         
4357         
4358         
4359         
4360       end
4361     end
4362
4363     class 141058 "typedef24"
4364       visibility package stereotype "typedef" explicit_base_type "wxNotifyEvent"
4365       cpp_decl "${comment}typedef ${type} ${name};
4366 "
4367       java_decl ""
4368       php_decl ""
4369       python_2_2 python_decl ""
4370       idl_decl ""
4371       explicit_switch_type ""
4372       
4373     end
4374   end
4375
4376   deploymentview 128258 "treemultictrl"
4377     //deployment diagram settings
4378     package_name_in_tab default show_context default write_horizontally default auto_label_position default draw_all_relations default shadow default
4379     draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
4380     artifact 131458 "TreeMultiItemBase"
4381       stereotype "source"
4382       cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
4383 #define ${NAMESPACE}_${NAME}_H
4384
4385 ${comment}
4386 ${includes}
4387 ${declarations}
4388 ${namespace_start}
4389 ${definition}
4390 ${namespace_end}
4391 #endif
4392 "
4393       cpp_src "${comment}
4394 ${includes}
4395 ${namespace_start}
4396 ${members}
4397 ${namespace_end}"
4398       associated_classes
4399         class_ref 139778 // TreeMultiItemBase
4400       end
4401     end
4402
4403     artifact 131586 "TreeMultiItemNode"
4404       stereotype "source"
4405       cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
4406 #define ${NAMESPACE}_${NAME}_H
4407
4408 ${comment}
4409 ${includes}
4410 ${declarations}
4411 ${namespace_start}
4412 ${definition}
4413 ${namespace_end}
4414 #endif
4415 "
4416       cpp_src "${comment}
4417 ${includes}
4418 ${namespace_start}
4419 ${members}
4420 ${namespace_end}"
4421       associated_classes
4422         class_ref 139906 // TreeMultiItemNode
4423       end
4424     end
4425
4426     artifact 131714 "TreeMultiItemRoot"
4427       stereotype "source"
4428       cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
4429 #define ${NAMESPACE}_${NAME}_H
4430
4431 ${comment}
4432 ${includes}
4433 ${declarations}
4434 ${namespace_start}
4435 ${definition}
4436 ${namespace_end}
4437 #endif
4438 "
4439       cpp_src "${comment}
4440 ${includes}
4441 ${namespace_start}
4442 ${members}
4443 ${namespace_end}"
4444       associated_classes
4445         class_ref 140034 // TreeMultiItemRoot
4446       end
4447     end
4448
4449     artifact 131842 "TreeMultiItemWindow"
4450       stereotype "source"
4451       cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
4452 #define ${NAMESPACE}_${NAME}_H
4453
4454 ${comment}
4455 ${includes}
4456 ${declarations}
4457 ${namespace_start}
4458 ${definition}
4459 ${namespace_end}
4460 #endif
4461 "
4462       cpp_src "${comment}
4463 ${includes}
4464 ${namespace_start}
4465 ${members}
4466 ${namespace_end}"
4467       associated_classes
4468         class_ref 140162 // TreeMultiItemWindow
4469       end
4470     end
4471
4472     artifact 131970 "wxTreeMultiCtrl"
4473       stereotype "source"
4474       cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
4475 #define ${NAMESPACE}_${NAME}_H
4476
4477 ${comment}
4478 ${includes}
4479 ${declarations}
4480 ${namespace_start}
4481 ${definition}
4482 ${namespace_end}
4483 #endif
4484 "
4485       cpp_src "${comment}
4486 ${includes}
4487 ${namespace_start}
4488 ${members}
4489 ${namespace_end}"
4490       associated_classes
4491         class_ref 140290 // anonymous1
4492         class_ref 140418 // wxTreeMultiItem
4493         class_ref 140546 // wxTreeMultiWindowInfo
4494         class_ref 140802 // typedef23
4495         class_ref 140674 // wxTreeMultiCtrl
4496       end
4497     end
4498
4499     artifact 132098 "wxTreeMultiEvent"
4500       stereotype "source"
4501       cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
4502 #define ${NAMESPACE}_${NAME}_H
4503
4504 ${comment}
4505 ${includes}
4506 ${declarations}
4507 ${namespace_start}
4508 ${definition}
4509 ${namespace_end}
4510 #endif
4511 "
4512       cpp_src "${comment}
4513 ${includes}
4514 ${namespace_start}
4515 ${members}
4516 ${namespace_end}"
4517       associated_classes
4518         class_ref 141058 // typedef24
4519         class_ref 140930 // wxTreeMultiEvent
4520       end
4521     end
4522   end
4523 end