1 /* 2 * Copyright 2009-2015, Haiku, Inc. All rights reserved. 3 * Distributed under the terms of the MIT License. 4 */ 5 #ifndef _LAYOUT_BUILDER_H 6 #define _LAYOUT_BUILDER_H 7 8 9 #include <new> 10 11 #include <CardLayout.h> 12 #include <CardView.h> 13 #include <GridLayout.h> 14 #include <GridView.h> 15 #include <GroupLayout.h> 16 #include <GroupView.h> 17 #include <Menu.h> 18 #include <MenuField.h> 19 #include <MenuItem.h> 20 #include <SpaceLayoutItem.h> 21 #include <SplitView.h> 22 #include <TextControl.h> 23 #include <Window.h> 24 25 26 namespace BLayoutBuilder { 27 28 template<typename ParentBuilder> class Base; 29 template<typename ParentBuilder = void*> class Group; 30 template<typename ParentBuilder = void*> class Grid; 31 template<typename ParentBuilder = void*> class Split; 32 template<typename ParentBuilder = void*> class Cards; 33 template<typename ParentBuilder = void*> class Menu; 34 template<typename ParentBuilder = void*> class MenuItem; 35 36 37 template<typename ParentBuilder> 38 class Base { 39 protected: 40 inline Base(); 41 42 public: 43 inline void SetParent(ParentBuilder* parent); 44 // conceptually private 45 inline ParentBuilder& End(); 46 47 protected: 48 ParentBuilder* fParent; 49 }; 50 51 52 template<typename ParentBuilder> 53 class Group : public Base<ParentBuilder> { 54 public: 55 typedef Group<ParentBuilder> ThisBuilder; 56 typedef Group<ThisBuilder> GroupBuilder; 57 typedef Grid<ThisBuilder> GridBuilder; 58 typedef Split<ThisBuilder> SplitBuilder; 59 typedef Cards<ThisBuilder> CardBuilder; 60 61 public: 62 inline Group(orientation orientation = B_HORIZONTAL, 63 float spacing = B_USE_DEFAULT_SPACING); 64 inline Group(BWindow* window, 65 orientation orientation = B_HORIZONTAL, 66 float spacing = B_USE_DEFAULT_SPACING); 67 inline Group(BView* view, 68 orientation orientation = B_HORIZONTAL, 69 float spacing = B_USE_DEFAULT_SPACING); 70 inline Group(BGroupLayout* layout); 71 inline Group(BGroupView* view); 72 73 inline BGroupLayout* Layout() const; 74 inline BView* View() const; 75 inline ThisBuilder& GetLayout(BGroupLayout** _layout); 76 inline ThisBuilder& GetView(BView** _view); 77 78 inline ThisBuilder& Add(BView* view); 79 inline ThisBuilder& Add(BView* view, float weight); 80 inline ThisBuilder& Add(BLayoutItem* item); 81 inline ThisBuilder& Add(BLayoutItem* item, float weight); 82 83 inline GroupBuilder AddGroup(orientation orientation, 84 float spacing = B_USE_DEFAULT_SPACING, 85 float weight = 1.0f); 86 inline GroupBuilder AddGroup(BGroupView* groupView, 87 float weight = 1.0f); 88 inline GroupBuilder AddGroup(BGroupLayout* groupLayout, 89 float weight = 1.0f); 90 91 inline GridBuilder AddGrid(float horizontal 92 = B_USE_DEFAULT_SPACING, 93 float vertical = B_USE_DEFAULT_SPACING, 94 float weight = 1.0f); 95 inline GridBuilder AddGrid(BGridLayout* gridLayout, 96 float weight = 1.0f); 97 inline GridBuilder AddGrid(BGridView* gridView, 98 float weight = 1.0f); 99 100 inline SplitBuilder AddSplit(orientation orientation, 101 float spacing = B_USE_DEFAULT_SPACING, 102 float weight = 1.0f); 103 inline SplitBuilder AddSplit(BSplitView* splitView, 104 float weight = 1.0f); 105 106 inline CardBuilder AddCards(float weight = 1.0f); 107 inline CardBuilder AddCards(BCardLayout* cardLayout, 108 float weight = 1.0f); 109 inline CardBuilder AddCards(BCardView* cardView, 110 float weight = 1.0f); 111 112 inline ThisBuilder& AddGlue(float weight = 1.0f); 113 inline ThisBuilder& AddStrut(float size); 114 115 inline ThisBuilder& SetInsets(float left, float top, float right, 116 float bottom); 117 inline ThisBuilder& SetInsets(float horizontal, float vertical); 118 inline ThisBuilder& SetInsets(float insets); 119 120 inline ThisBuilder& SetExplicitMinSize(BSize size); 121 inline ThisBuilder& SetExplicitMaxSize(BSize size); 122 inline ThisBuilder& SetExplicitPreferredSize(BSize size); 123 inline ThisBuilder& SetExplicitAlignment(BAlignment alignment); 124 125 inline operator BGroupLayout*(); 126 127 private: 128 BGroupLayout* fLayout; 129 }; 130 131 132 template<typename ParentBuilder> 133 class Grid : public Base<ParentBuilder> { 134 public: 135 typedef Grid<ParentBuilder> ThisBuilder; 136 typedef Group<ThisBuilder> GroupBuilder; 137 typedef Grid<ThisBuilder> GridBuilder; 138 typedef Split<ThisBuilder> SplitBuilder; 139 typedef Cards<ThisBuilder> CardBuilder; 140 141 public: 142 inline Grid(float horizontal 143 = B_USE_DEFAULT_SPACING, 144 float vertical = B_USE_DEFAULT_SPACING); 145 inline Grid(BWindow* window, 146 float horizontal = B_USE_DEFAULT_SPACING, 147 float vertical = B_USE_DEFAULT_SPACING); 148 inline Grid(BView* view, 149 float horizontal = B_USE_DEFAULT_SPACING, 150 float vertical = B_USE_DEFAULT_SPACING); 151 inline Grid(BGridLayout* layout); 152 inline Grid(BGridView* view); 153 154 inline BGridLayout* Layout() const; 155 inline BView* View() const; 156 inline ThisBuilder& GetLayout(BGridLayout** _layout); 157 inline ThisBuilder& GetView(BView** _view); 158 159 inline ThisBuilder& Add(BView* view, int32 column, int32 row, 160 int32 columnCount = 1, int32 rowCount = 1); 161 inline ThisBuilder& Add(BLayoutItem* item, int32 column, int32 row, 162 int32 columnCount = 1, int32 rowCount = 1); 163 inline ThisBuilder& AddMenuField(BMenuField* menuField, 164 int32 column, int32 row, 165 alignment labelAlignment 166 = B_ALIGN_HORIZONTAL_UNSET, 167 int32 labelColumnCount = 1, 168 int32 fieldColumnCount = 1, 169 int32 rowCount = 1); 170 inline ThisBuilder& AddTextControl(BTextControl* textControl, 171 int32 column, int32 row, 172 alignment labelAlignment 173 = B_ALIGN_HORIZONTAL_UNSET, 174 int32 labelColumnCount = 1, 175 int32 textColumnCount = 1, 176 int32 rowCount = 1); 177 178 inline GroupBuilder AddGroup(orientation orientation, 179 float spacing, int32 column, int32 row, 180 int32 columnCount = 1, int32 rowCount = 1); 181 inline GroupBuilder AddGroup(BGroupView* groupView, int32 column, 182 int32 row, int32 columnCount = 1, 183 int32 rowCount = 1); 184 inline GroupBuilder AddGroup(BGroupLayout* groupLayout, 185 int32 column, int32 row, 186 int32 columnCount = 1, int32 rowCount = 1); 187 188 inline GridBuilder AddGrid(float horizontalSpacing, 189 float verticalSpacing, int32 column, 190 int32 row, int32 columnCount = 1, 191 int32 rowCount = 1); 192 inline GridBuilder AddGrid(BGridLayout* gridLayout, 193 int32 column, int32 row, 194 int32 columnCount = 1, int32 rowCount = 1); 195 inline GridBuilder AddGrid(BGridView* gridView, 196 int32 column, int32 row, 197 int32 columnCount = 1, int32 rowCount = 1); 198 199 inline SplitBuilder AddSplit(orientation orientation, 200 float spacing, int32 column, int32 row, 201 int32 columnCount = 1, int32 rowCount = 1); 202 inline SplitBuilder AddSplit(BSplitView* splitView, int32 column, 203 int32 row, int32 columnCount = 1, 204 int32 rowCount = 1); 205 206 inline CardBuilder AddCards(int32 column, int32 row, 207 int32 columnCount = 1, int32 rowCount = 1); 208 inline CardBuilder AddCards(BCardLayout* cardLayout, int32 column, 209 int32 row, int32 columnCount = 1, 210 int32 rowCount = 1); 211 inline CardBuilder AddCards(BCardView* cardView, int32 column, 212 int32 row, int32 columnCount = 1, 213 int32 rowCount = 1); 214 215 inline ThisBuilder& AddGlue(int32 column, int32 row, 216 int32 columnCount = 1, int32 rowCount = 1); 217 218 inline ThisBuilder& SetHorizontalSpacing(float spacing); 219 inline ThisBuilder& SetVerticalSpacing(float spacing); 220 inline ThisBuilder& SetSpacing(float horizontal, float vertical); 221 222 inline ThisBuilder& SetColumnWeight(int32 column, float weight); 223 inline ThisBuilder& SetRowWeight(int32 row, float weight); 224 225 inline ThisBuilder& SetInsets(float left, float top, float right, 226 float bottom); 227 inline ThisBuilder& SetInsets(float horizontal, float vertical); 228 inline ThisBuilder& SetInsets(float insets); 229 230 inline ThisBuilder& SetExplicitMinSize(BSize size); 231 inline ThisBuilder& SetExplicitMaxSize(BSize size); 232 inline ThisBuilder& SetExplicitPreferredSize(BSize size); 233 inline ThisBuilder& SetExplicitAlignment(BAlignment alignment); 234 235 inline operator BGridLayout*(); 236 237 private: 238 BGridLayout* fLayout; 239 }; 240 241 242 template<typename ParentBuilder> 243 class Split : public Base<ParentBuilder> { 244 public: 245 typedef Split<ParentBuilder> ThisBuilder; 246 typedef Group<ThisBuilder> GroupBuilder; 247 typedef Grid<ThisBuilder> GridBuilder; 248 typedef Split<ThisBuilder> SplitBuilder; 249 typedef Cards<ThisBuilder> CardBuilder; 250 251 public: 252 inline Split(orientation orientation = B_HORIZONTAL, 253 float spacing = B_USE_DEFAULT_SPACING); 254 inline Split(BSplitView* view); 255 256 inline BSplitView* View() const; 257 inline ThisBuilder& GetView(BView** _view); 258 inline ThisBuilder& GetSplitView(BSplitView** _view); 259 260 inline ThisBuilder& Add(BView* view); 261 inline ThisBuilder& Add(BView* view, float weight); 262 inline ThisBuilder& Add(BLayoutItem* item); 263 inline ThisBuilder& Add(BLayoutItem* item, float weight); 264 265 inline GroupBuilder AddGroup(orientation orientation, 266 float spacing = B_USE_DEFAULT_SPACING, 267 float weight = 1.0f); 268 inline GroupBuilder AddGroup(BGroupView* groupView, 269 float weight = 1.0f); 270 inline GroupBuilder AddGroup(BGroupLayout* groupLayout, 271 float weight = 1.0f); 272 273 inline GridBuilder AddGrid(float horizontal 274 = B_USE_DEFAULT_SPACING, 275 float vertical = B_USE_DEFAULT_SPACING, 276 float weight = 1.0f); 277 inline GridBuilder AddGrid(BGridView* gridView, 278 float weight = 1.0f); 279 inline GridBuilder AddGrid(BGridLayout* gridLayout, 280 float weight = 1.0f); 281 282 inline SplitBuilder AddSplit(orientation orientation, 283 float spacing = B_USE_DEFAULT_SPACING, 284 float weight = 1.0f); 285 inline SplitBuilder AddSplit(BSplitView* splitView, 286 float weight = 1.0f); 287 288 inline CardBuilder AddCards(float weight = 1.0f); 289 inline CardBuilder AddCards(BCardLayout* cardLayout, 290 float weight = 1.0f); 291 inline CardBuilder AddCards(BCardView* cardView, 292 float weight = 1.0f); 293 294 inline ThisBuilder& SetCollapsible(bool collapsible); 295 inline ThisBuilder& SetCollapsible(int32 index, bool collapsible); 296 inline ThisBuilder& SetCollapsible(int32 first, int32 last, 297 bool collapsible); 298 299 inline ThisBuilder& SetInsets(float left, float top, float right, 300 float bottom); 301 inline ThisBuilder& SetInsets(float horizontal, float vertical); 302 inline ThisBuilder& SetInsets(float insets); 303 304 inline operator BSplitView*(); 305 306 private: 307 BSplitView* fView; 308 }; 309 310 template<typename ParentBuilder> 311 class Cards : public Base<ParentBuilder> { 312 public: 313 typedef Cards<ParentBuilder> ThisBuilder; 314 typedef Group<ThisBuilder> GroupBuilder; 315 typedef Grid<ThisBuilder> GridBuilder; 316 typedef Split<ThisBuilder> SplitBuilder; 317 typedef Cards<ThisBuilder> CardBuilder; 318 319 public: 320 inline Cards(); 321 inline Cards(BWindow* window); 322 inline Cards(BView* view); 323 inline Cards(BCardLayout* layout); 324 inline Cards(BCardView* view); 325 326 inline BCardLayout* Layout() const; 327 inline BView* View() const; 328 inline ThisBuilder& GetLayout(BCardLayout** _layout); 329 inline ThisBuilder& GetView(BView** _view); 330 331 inline ThisBuilder& Add(BView* view); 332 inline ThisBuilder& Add(BLayoutItem* item); 333 334 inline GroupBuilder AddGroup(orientation orientation, 335 float spacing = B_USE_DEFAULT_SPACING); 336 inline GroupBuilder AddGroup(BGroupView* groupView); 337 inline GroupBuilder AddGroup(BGroupLayout* groupLayout); 338 339 inline GridBuilder AddGrid(float horizontal 340 = B_USE_DEFAULT_SPACING, 341 float vertical = B_USE_DEFAULT_SPACING); 342 inline GridBuilder AddGrid(BGridLayout* gridLayout); 343 inline GridBuilder AddGrid(BGridView* gridView); 344 345 inline SplitBuilder AddSplit(orientation orientation, 346 float spacing = B_USE_DEFAULT_SPACING); 347 inline SplitBuilder AddSplit(BSplitView* splitView); 348 349 inline CardBuilder AddCards(); 350 inline CardBuilder AddCards(BCardLayout* cardLayout); 351 inline CardBuilder AddCards(BCardView* cardView); 352 353 inline ThisBuilder& SetExplicitMinSize(BSize size); 354 inline ThisBuilder& SetExplicitMaxSize(BSize size); 355 inline ThisBuilder& SetExplicitPreferredSize(BSize size); 356 inline ThisBuilder& SetExplicitAlignment(BAlignment alignment); 357 358 inline ThisBuilder& SetVisibleItem(int32 index); 359 360 inline operator BCardLayout*(); 361 362 private: 363 BCardLayout* fLayout; 364 }; 365 366 367 template<typename ParentBuilder> 368 class Menu : public Base<ParentBuilder> { 369 public: 370 typedef Menu<ParentBuilder> ThisBuilder; 371 typedef MenuItem<ParentBuilder> ItemBuilder; 372 typedef Menu<ThisBuilder> MenuBuilder; 373 374 public: 375 inline Menu(BMenu* menu); 376 377 inline ThisBuilder& GetMenu(BMenu*& _menu); 378 379 inline ItemBuilder AddItem(BMenuItem* item); 380 inline ItemBuilder AddItem(BMenu* menu); 381 inline ItemBuilder AddItem(const char* label, BMessage* message, 382 char shortcut = 0, uint32 modifiers = 0); 383 inline ItemBuilder AddItem(const char* label, uint32 messageWhat, 384 char shortcut = 0, uint32 modifiers = 0); 385 386 inline MenuBuilder AddMenu(BMenu* menu); 387 inline MenuBuilder AddMenu(const char* title, 388 menu_layout layout = B_ITEMS_IN_COLUMN); 389 390 inline ThisBuilder& AddSeparator(); 391 392 private: 393 BMenu* fMenu; 394 }; 395 396 397 template<typename ParentBuilder> 398 class MenuItem : public Menu<ParentBuilder> { 399 public: 400 typedef MenuItem<ParentBuilder> ThisBuilder; 401 402 public: 403 inline MenuItem(ParentBuilder* parentBuilder, 404 BMenu* menu, BMenuItem* item); 405 406 inline ThisBuilder& GetItem(BMenuItem*& _item); 407 408 inline ThisBuilder& SetEnabled(bool enabled); 409 410 private: 411 BMenuItem* fMenuItem; 412 }; 413 414 415 // #pragma mark - Base 416 417 418 template<typename ParentBuilder> 419 Base<ParentBuilder>::Base() 420 : 421 fParent(NULL) 422 { 423 } 424 425 426 template<typename ParentBuilder> 427 void 428 Base<ParentBuilder>::SetParent(ParentBuilder* parent) 429 { 430 fParent = parent; 431 } 432 433 434 template<typename ParentBuilder> 435 ParentBuilder& 436 Base<ParentBuilder>::End() 437 { 438 return *fParent; 439 } 440 441 442 // #pragma mark - Group 443 444 445 template<typename ParentBuilder> 446 Group<ParentBuilder>::Group(orientation orientation, float spacing) 447 : 448 fLayout((new BGroupView(orientation, spacing))->GroupLayout()) 449 { 450 } 451 452 453 template<typename ParentBuilder> 454 Group<ParentBuilder>::Group(BWindow* window, orientation orientation, 455 float spacing) 456 : 457 fLayout(new BGroupLayout(orientation, spacing)) 458 { 459 window->SetLayout(fLayout); 460 fLayout->Owner()->AdoptSystemColors(); 461 } 462 463 464 template<typename ParentBuilder> 465 Group<ParentBuilder>::Group(BView* view, orientation orientation, 466 float spacing) 467 : 468 fLayout(new BGroupLayout(orientation, spacing)) 469 { 470 471 if (view->HasDefaultColors()) 472 view->AdoptSystemColors(); 473 474 view->SetLayout(fLayout); 475 } 476 477 478 template<typename ParentBuilder> 479 Group<ParentBuilder>::Group(BGroupLayout* layout) 480 : 481 fLayout(layout) 482 { 483 } 484 485 486 template<typename ParentBuilder> 487 Group<ParentBuilder>::Group(BGroupView* view) 488 : 489 fLayout(view->GroupLayout()) 490 { 491 } 492 493 494 template<typename ParentBuilder> 495 BGroupLayout* 496 Group<ParentBuilder>::Layout() const 497 { 498 return fLayout; 499 } 500 501 502 template<typename ParentBuilder> 503 BView* 504 Group<ParentBuilder>::View() const 505 { 506 return fLayout->Owner(); 507 } 508 509 510 template<typename ParentBuilder> 511 typename Group<ParentBuilder>::ThisBuilder& 512 Group<ParentBuilder>::GetLayout(BGroupLayout** _layout) 513 { 514 *_layout = fLayout; 515 return *this; 516 } 517 518 519 template<typename ParentBuilder> 520 typename Group<ParentBuilder>::ThisBuilder& 521 Group<ParentBuilder>::GetView(BView** _view) 522 { 523 *_view = fLayout->Owner(); 524 return *this; 525 } 526 527 528 template<typename ParentBuilder> 529 typename Group<ParentBuilder>::ThisBuilder& 530 Group<ParentBuilder>::Add(BView* view) 531 { 532 fLayout->AddView(view); 533 return *this; 534 } 535 536 537 template<typename ParentBuilder> 538 typename Group<ParentBuilder>::ThisBuilder& 539 Group<ParentBuilder>::Add(BView* view, float weight) 540 { 541 fLayout->AddView(view, weight); 542 return *this; 543 } 544 545 546 template<typename ParentBuilder> 547 typename Group<ParentBuilder>::ThisBuilder& 548 Group<ParentBuilder>::Add(BLayoutItem* item) 549 { 550 fLayout->AddItem(item); 551 return *this; 552 } 553 554 555 template<typename ParentBuilder> 556 typename Group<ParentBuilder>::ThisBuilder& 557 Group<ParentBuilder>::Add(BLayoutItem* item, float weight) 558 { 559 fLayout->AddItem(item, weight); 560 return *this; 561 } 562 563 564 template<typename ParentBuilder> 565 typename Group<ParentBuilder>::GroupBuilder 566 Group<ParentBuilder>::AddGroup(orientation orientation, float spacing, 567 float weight) 568 { 569 GroupBuilder builder(new BGroupLayout(orientation, spacing)); 570 builder.SetParent(this); 571 fLayout->AddItem(builder.Layout(), weight); 572 return builder; 573 } 574 575 576 template<typename ParentBuilder> 577 typename Group<ParentBuilder>::GroupBuilder 578 Group<ParentBuilder>::AddGroup(BGroupView* groupView, float weight) 579 { 580 GroupBuilder builder(groupView); 581 builder.SetParent(this); 582 fLayout->AddItem(builder.Layout(), weight); 583 return builder; 584 } 585 586 587 template<typename ParentBuilder> 588 typename Group<ParentBuilder>::GroupBuilder 589 Group<ParentBuilder>::AddGroup(BGroupLayout* groupLayout, float weight) 590 { 591 GroupBuilder builder(groupLayout); 592 builder.SetParent(this); 593 fLayout->AddItem(builder.Layout(), weight); 594 return builder; 595 } 596 597 598 template<typename ParentBuilder> 599 typename Group<ParentBuilder>::GridBuilder 600 Group<ParentBuilder>::AddGrid(float horizontalSpacing, 601 float verticalSpacing, float weight) 602 { 603 GridBuilder builder(new BGridLayout(horizontalSpacing, verticalSpacing)); 604 builder.SetParent(this); 605 fLayout->AddItem(builder.Layout(), weight); 606 return builder; 607 } 608 609 610 template<typename ParentBuilder> 611 typename Group<ParentBuilder>::GridBuilder 612 Group<ParentBuilder>::AddGrid(BGridLayout* gridLayout, float weight) 613 { 614 GridBuilder builder(gridLayout); 615 builder.SetParent(this); 616 fLayout->AddItem(builder.Layout(), weight); 617 return builder; 618 } 619 620 621 template<typename ParentBuilder> 622 typename Group<ParentBuilder>::GridBuilder 623 Group<ParentBuilder>::AddGrid(BGridView* gridView, float weight) 624 { 625 GridBuilder builder(gridView); 626 builder.SetParent(this); 627 fLayout->AddItem(builder.Layout(), weight); 628 return builder; 629 } 630 631 632 template<typename ParentBuilder> 633 typename Group<ParentBuilder>::SplitBuilder 634 Group<ParentBuilder>::AddSplit(orientation orientation, float spacing, 635 float weight) 636 { 637 SplitBuilder builder(orientation, spacing); 638 builder.SetParent(this); 639 fLayout->AddView(builder.View(), weight); 640 return builder; 641 } 642 643 644 template<typename ParentBuilder> 645 typename Group<ParentBuilder>::SplitBuilder 646 Group<ParentBuilder>::AddSplit(BSplitView* splitView, float weight) 647 { 648 SplitBuilder builder(splitView); 649 builder.SetParent(this); 650 fLayout->AddView(builder.View(), weight); 651 return builder; 652 } 653 654 655 template<typename ParentBuilder> 656 typename Group<ParentBuilder>::CardBuilder 657 Group<ParentBuilder>::AddCards(float weight) 658 { 659 CardBuilder builder; 660 builder.SetParent(this); 661 fLayout->AddView(builder.View(), weight); 662 return builder; 663 } 664 665 666 template<typename ParentBuilder> 667 typename Group<ParentBuilder>::CardBuilder 668 Group<ParentBuilder>::AddCards(BCardLayout* cardLayout, float weight) 669 { 670 CardBuilder builder(cardLayout); 671 builder.SetParent(this); 672 fLayout->AddView(builder.View(), weight); 673 return builder; 674 } 675 676 677 template<typename ParentBuilder> 678 typename Group<ParentBuilder>::CardBuilder 679 Group<ParentBuilder>::AddCards(BCardView* cardView, float weight) 680 { 681 CardBuilder builder(cardView); 682 builder.SetParent(this); 683 fLayout->AddView(builder.View(), weight); 684 return builder; 685 } 686 687 688 template<typename ParentBuilder> 689 typename Group<ParentBuilder>::ThisBuilder& 690 Group<ParentBuilder>::AddGlue(float weight) 691 { 692 fLayout->AddItem(BSpaceLayoutItem::CreateGlue(), weight); 693 return *this; 694 } 695 696 697 template<typename ParentBuilder> 698 typename Group<ParentBuilder>::ThisBuilder& 699 Group<ParentBuilder>::AddStrut(float size) 700 { 701 if (fLayout->Orientation() == B_HORIZONTAL) 702 fLayout->AddItem(BSpaceLayoutItem::CreateHorizontalStrut(size)); 703 else 704 fLayout->AddItem(BSpaceLayoutItem::CreateVerticalStrut(size)); 705 706 return *this; 707 } 708 709 710 template<typename ParentBuilder> 711 typename Group<ParentBuilder>::ThisBuilder& 712 Group<ParentBuilder>::SetInsets(float left, float top, float right, 713 float bottom) 714 { 715 fLayout->SetInsets(left, top, right, bottom); 716 return *this; 717 } 718 719 720 template<typename ParentBuilder> 721 typename Group<ParentBuilder>::ThisBuilder& 722 Group<ParentBuilder>::SetInsets(float horizontal, float vertical) 723 { 724 fLayout->SetInsets(horizontal, vertical); 725 return *this; 726 } 727 728 729 template<typename ParentBuilder> 730 typename Group<ParentBuilder>::ThisBuilder& 731 Group<ParentBuilder>::SetInsets(float insets) 732 { 733 fLayout->SetInsets(insets); 734 return *this; 735 } 736 737 738 template<typename ParentBuilder> 739 typename Group<ParentBuilder>::ThisBuilder& 740 Group<ParentBuilder>::SetExplicitMinSize(BSize size) 741 { 742 fLayout->SetExplicitMinSize(size); 743 return *this; 744 } 745 746 747 template<typename ParentBuilder> 748 typename Group<ParentBuilder>::ThisBuilder& 749 Group<ParentBuilder>::SetExplicitMaxSize(BSize size) 750 { 751 fLayout->SetExplicitMaxSize(size); 752 return *this; 753 } 754 755 756 template<typename ParentBuilder> 757 typename Group<ParentBuilder>::ThisBuilder& 758 Group<ParentBuilder>::SetExplicitPreferredSize(BSize size) 759 { 760 fLayout->SetExplicitPreferredSize(size); 761 return *this; 762 } 763 764 765 template<typename ParentBuilder> 766 typename Group<ParentBuilder>::ThisBuilder& 767 Group<ParentBuilder>::SetExplicitAlignment(BAlignment alignment) 768 { 769 fLayout->SetExplicitAlignment(alignment); 770 return *this; 771 } 772 773 774 template<typename ParentBuilder> 775 Group<ParentBuilder>::operator BGroupLayout*() 776 { 777 return fLayout; 778 } 779 780 781 // #pragma mark - Grid 782 783 784 template<typename ParentBuilder> 785 Grid<ParentBuilder>::Grid(float horizontalSpacing, float verticalSpacing) 786 : 787 fLayout((new BGridView(horizontalSpacing, verticalSpacing))->GridLayout()) 788 { 789 } 790 791 792 template<typename ParentBuilder> 793 Grid<ParentBuilder>::Grid(BWindow* window, float horizontalSpacing, 794 float verticalSpacing) 795 : 796 fLayout(new BGridLayout(horizontalSpacing, verticalSpacing)) 797 { 798 window->SetLayout(fLayout); 799 fLayout->Owner()->AdoptSystemColors(); 800 } 801 802 803 template<typename ParentBuilder> 804 Grid<ParentBuilder>::Grid(BView* view, float horizontalSpacing, 805 float verticalSpacing) 806 : 807 fLayout(new BGridLayout(horizontalSpacing, verticalSpacing)) 808 { 809 if (view->HasDefaultColors()) 810 view->AdoptSystemColors(); 811 812 view->SetLayout(fLayout); 813 } 814 815 816 template<typename ParentBuilder> 817 Grid<ParentBuilder>::Grid(BGridLayout* layout) 818 : 819 fLayout(layout) 820 { 821 } 822 823 824 template<typename ParentBuilder> 825 Grid<ParentBuilder>::Grid(BGridView* view) 826 : 827 fLayout(view->GridLayout()) 828 { 829 } 830 831 832 template<typename ParentBuilder> 833 BGridLayout* 834 Grid<ParentBuilder>::Layout() const 835 { 836 return fLayout; 837 } 838 839 840 template<typename ParentBuilder> 841 BView* 842 Grid<ParentBuilder>::View() const 843 { 844 return fLayout->Owner(); 845 } 846 847 848 template<typename ParentBuilder> 849 typename Grid<ParentBuilder>::ThisBuilder& 850 Grid<ParentBuilder>::GetLayout(BGridLayout** _layout) 851 { 852 *_layout = fLayout; 853 return *this; 854 } 855 856 857 template<typename ParentBuilder> 858 typename Grid<ParentBuilder>::ThisBuilder& 859 Grid<ParentBuilder>::GetView(BView** _view) 860 { 861 *_view = fLayout->Owner(); 862 return *this; 863 } 864 865 866 template<typename ParentBuilder> 867 typename Grid<ParentBuilder>::ThisBuilder& 868 Grid<ParentBuilder>::Add(BView* view, int32 column, int32 row, 869 int32 columnCount, int32 rowCount) 870 { 871 fLayout->AddView(view, column, row, columnCount, rowCount); 872 return *this; 873 } 874 875 876 template<typename ParentBuilder> 877 typename Grid<ParentBuilder>::ThisBuilder& 878 Grid<ParentBuilder>::Add(BLayoutItem* item, int32 column, int32 row, 879 int32 columnCount, int32 rowCount) 880 { 881 fLayout->AddItem(item, column, row, columnCount, rowCount); 882 return *this; 883 } 884 885 886 template<typename ParentBuilder> 887 typename Grid<ParentBuilder>::ThisBuilder& 888 Grid<ParentBuilder>::AddMenuField(BMenuField* menuField, int32 column, 889 int32 row, alignment labelAlignment, int32 labelColumnCount, 890 int32 fieldColumnCount, int32 rowCount) 891 { 892 BLayoutItem* item = menuField->CreateLabelLayoutItem(); 893 item->SetExplicitAlignment( 894 BAlignment(labelAlignment, B_ALIGN_VERTICAL_UNSET)); 895 fLayout->AddItem(item, column, row, labelColumnCount, rowCount); 896 fLayout->AddItem(menuField->CreateMenuBarLayoutItem(), 897 column + labelColumnCount, row, fieldColumnCount, rowCount); 898 return *this; 899 } 900 901 902 template<typename ParentBuilder> 903 typename Grid<ParentBuilder>::ThisBuilder& 904 Grid<ParentBuilder>::AddTextControl(BTextControl* textControl, int32 column, 905 int32 row, alignment labelAlignment, int32 labelColumnCount, 906 int32 textColumnCount, int32 rowCount) 907 { 908 BLayoutItem* item = textControl->CreateLabelLayoutItem(); 909 item->SetExplicitAlignment( 910 BAlignment(labelAlignment, B_ALIGN_VERTICAL_UNSET)); 911 fLayout->AddItem(item, column, row, labelColumnCount, rowCount); 912 fLayout->AddItem(textControl->CreateTextViewLayoutItem(), 913 column + labelColumnCount, row, textColumnCount, rowCount); 914 return *this; 915 } 916 917 918 template<typename ParentBuilder> 919 typename Grid<ParentBuilder>::GroupBuilder 920 Grid<ParentBuilder>::AddGroup(orientation orientation, float spacing, 921 int32 column, int32 row, int32 columnCount, int32 rowCount) 922 { 923 GroupBuilder builder(new BGroupLayout(orientation, spacing)); 924 builder.SetParent(this); 925 fLayout->AddItem(builder.Layout(), column, row, columnCount, rowCount); 926 return builder; 927 } 928 929 930 template<typename ParentBuilder> 931 typename Grid<ParentBuilder>::GroupBuilder 932 Grid<ParentBuilder>::AddGroup(BGroupView* groupView, int32 column, int32 row, 933 int32 columnCount, int32 rowCount) 934 { 935 GroupBuilder builder(groupView); 936 builder.SetParent(this); 937 fLayout->AddItem(builder.Layout(), column, row, columnCount, rowCount); 938 return builder; 939 } 940 941 942 template<typename ParentBuilder> 943 typename Grid<ParentBuilder>::GroupBuilder 944 Grid<ParentBuilder>::AddGroup(BGroupLayout* groupLayout, int32 column, 945 int32 row, int32 columnCount, int32 rowCount) 946 { 947 GroupBuilder builder(groupLayout); 948 builder.SetParent(this); 949 fLayout->AddItem(builder.Layout(), column, row, columnCount, rowCount); 950 return builder; 951 } 952 953 954 template<typename ParentBuilder> 955 typename Grid<ParentBuilder>::GridBuilder 956 Grid<ParentBuilder>::AddGrid(float horizontalSpacing, float verticalSpacing, 957 int32 column, int32 row, int32 columnCount, int32 rowCount) 958 { 959 GridBuilder builder(new BGridLayout(horizontalSpacing, verticalSpacing)); 960 builder.SetParent(this); 961 fLayout->AddItem(builder.Layout(), column, row, columnCount, rowCount); 962 return builder; 963 } 964 965 966 template<typename ParentBuilder> 967 typename Grid<ParentBuilder>::GridBuilder 968 Grid<ParentBuilder>::AddGrid(BGridView* gridView, int32 column, int32 row, 969 int32 columnCount, int32 rowCount) 970 { 971 GridBuilder builder(gridView); 972 builder.SetParent(this); 973 fLayout->AddView(builder.View(), column, row, columnCount, rowCount); 974 return builder; 975 } 976 977 978 template<typename ParentBuilder> 979 typename Grid<ParentBuilder>::SplitBuilder 980 Grid<ParentBuilder>::AddSplit(orientation orientation, float spacing, 981 int32 column, int32 row, int32 columnCount, int32 rowCount) 982 { 983 SplitBuilder builder(orientation, spacing); 984 builder.SetParent(this); 985 fLayout->AddView(builder.View(), column, row, columnCount, rowCount); 986 return builder; 987 } 988 989 990 template<typename ParentBuilder> 991 typename Grid<ParentBuilder>::SplitBuilder 992 Grid<ParentBuilder>::AddSplit(BSplitView* splitView, int32 column, int32 row, 993 int32 columnCount, int32 rowCount) 994 { 995 SplitBuilder builder(splitView); 996 builder.SetParent(this); 997 fLayout->AddView(builder.View(), column, row, columnCount, rowCount); 998 return builder; 999 } 1000 1001 1002 template<typename ParentBuilder> 1003 typename Grid<ParentBuilder>::CardBuilder 1004 Grid<ParentBuilder>::AddCards(int32 column, int32 row, int32 columnCount, 1005 int32 rowCount) 1006 { 1007 CardBuilder builder; 1008 builder.SetParent(this); 1009 fLayout->AddView(builder.View(), column, row, columnCount, rowCount); 1010 return builder; 1011 } 1012 1013 1014 template<typename ParentBuilder> 1015 typename Grid<ParentBuilder>::CardBuilder 1016 Grid<ParentBuilder>::AddCards(BCardLayout* cardLayout, int32 column, int32 row, 1017 int32 columnCount, int32 rowCount) 1018 { 1019 CardBuilder builder(cardLayout); 1020 builder.SetParent(this); 1021 fLayout->AddView(builder.View(), column, row, columnCount, rowCount); 1022 return builder; 1023 } 1024 1025 1026 template<typename ParentBuilder> 1027 typename Grid<ParentBuilder>::CardBuilder 1028 Grid<ParentBuilder>::AddCards(BCardView* cardView, int32 column, int32 row, 1029 int32 columnCount, int32 rowCount) 1030 { 1031 CardBuilder builder(cardView); 1032 builder.SetParent(this); 1033 fLayout->AddView(builder.View(), column, row, columnCount, rowCount); 1034 return builder; 1035 } 1036 1037 1038 template<typename ParentBuilder> 1039 typename Grid<ParentBuilder>::ThisBuilder& 1040 Grid<ParentBuilder>::AddGlue(int32 column, int32 row, int32 columnCount, 1041 int32 rowCount) 1042 { 1043 fLayout->AddItem(BSpaceLayoutItem::CreateGlue(), column, row, columnCount, 1044 rowCount); 1045 return *this; 1046 } 1047 1048 1049 template<typename ParentBuilder> 1050 typename Grid<ParentBuilder>::ThisBuilder& 1051 Grid<ParentBuilder>::SetHorizontalSpacing(float spacing) 1052 { 1053 fLayout->SetHorizontalSpacing(spacing); 1054 return *this; 1055 } 1056 1057 1058 template<typename ParentBuilder> 1059 typename Grid<ParentBuilder>::ThisBuilder& 1060 Grid<ParentBuilder>::SetVerticalSpacing(float spacing) 1061 { 1062 fLayout->SetVerticalSpacing(spacing); 1063 return *this; 1064 } 1065 1066 1067 template<typename ParentBuilder> 1068 typename Grid<ParentBuilder>::ThisBuilder& 1069 Grid<ParentBuilder>::SetSpacing(float horizontal, float vertical) 1070 { 1071 fLayout->SetSpacing(horizontal, vertical); 1072 return *this; 1073 } 1074 1075 1076 template<typename ParentBuilder> 1077 typename Grid<ParentBuilder>::ThisBuilder& 1078 Grid<ParentBuilder>::SetColumnWeight(int32 column, float weight) 1079 { 1080 fLayout->SetColumnWeight(column, weight); 1081 return *this; 1082 } 1083 1084 1085 template<typename ParentBuilder> 1086 typename Grid<ParentBuilder>::ThisBuilder& 1087 Grid<ParentBuilder>::SetRowWeight(int32 row, float weight) 1088 { 1089 fLayout->SetRowWeight(row, weight); 1090 return *this; 1091 } 1092 1093 1094 template<typename ParentBuilder> 1095 typename Grid<ParentBuilder>::ThisBuilder& 1096 Grid<ParentBuilder>::SetInsets(float left, float top, float right, 1097 float bottom) 1098 { 1099 fLayout->SetInsets(left, top, right, bottom); 1100 return *this; 1101 } 1102 1103 1104 template<typename ParentBuilder> 1105 typename Grid<ParentBuilder>::ThisBuilder& 1106 Grid<ParentBuilder>::SetInsets(float horizontal, float vertical) 1107 { 1108 fLayout->SetInsets(horizontal, vertical); 1109 return *this; 1110 } 1111 1112 1113 template<typename ParentBuilder> 1114 typename Grid<ParentBuilder>::ThisBuilder& 1115 Grid<ParentBuilder>::SetInsets(float insets) 1116 { 1117 fLayout->SetInsets(insets); 1118 return *this; 1119 } 1120 1121 1122 template<typename ParentBuilder> 1123 typename Grid<ParentBuilder>::ThisBuilder& 1124 Grid<ParentBuilder>::SetExplicitMinSize(BSize size) 1125 { 1126 fLayout->SetExplicitMinSize(size); 1127 return *this; 1128 } 1129 1130 1131 template<typename ParentBuilder> 1132 typename Grid<ParentBuilder>::ThisBuilder& 1133 Grid<ParentBuilder>::SetExplicitMaxSize(BSize size) 1134 { 1135 fLayout->SetExplicitMaxSize(size); 1136 return *this; 1137 } 1138 1139 1140 template<typename ParentBuilder> 1141 typename Grid<ParentBuilder>::ThisBuilder& 1142 Grid<ParentBuilder>::SetExplicitPreferredSize(BSize size) 1143 { 1144 fLayout->SetExplicitPreferredSize(size); 1145 return *this; 1146 } 1147 1148 1149 template<typename ParentBuilder> 1150 typename Grid<ParentBuilder>::ThisBuilder& 1151 Grid<ParentBuilder>::SetExplicitAlignment(BAlignment alignment) 1152 { 1153 fLayout->SetExplicitAlignment(alignment); 1154 return *this; 1155 } 1156 1157 1158 template<typename ParentBuilder> 1159 Grid<ParentBuilder>::operator BGridLayout*() 1160 { 1161 return fLayout; 1162 } 1163 1164 1165 // #pragma mark - Split 1166 1167 1168 template<typename ParentBuilder> 1169 Split<ParentBuilder>::Split(orientation orientation, float spacing) 1170 : 1171 fView(new BSplitView(orientation, spacing)) 1172 { 1173 } 1174 1175 1176 template<typename ParentBuilder> 1177 Split<ParentBuilder>::Split(BSplitView* view) 1178 : 1179 fView(view) 1180 { 1181 } 1182 1183 1184 template<typename ParentBuilder> 1185 BSplitView* 1186 Split<ParentBuilder>::View() const 1187 { 1188 return fView; 1189 } 1190 1191 1192 template<typename ParentBuilder> 1193 typename Split<ParentBuilder>::ThisBuilder& 1194 Split<ParentBuilder>::GetView(BView** _view) 1195 { 1196 *_view = fView; 1197 return *this; 1198 } 1199 1200 1201 template<typename ParentBuilder> 1202 typename Split<ParentBuilder>::ThisBuilder& 1203 Split<ParentBuilder>::GetSplitView(BSplitView** _view) 1204 { 1205 *_view = fView; 1206 return *this; 1207 } 1208 1209 1210 template<typename ParentBuilder> 1211 typename Split<ParentBuilder>::ThisBuilder& 1212 Split<ParentBuilder>::Add(BView* view) 1213 { 1214 fView->AddChild(view); 1215 return *this; 1216 } 1217 1218 1219 template<typename ParentBuilder> 1220 typename Split<ParentBuilder>::ThisBuilder& 1221 Split<ParentBuilder>::Add(BView* view, float weight) 1222 { 1223 fView->AddChild(view, weight); 1224 return *this; 1225 } 1226 1227 1228 template<typename ParentBuilder> 1229 typename Split<ParentBuilder>::ThisBuilder& 1230 Split<ParentBuilder>::Add(BLayoutItem* item) 1231 { 1232 fView->AddChild(item); 1233 return *this; 1234 } 1235 1236 1237 template<typename ParentBuilder> 1238 typename Split<ParentBuilder>::ThisBuilder& 1239 Split<ParentBuilder>::Add(BLayoutItem* item, float weight) 1240 { 1241 fView->AddChild(item, weight); 1242 return *this; 1243 } 1244 1245 1246 template<typename ParentBuilder> 1247 typename Split<ParentBuilder>::GroupBuilder 1248 Split<ParentBuilder>::AddGroup(orientation orientation, float spacing, 1249 float weight) 1250 { 1251 GroupBuilder builder(new BGroupLayout(orientation, spacing)); 1252 builder.SetParent(this); 1253 fView->AddChild(builder.Layout(), weight); 1254 return builder; 1255 } 1256 1257 1258 template<typename ParentBuilder> 1259 typename Split<ParentBuilder>::GroupBuilder 1260 Split<ParentBuilder>::AddGroup(BGroupView* groupView, float weight) 1261 { 1262 GroupBuilder builder(groupView); 1263 builder.SetParent(this); 1264 fView->AddChild(builder.Layout(), weight); 1265 return builder; 1266 } 1267 1268 1269 template<typename ParentBuilder> 1270 typename Split<ParentBuilder>::GroupBuilder 1271 Split<ParentBuilder>::AddGroup(BGroupLayout* groupLayout, float weight) 1272 { 1273 GroupBuilder builder(groupLayout); 1274 builder.SetParent(this); 1275 fView->AddChild(builder.Layout(), weight); 1276 return builder; 1277 } 1278 1279 1280 template<typename ParentBuilder> 1281 typename Split<ParentBuilder>::GridBuilder 1282 Split<ParentBuilder>::AddGrid(float horizontalSpacing, float verticalSpacing, 1283 float weight) 1284 { 1285 GridBuilder builder(new BGridLayout(horizontalSpacing, verticalSpacing)); 1286 builder.SetParent(this); 1287 fView->AddChild(builder.Layout(), weight); 1288 return builder; 1289 } 1290 1291 1292 template<typename ParentBuilder> 1293 typename Split<ParentBuilder>::GridBuilder 1294 Split<ParentBuilder>::AddGrid(BGridView* gridView, float weight) 1295 { 1296 GridBuilder builder(gridView); 1297 builder.SetParent(this); 1298 fView->AddChild(builder.Layout(), weight); 1299 return builder; 1300 } 1301 1302 1303 template<typename ParentBuilder> 1304 typename Split<ParentBuilder>::GridBuilder 1305 Split<ParentBuilder>::AddGrid(BGridLayout* layout, float weight) 1306 { 1307 GridBuilder builder(layout); 1308 builder.SetParent(this); 1309 fView->AddChild(builder.Layout(), weight); 1310 return builder; 1311 } 1312 1313 1314 template<typename ParentBuilder> 1315 typename Split<ParentBuilder>::SplitBuilder 1316 Split<ParentBuilder>::AddSplit(orientation orientation, float spacing, 1317 float weight) 1318 { 1319 SplitBuilder builder(orientation, spacing); 1320 builder.SetParent(this); 1321 fView->AddChild(builder.View(), weight); 1322 return builder; 1323 } 1324 1325 1326 template<typename ParentBuilder> 1327 typename Split<ParentBuilder>::CardBuilder 1328 Split<ParentBuilder>::AddCards(float weight) 1329 { 1330 CardBuilder builder; 1331 builder.SetParent(this); 1332 fView->AddChild(builder.View(), weight); 1333 return builder; 1334 } 1335 1336 1337 template<typename ParentBuilder> 1338 typename Split<ParentBuilder>::CardBuilder 1339 Split<ParentBuilder>::AddCards(BCardLayout* cardLayout, float weight) 1340 { 1341 CardBuilder builder(cardLayout); 1342 builder.SetParent(this); 1343 fView->AddChild(builder.View(), weight); 1344 return builder; 1345 } 1346 1347 1348 template<typename ParentBuilder> 1349 typename Split<ParentBuilder>::CardBuilder 1350 Split<ParentBuilder>::AddCards(BCardView* cardView, float weight) 1351 { 1352 CardBuilder builder(cardView); 1353 builder.SetParent(this); 1354 fView->AddChild(builder.View(), weight); 1355 return builder; 1356 } 1357 1358 1359 template<typename ParentBuilder> 1360 typename Split<ParentBuilder>::ThisBuilder& 1361 Split<ParentBuilder>::SetCollapsible(bool collapsible) 1362 { 1363 fView->SetCollapsible(collapsible); 1364 return *this; 1365 } 1366 1367 1368 template<typename ParentBuilder> 1369 typename Split<ParentBuilder>::ThisBuilder& 1370 Split<ParentBuilder>::SetCollapsible(int32 index, bool collapsible) 1371 { 1372 fView->SetCollapsible(index, collapsible); 1373 return *this; 1374 } 1375 1376 1377 template<typename ParentBuilder> 1378 typename Split<ParentBuilder>::ThisBuilder& 1379 Split<ParentBuilder>::SetCollapsible(int32 first, int32 last, bool collapsible) 1380 { 1381 fView->SetCollapsible(first, last, collapsible); 1382 return *this; 1383 } 1384 1385 1386 template<typename ParentBuilder> 1387 typename Split<ParentBuilder>::ThisBuilder& 1388 Split<ParentBuilder>::SetInsets(float left, float top, float right, 1389 float bottom) 1390 { 1391 fView->SetInsets(left, top, right, bottom); 1392 return *this; 1393 } 1394 1395 1396 template<typename ParentBuilder> 1397 typename Split<ParentBuilder>::ThisBuilder& 1398 Split<ParentBuilder>::SetInsets(float horizontal, float vertical) 1399 { 1400 fView->SetInsets(horizontal, vertical); 1401 return *this; 1402 } 1403 1404 1405 template<typename ParentBuilder> 1406 typename Split<ParentBuilder>::ThisBuilder& 1407 Split<ParentBuilder>::SetInsets(float insets) 1408 { 1409 fView->SetInsets(insets); 1410 return *this; 1411 } 1412 1413 1414 template<typename ParentBuilder> 1415 Split<ParentBuilder>::operator BSplitView*() 1416 { 1417 return fView; 1418 } 1419 1420 1421 // #pragma mark - Cards 1422 1423 1424 template<typename ParentBuilder> 1425 Cards<ParentBuilder>::Cards() 1426 : 1427 fLayout((new BCardView())->CardLayout()) 1428 { 1429 } 1430 1431 1432 template<typename ParentBuilder> 1433 Cards<ParentBuilder>::Cards(BWindow* window) 1434 : 1435 fLayout(new BCardLayout()) 1436 { 1437 window->SetLayout(fLayout); 1438 1439 fLayout->Owner()->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); 1440 } 1441 1442 1443 template<typename ParentBuilder> 1444 Cards<ParentBuilder>::Cards(BView* view) 1445 : 1446 fLayout(new BCardLayout()) 1447 { 1448 view->SetLayout(fLayout); 1449 view->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); 1450 } 1451 1452 1453 template<typename ParentBuilder> 1454 Cards<ParentBuilder>::Cards(BCardLayout* layout) 1455 : 1456 fLayout(layout) 1457 { 1458 } 1459 1460 1461 template<typename ParentBuilder> 1462 Cards<ParentBuilder>::Cards(BCardView* view) 1463 : 1464 fLayout(view->CardLayout()) 1465 { 1466 } 1467 1468 1469 template<typename ParentBuilder> 1470 BCardLayout* 1471 Cards<ParentBuilder>::Layout() const 1472 { 1473 return fLayout; 1474 } 1475 1476 1477 template<typename ParentBuilder> 1478 BView* 1479 Cards<ParentBuilder>::View() const 1480 { 1481 return fLayout->Owner(); 1482 } 1483 1484 1485 template<typename ParentBuilder> 1486 typename Cards<ParentBuilder>::ThisBuilder& 1487 Cards<ParentBuilder>::GetLayout(BCardLayout** _layout) 1488 { 1489 *_layout = fLayout; 1490 return *this; 1491 } 1492 1493 1494 template<typename ParentBuilder> 1495 typename Cards<ParentBuilder>::ThisBuilder& 1496 Cards<ParentBuilder>::GetView(BView** _view) 1497 { 1498 *_view = fLayout->Owner(); 1499 return *this; 1500 } 1501 1502 1503 template<typename ParentBuilder> 1504 typename Cards<ParentBuilder>::ThisBuilder& 1505 Cards<ParentBuilder>::Add(BView* view) 1506 { 1507 fLayout->AddView(view); 1508 return *this; 1509 } 1510 1511 1512 template<typename ParentBuilder> 1513 typename Cards<ParentBuilder>::ThisBuilder& 1514 Cards<ParentBuilder>::Add(BLayoutItem* item) 1515 { 1516 fLayout->AddItem(item); 1517 return *this; 1518 } 1519 1520 1521 template<typename ParentBuilder> 1522 typename Cards<ParentBuilder>::GroupBuilder 1523 Cards<ParentBuilder>::AddGroup(orientation orientation, float spacing) 1524 { 1525 GroupBuilder builder(new BGroupLayout(orientation, spacing)); 1526 builder.SetParent(this); 1527 fLayout->AddItem(builder.Layout()); 1528 return builder; 1529 } 1530 1531 1532 template<typename ParentBuilder> 1533 typename Cards<ParentBuilder>::GroupBuilder 1534 Cards<ParentBuilder>::AddGroup(BGroupView* groupView) 1535 { 1536 GroupBuilder builder(groupView); 1537 builder.SetParent(this); 1538 fLayout->AddItem(builder.Layout()); 1539 return builder; 1540 } 1541 1542 1543 template<typename ParentBuilder> 1544 typename Cards<ParentBuilder>::GroupBuilder 1545 Cards<ParentBuilder>::AddGroup(BGroupLayout* groupLayout) 1546 { 1547 GroupBuilder builder(groupLayout); 1548 builder.SetParent(this); 1549 fLayout->AddItem(builder.Layout()); 1550 return builder; 1551 } 1552 1553 1554 template<typename ParentBuilder> 1555 typename Cards<ParentBuilder>::GridBuilder 1556 Cards<ParentBuilder>::AddGrid(float horizontal, float vertical) 1557 { 1558 GridBuilder builder(horizontal, vertical); 1559 builder.SetParent(this); 1560 fLayout->AddItem(builder.Layout()); 1561 return builder; 1562 } 1563 1564 1565 template<typename ParentBuilder> 1566 typename Cards<ParentBuilder>::GridBuilder 1567 Cards<ParentBuilder>::AddGrid(BGridLayout* gridLayout) 1568 { 1569 GridBuilder builder(gridLayout); 1570 builder.SetParent(this); 1571 fLayout->AddItem(builder.Layout()); 1572 return builder; 1573 } 1574 1575 1576 template<typename ParentBuilder> 1577 typename Cards<ParentBuilder>::GridBuilder 1578 Cards<ParentBuilder>::AddGrid(BGridView* gridView) 1579 { 1580 GridBuilder builder(gridView); 1581 builder.SetParent(this); 1582 fLayout->AddItem(builder.Layout()); 1583 return builder; 1584 } 1585 1586 1587 template<typename ParentBuilder> 1588 typename Cards<ParentBuilder>::SplitBuilder 1589 Cards<ParentBuilder>::AddSplit(orientation orientation, float spacing) 1590 { 1591 SplitBuilder builder(orientation, spacing); 1592 builder.SetParent(this); 1593 fLayout->AddView(builder.View()); 1594 return builder; 1595 } 1596 1597 1598 template<typename ParentBuilder> 1599 typename Cards<ParentBuilder>::SplitBuilder 1600 Cards<ParentBuilder>::AddSplit(BSplitView* splitView) 1601 { 1602 SplitBuilder builder(splitView); 1603 builder.SetParent(this); 1604 fLayout->AddView(builder.View()); 1605 return builder; 1606 } 1607 1608 1609 template<typename ParentBuilder> 1610 typename Cards<ParentBuilder>::CardBuilder 1611 Cards<ParentBuilder>::AddCards() 1612 { 1613 CardBuilder builder; 1614 builder.SetParent(this); 1615 fLayout->AddView(builder.View()); 1616 return builder; 1617 } 1618 1619 1620 template<typename ParentBuilder> 1621 typename Cards<ParentBuilder>::CardBuilder 1622 Cards<ParentBuilder>::AddCards(BCardLayout* cardLayout) 1623 { 1624 CardBuilder builder(cardLayout); 1625 builder.SetParent(this); 1626 fLayout->AddView(builder.View()); 1627 return builder; 1628 } 1629 1630 template<typename ParentBuilder> 1631 typename Cards<ParentBuilder>::CardBuilder 1632 Cards<ParentBuilder>::AddCards(BCardView* cardView) 1633 { 1634 CardBuilder builder(cardView); 1635 builder.SetParent(this); 1636 fLayout->AddView(builder.View()); 1637 return builder; 1638 } 1639 1640 1641 template<typename ParentBuilder> 1642 typename Cards<ParentBuilder>::ThisBuilder& 1643 Cards<ParentBuilder>::SetExplicitMinSize(BSize size) 1644 { 1645 fLayout->SetExplicitMinSize(size); 1646 return *this; 1647 } 1648 1649 1650 template<typename ParentBuilder> 1651 typename Cards<ParentBuilder>::ThisBuilder& 1652 Cards<ParentBuilder>::SetExplicitMaxSize(BSize size) 1653 { 1654 fLayout->SetExplicitMaxSize(size); 1655 return *this; 1656 } 1657 1658 1659 template<typename ParentBuilder> 1660 typename Cards<ParentBuilder>::ThisBuilder& 1661 Cards<ParentBuilder>::SetExplicitPreferredSize(BSize size) 1662 { 1663 fLayout->SetExplicitPreferredSize(size); 1664 return *this; 1665 } 1666 1667 1668 template<typename ParentBuilder> 1669 typename Cards<ParentBuilder>::ThisBuilder& 1670 Cards<ParentBuilder>::SetExplicitAlignment(BAlignment alignment) 1671 { 1672 fLayout->SetExplicitAlignment(alignment); 1673 return *this; 1674 } 1675 1676 1677 template<typename ParentBuilder> 1678 typename Cards<ParentBuilder>::ThisBuilder& 1679 Cards<ParentBuilder>::SetVisibleItem(int32 item) 1680 { 1681 fLayout->SetVisibleItem(item); 1682 return *this; 1683 } 1684 1685 1686 template<typename ParentBuilder> 1687 Cards<ParentBuilder>::operator BCardLayout*() 1688 { 1689 return fLayout; 1690 } 1691 1692 1693 // #pragma mark - Menu 1694 1695 1696 template<typename ParentBuilder> 1697 Menu<ParentBuilder>::Menu(BMenu* menu) 1698 : 1699 fMenu(menu) 1700 { 1701 } 1702 1703 1704 template<typename ParentBuilder> 1705 typename Menu<ParentBuilder>::ThisBuilder& 1706 Menu<ParentBuilder>::GetMenu(BMenu*& _menu) 1707 { 1708 _menu = fMenu; 1709 return *this; 1710 } 1711 1712 1713 template<typename ParentBuilder> 1714 typename Menu<ParentBuilder>::ItemBuilder 1715 Menu<ParentBuilder>::AddItem(BMenuItem* item) 1716 { 1717 fMenu->AddItem(item); 1718 return MenuItem<ParentBuilder>(this->fParent, fMenu, item); 1719 } 1720 1721 1722 template<typename ParentBuilder> 1723 typename Menu<ParentBuilder>::ItemBuilder 1724 Menu<ParentBuilder>::AddItem(BMenu* menu) 1725 { 1726 if (!fMenu->AddItem(menu)) 1727 throw std::bad_alloc(); 1728 1729 return MenuItem<ParentBuilder>(this->fParent, fMenu, 1730 fMenu->ItemAt(fMenu->CountItems() - 1)); 1731 } 1732 1733 1734 template<typename ParentBuilder> 1735 typename Menu<ParentBuilder>::ItemBuilder 1736 Menu<ParentBuilder>::AddItem(const char* label, BMessage* message, 1737 char shortcut, uint32 modifiers) 1738 { 1739 BMenuItem* item = new BMenuItem(label, message, shortcut, modifiers); 1740 if (!fMenu->AddItem(item)) { 1741 delete item; 1742 item = NULL; 1743 } 1744 1745 return MenuItem<ParentBuilder>(this->fParent, fMenu, item); 1746 } 1747 1748 1749 template<typename ParentBuilder> 1750 typename Menu<ParentBuilder>::ItemBuilder 1751 Menu<ParentBuilder>::AddItem(const char* label, uint32 messageWhat, 1752 char shortcut, uint32 modifiers) 1753 { 1754 BMessage* message = new BMessage(messageWhat); 1755 BMenuItem* item; 1756 try { 1757 item = new BMenuItem(label, message, shortcut, modifiers); 1758 } catch (...) { 1759 delete message; 1760 throw; 1761 } 1762 1763 if (!fMenu->AddItem(item)) { 1764 delete item; 1765 item = NULL; 1766 } 1767 1768 return MenuItem<ParentBuilder>(this->fParent, fMenu, item); 1769 } 1770 1771 1772 template<typename ParentBuilder> 1773 typename Menu<ParentBuilder>::ThisBuilder& 1774 Menu<ParentBuilder>::AddSeparator() 1775 { 1776 fMenu->AddSeparatorItem(); 1777 return *this; 1778 } 1779 1780 1781 template<typename ParentBuilder> 1782 typename Menu<ParentBuilder>::MenuBuilder 1783 Menu<ParentBuilder>::AddMenu(BMenu* menu) 1784 { 1785 if (!fMenu->AddItem(menu)) 1786 throw std::bad_alloc(); 1787 1788 MenuBuilder builder(menu); 1789 builder.SetParent(this); 1790 return builder; 1791 } 1792 1793 1794 template<typename ParentBuilder> 1795 typename Menu<ParentBuilder>::MenuBuilder 1796 Menu<ParentBuilder>::AddMenu(const char* title, menu_layout layout) 1797 { 1798 BMenu* menu = new BMenu(title, layout); 1799 if (!fMenu->AddItem(menu)) { 1800 delete menu; 1801 throw std::bad_alloc(); 1802 } 1803 1804 MenuBuilder builder(menu); 1805 builder.SetParent(this); 1806 return builder; 1807 } 1808 1809 1810 // #pragma mark - MenuItem 1811 1812 1813 template<typename ParentBuilder> 1814 MenuItem<ParentBuilder>::MenuItem(ParentBuilder* parentBuilder, BMenu* menu, 1815 BMenuItem* item) 1816 : 1817 Menu<ParentBuilder>(menu), 1818 fMenuItem(item) 1819 { 1820 this->SetParent(parentBuilder); 1821 } 1822 1823 1824 template<typename ParentBuilder> 1825 typename MenuItem<ParentBuilder>::ThisBuilder& 1826 MenuItem<ParentBuilder>::GetItem(BMenuItem*& _item) 1827 { 1828 _item = fMenuItem; 1829 return *this; 1830 } 1831 1832 1833 template<typename ParentBuilder> 1834 typename MenuItem<ParentBuilder>::ThisBuilder& 1835 MenuItem<ParentBuilder>::SetEnabled(bool enabled) 1836 { 1837 fMenuItem->SetEnabled(enabled); 1838 return *this; 1839 } 1840 1841 1842 } // namespace BLayoutBuilder 1843 1844 1845 #endif // _LAYOUT_BUILDER_H 1846