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