sublime/ideallayout.cpp

   1 /*
   2   Copyright 2007 Roberto Raggi <roberto@kdevelop.org>
   3   Copyright 2007 Hamish Rodda <rodda@kde.org>
   4   Copyright 2008 Vladimir Prus <ghost@cs.msu.su>
   5
   6   Permission to use, copy, modify, distribute, and sell this software and its
   7   documentation for any purpose is hereby granted without fee, provided that
   8   the above copyright notice appear in all copies and that both that
   9   copyright notice and this permission notice appear in supporting
  10   documentation.
  11
  12   The above copyright notice and this permission notice shall be included in
  13   all copies or substantial portions of the Software.
  14
  15   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  18   KDEVELOP TEAM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  19   AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21 */
  22
  23 #include "ideallayout.h"
  24 #include "ideal.h"
  25
  26 #include "kdebug.h"
  27 #include <KConfigGroup>
  28 #include <KGlobal>
  29 #include <KConfig>
  30
  31 using namespace Sublime;
  32
  33 IdealMainLayout::Role Sublime ::roleForArea(Qt::DockWidgetArea area)
  34 {
  35     switch (area) {
  36         case Qt::LeftDockWidgetArea:
  37             return IdealMainLayout::Left;
  38
  39         case Qt::RightDockWidgetArea:
  40             return IdealMainLayout::Right;
  41
  42         case Qt::BottomDockWidgetArea:
  43             return IdealMainLayout::Bottom;
  44
  45         case Qt::TopDockWidgetArea:
  46             return IdealMainLayout::Top;
  47
  48         default:
  49             Q_ASSERT(false);
  50             return IdealMainLayout::Left;
  51     }
  52 }
  53
  54 Qt::DockWidgetArea Sublime ::areaForRole(IdealMainLayout::Role role)
  55 {
  56     switch (role) {
  57         case IdealMainLayout::Left:
  58             return Qt::LeftDockWidgetArea;
  59
  60         case IdealMainLayout::Right:
  61             return Qt::RightDockWidgetArea;
  62
  63         case IdealMainLayout::Bottom:
  64             return Qt::BottomDockWidgetArea;
  65
  66         case IdealMainLayout::Top:
  67             return Qt::TopDockWidgetArea;
  68
  69         default:
  70             Q_ASSERT(false);
  71             return Qt::LeftDockWidgetArea;
  72     }
  73 }
  74
  75 IdealButtonBarLayout::IdealButtonBarLayout(Qt::Orientation orientation, QWidget *parent)
  76     : QLayout(parent)
  77     , _orientation(orientation)
  78     , _height(0)
  79
  80 {
  81     if (orientation == Qt::Vertical)
  82         setContentsMargins(2, 0, 2, 0);
  83     else
  84         setContentsMargins(0, 2, 0, 0);
  85     setSpacing(2);
  86     invalidate();
  87 }
  88
  89 void IdealButtonBarLayout::invalidate()
  90 {
  91     m_minSizeDirty = true;
  92     m_sizeHintDirty = true;
  93     m_layoutDirty = true;
  94     QLayout::invalidate();
  95 }
  96
  97 IdealButtonBarLayout::~IdealButtonBarLayout()
  98 {
  99     qDeleteAll(_items);
 100 }
 101
 102 void IdealButtonBarLayout::setHeight(int height)
 103 {
 104     Q_ASSERT(orientation() == Qt::Vertical);
 105     _height = height;
 106
 107     (void) invalidate();
 108 }
 109
 110 Qt::Orientation IdealButtonBarLayout::orientation() const
 111 {
 112     return _orientation;
 113 }
 114
 115 Qt::Orientations IdealButtonBarLayout::expandingDirections() const
 116 {
 117     return orientation();
 118 }
 119
 120 QSize IdealButtonBarLayout::minimumSize() const
 121 {
 122     // The code below appears to be completely wrong --
 123     // it will return the maximum size of a single button, not any
 124     // estimate as to how much space is necessary to draw all buttons
 125     // in a minimally acceptable way.
 126     if (m_minSizeDirty) {
 127         if (orientation() == Qt::Vertical) {
 128             const int width = doVerticalLayout(QRect(0, 0, 0, _height), false);
 129             return QSize(width, 0);
 130         }
 131
 132         m_min = QSize(0, 0);
 133         foreach (QLayoutItem *item, _items)
 134             m_min = m_min.expandedTo(item->minimumSize());
 135
 136         m_minSizeDirty = false;
 137     }
 138     return m_min;
 139 }
 140
 141 QSize IdealButtonBarLayout::sizeHint() const
 142 {
 143     if (m_sizeHintDirty) {
 144         int orientationSize = 0;
 145         int crossSize = 0;
 146
 147         bool first = true;
 148         foreach (QLayoutItem *item, _items)
 149         {
 150             QSize hint = item->sizeHint();
 151             int orientationSizeHere;
 152             int crossSizeHere;
 153             if (orientation() == Qt::Vertical)
 154             {
 155                 orientationSizeHere = hint.height();
 156                 crossSizeHere = hint.width();
 157             }
 158             else
 159             {
 160                 orientationSizeHere = hint.width();
 161                 crossSizeHere = hint.height();
 162             }
 163
 164             if (first)
 165             {
 166                 crossSize = crossSizeHere;
 167             }
 168             else
 169             {
 170                 orientationSize += spacing();
 171             }
 172             orientationSize += orientationSizeHere;
 173             first = false;
 174         }
 175
 176         if (orientation() == Qt::Vertical)
 177             m_hint = QSize(crossSize, orientationSize);
 178         else
 179             m_hint = QSize(orientationSize, crossSize);
 180
 181         if (!_items.empty())
 182         {
 183             /* If we have no items, just use (0, 0) as hint, don't
 184                append any margins.  */
 185             int l, t, r, b;
 186             getContentsMargins(&l, &t, &r, &b);
 187             m_hint += QSize(l+r, t+b);
 188         }
 189
 190         m_sizeHintDirty = false;
 191     }
 192     return m_hint;
 193 }
 194
 195 void IdealButtonBarLayout::setGeometry(const QRect &rect)
 196 {
 197     if (m_layoutDirty || rect != geometry())
 198         if (orientation() == Qt::Vertical)
 199             doVerticalLayout(rect);
 200         else
 201             doHorizontalLayout(rect);
 202 }
 203
 204 void IdealButtonBarLayout::addItem(QLayoutItem *item)
 205 {
 206     _items.append(item);
 207 }
 208
 209 QLayoutItem* IdealButtonBarLayout::itemAt(int index) const
 210 {
 211     return _items.value(index, 0);
 212 }
 213
 214 QLayoutItem* IdealButtonBarLayout::takeAt(int index)
 215 {
 216     if (index >= 0 && index < _items.count())
 217         return _items.takeAt(index);
 218     return 0;
 219 }
 220
 221 int IdealButtonBarLayout::count() const
 222 {
 223     return _items.count();
 224 }
 225
 226 int IdealButtonBarLayout::doVerticalLayout(const QRect &rect, bool updateGeometry) const
 227 {
 228     int l, t, r, b;
 229     getContentsMargins(&l, &t, &r, &b);
 230     int x = rect.x() + l;
 231     int y = rect.y() + t;
 232     int currentLineWidth = 0;
 233
 234     foreach (QLayoutItem *item, _items) {
 235         const QSize itemSizeHint = item->sizeHint();
 236         if (y + itemSizeHint.height() + b > rect.height()) {
 237             int newX = x + currentLineWidth + spacing();
 238             if (newX + itemSizeHint.width() + r <= rect.width())
 239             {
 240                 x += currentLineWidth + spacing();
 241                 y = rect.y() + t;
 242             }
 243         }
 244
 245         if (updateGeometry)
 246             item->setGeometry(QRect(x, y, itemSizeHint.width(), itemSizeHint.height()));
 247
 248         currentLineWidth = qMax(currentLineWidth, itemSizeHint.width());
 249
 250         y += itemSizeHint.height() + spacing();
 251     }
 252
 253     m_layoutDirty = updateGeometry;
 254
 255     return x + currentLineWidth + r;
 256 }
 257
 258 int IdealButtonBarLayout::doHorizontalLayout(const QRect &rect, bool updateGeometry) const
 259 {
 260     int l, t, r, b;
 261     getContentsMargins(&l, &t, &r, &b);
 262     int x = rect.x() + l;
 263     int y = rect.y() + t;
 264     int currentLineHeight = 0;
 265
 266     foreach (QLayoutItem *item, _items) {
 267         QSize itemSizeHint = item->sizeHint();
 268         if (x + itemSizeHint.width() + r > rect.width()) {
 269             // Run out of horizontal space. Try to move button to another
 270             // row.
 271             int newY = y + currentLineHeight + spacing();
 272             if (newY + itemSizeHint.height() + b <= rect.height())
 273             {
 274                 y = newY;
 275                 x = rect.x() + l;
 276                 currentLineHeight = 0;
 277             }
 278         }
 279
 280         if (updateGeometry)
 281             item->setGeometry(QRect(x, y, itemSizeHint.width(), itemSizeHint.height()));
 282
 283         currentLineHeight = qMax(currentLineHeight, itemSizeHint.height());
 284
 285         x += itemSizeHint.width() + spacing();
 286     }
 287
 288     m_layoutDirty = updateGeometry;
 289
 290     return y + currentLineHeight + b;
 291 }
 292
 293 IdealDockWidget* IdealMainLayout::lastDockWidget() const
 294 {
 295     return qobject_cast<IdealDockWidget*>(m_lastDockWidget);
 296 }
 297
 298 IdealDockWidget * IdealMainLayout::lastDockWidget(IdealMainLayout::Role role) const
 299 {
 300     return qobject_cast<IdealDockWidget*>(m_items[role]->last);
 301 }
 302
 303 IdealMainLayout::IdealMainLayout(QWidget * parent)
 304     : QLayout(parent)
 305     , m_layoutDirty(true)
 306     , m_minDirty(true)
 307     , m_lastDockWidgetRole(Left)
 308     , m_topOwnsTopLeft(0)
 309     , m_topOwnsTopRight(0)
 310     , m_bottomOwnsBottomLeft(0)
 311     , m_bottomOwnsBottomRight(0)
 312     , m_maximizedWidget(0)
 313 {
 314     createArea(Left);
 315     createArea(Right);
 316     createArea(Top);
 317     createArea(Bottom);
 318     createArea(Central);
 319
 320     setMargin(0);
 321     m_splitterWidth = parent->style()->pixelMetric(QStyle::PM_SplitterWidth, 0, parentWidget());
 322
 323     loadSettings();
 324
 325     anchorWidget(true, Left);
 326     anchorWidget(true, Right);
 327     anchorWidget(true, Top);
 328     anchorWidget(true, Bottom);
 329 }
 330
 331 IdealMainLayout::~ IdealMainLayout()
 332 {
 333 }
 334
 335 QSize IdealMainLayout::minimumSize() const
 336 {
 337     if (m_minDirty) {
 338         if (m_maximizedWidget) {
 339             m_min = m_maximizedWidget->minimumSize();
 340             m_minDirty = false;
 341             return m_min;
 342         }
 343
 344         int minHeight = 0;
 345         int softMinHeight = 0;
 346         int minWidth = 0;
 347         int softMinWidth = 0;
 348
 349         minimumSize(Left, minWidth, softMinWidth, minHeight, softMinHeight);
 350         minimumSize(Right, minWidth, softMinWidth, minHeight, softMinHeight);
 351         minimumSize(Top, minWidth, softMinWidth, minHeight, softMinHeight);
 352         minimumSize(Bottom, minWidth, softMinWidth, minHeight, softMinHeight);
 353
 354         if (QLayoutItem* item = m_items[Central]->first()) {
 355             const QSize itemSizeHint = item->minimumSize();
 356             minHeight += qMax(softMinHeight, itemSizeHint.height() + splitterWidth());
 357             minWidth += qMax(softMinWidth, itemSizeHint.width() + splitterWidth());
 358         }
 359
 360         m_min = QSize(minHeight, minWidth);
 361         m_minDirty = true;
 362     }
 363
 364     return m_min;
 365 }
 366
 367 void IdealMainLayout::minimumSize(Role role, int& minWidth, int& softMinWidth, int& minHeight, int& softMinHeight) const
 368 {
 369     foreach (QLayoutItem* item, m_items[role]->items()) {
 370         const QSize itemSizeHint = item->minimumSize();
 371         switch (role) {
 372             case Left:
 373             case Right:
 374                 if (m_items[role]->anchored)
 375                     minWidth += itemSizeHint.width() + splitterWidth();
 376                 softMinHeight = qMax(softMinHeight, itemSizeHint.height() + splitterWidth());
 377                 break;
 378
 379             case Top:
 380             case Bottom:
 381                 if (m_items[role]->anchored)
 382                     minHeight += itemSizeHint.height() + splitterWidth();
 383                 softMinWidth = qMax(softMinWidth, itemSizeHint.width() + splitterWidth());
 384                 break;
 385
 386             default:
 387                 break;
 388         }
 389     }
 390 }
 391
 392 QLayoutItem * IdealMainLayout::itemAt(int index) const
 393 {
 394     int at = 0;
 395     if (QLayoutItem* item = m_items[Left]->itemAt(index, at))
 396         return item;
 397
 398     index -= at;
 399     at = 0;
 400     if (QLayoutItem* item = m_items[Right]->itemAt(index, at))
 401         return item;
 402
 403     index -= at;
 404     at = 0;
 405     if (QLayoutItem* item = m_items[Top]->itemAt(index, at))
 406         return item;
 407
 408     index -= at;
 409     at = 0;
 410     if (QLayoutItem* item = m_items[Bottom]->itemAt(index, at))
 411         return item;
 412
 413     index -= at;
 414     at = 0;
 415     if (QLayoutItem* item = m_items[Central]->itemAt(index, at))
 416         return item;
 417
 418     return 0;
 419 }
 420
 421 void IdealMainLayout::addItem(QLayoutItem * item)
 422 {
 423     Q_UNUSED(item)
 424
 425     // Uh-oh...??
 426     Q_ASSERT(false);
 427 }
 428
 429 void IdealMainLayout::setGeometry(const QRect & rect)
 430 {
 431     if (m_layoutDirty || rect != geometry()) {
 432         QLayout::setGeometry(rect);
 433         doLayout(rect);
 434     }
 435 }
 436
 437 QSize IdealMainLayout::sizeHint() const
 438 {
 439     return QSize();
 440 }
 441
 442 QLayoutItem * IdealMainLayout::takeAt(int index)
 443 {
 444     Q_UNUSED(index)
 445
 446     // Uh-oh...??
 447     Q_ASSERT(false);
 448
 449     return 0;
 450 }
 451
 452 int IdealMainLayout::count() const
 453 {
 454     return m_items[Left]->count() + m_items[Right]->count()
 455         + m_items[Top]->count() + m_items[Bottom]->count() + m_items[Central]->count();
 456 }
 457
 458 void IdealMainLayout::doLayout(QRect rect) const
 459 {
 460     if (m_maximizedWidget) {
 461         m_maximizedWidget->setGeometry(rect);
 462         return;
 463     }
 464
 465     if (m_topOwnsTopLeft)
 466         if (m_topOwnsTopRight)
 467             if (m_bottomOwnsBottomLeft)
 468                 if (m_bottomOwnsBottomRight)
 469                     layout(Top, Bottom, Left, Right, rect);
 470                 else
 471                     layout(Top, Right, Bottom, Left, rect);
 472             else
 473                 if (m_bottomOwnsBottomRight)
 474                     layout(Top, Left, Bottom, Right, rect);
 475                 else
 476                     layout(Top, Right, Left, Bottom, rect);
 477         else
 478             if (m_bottomOwnsBottomLeft)
 479                 if (m_bottomOwnsBottomRight)
 480                     layout(Bottom, Right, Top, Left, rect);
 481                 else
 482                     layout(Right, Top, Left, Bottom, rect);
 483             else
 484                 if (m_bottomOwnsBottomRight)
 485                     // TODO: this is not possible with current code
 486                     layout(Top, Left, Bottom, Right, rect);
 487                 else
 488                     layout(Right, Top, Left, Bottom, rect);
 489     else
 490         if (m_topOwnsTopRight)
 491             if (m_bottomOwnsBottomLeft)
 492                 if (m_bottomOwnsBottomRight)
 493                     layout(Bottom, Left, Top, Right, rect);
 494                 else
 495                     layout(Left, Top, Right, Bottom, rect);
 496             else
 497                 if (m_bottomOwnsBottomRight)
 498                     layout(Left, Bottom, Top, Right, rect);
 499                 else
 500                     layout(Right, Left, Bottom, Top, rect);
 501         else
 502             if (m_bottomOwnsBottomLeft)
 503                 if (m_bottomOwnsBottomRight)
 504                     layout(Bottom, Right, Left, Top, rect);
 505                 else
 506                     layout(Right, Bottom, Left, Top, rect);
 507             else
 508                 if (m_bottomOwnsBottomRight)
 509                     // TODO: this is not possible with current code
 510                     layout(Left, Bottom, Right, Top, rect);
 511                 else
 512                     layout(Right, Left, Bottom, Top, rect);
 513
 514
 515     if (QLayoutItem* item = m_items[Central]->first()) {
 516         QSize itemSizeHint = item->sizeHint();
 517         if (itemSizeHint.height() > rect.height()) {
 518             itemSizeHint.setHeight(qMax(item->minimumSize().height(), rect.height()));
 519
 520             if (itemSizeHint.height() > rect.height())
 521                 rect.setHeight(itemSizeHint.height());
 522         }
 523
 524         if (itemSizeHint.width() > rect.width()) {
 525             itemSizeHint.setWidth(qMax(item->minimumSize().width(), rect.width()));
 526
 527             if (itemSizeHint.width() > rect.width())
 528                 rect.setWidth(itemSizeHint.width());
 529         }
 530
 531         item->setGeometry(rect);
 532     }
 533
 534     m_layoutDirty = false;
 535 }
 536
 537 void IdealMainLayout::layout(Role role1, Role role2, Role role3, Role role4, QRect & rect) const
 538 {
 539     layoutItem(role1, rect);
 540     layoutItem(role2, rect);
 541     layoutItem(role3, rect);
 542     layoutItem(role4, rect);
 543 }
 544
 545 void IdealMainLayout::layoutItem(Role role, QRect& rect) const
 546 {
 547     DockArea* area = m_items[role];
 548
 549     QWidgetItem* buttonBar = area->buttonBar();
 550     if (buttonBar)
 551     {
 552         const QSize hint = buttonBar->sizeHint();
 553         QRect geometry = rect;
 554         if (role == Left) {
 555             geometry.setWidth(hint.width());
 556             rect.setLeft(hint.width());
 557         }
 558         else if (role == Bottom) {
 559             int y = rect.height() - hint.height();
 560             geometry.setTop(geometry.y() + y);
 561             rect.setBottom(y);
 562         }
 563         else if (role == Right) {
 564             int x = rect.width() - hint.width();
 565             geometry.setLeft(geometry.x() + x);
 566             rect.setWidth(x);
 567         }
 568         else if (role == Top) {
 569             geometry.setHeight(hint.height());
 570             rect.setTop(hint.height());
 571         }
 572
 573         buttonBar->setGeometry(geometry);
 574     }
 575
 576     foreach (QLayoutItem* item, area->items()) {
 577         int hintDimension = 0;
 578         if (m_items[role]->width != -1) {
 579             hintDimension = m_items[role]->width;
 580
 581         } else {
 582             const QSize itemSize = item->sizeHint();
 583             switch (role) {
 584                 case Left:
 585                 case Right:
 586                     hintDimension = itemSize.width() + splitterWidth();
 587                     if (hintDimension + splitterWidth() > rect.width()) {
 588                         hintDimension = item->minimumSize().width();
 589
 590                         if (hintDimension + splitterWidth() > rect.width())
 591                             rect.setWidth(hintDimension + splitterWidth());
 592                     }
 593                     break;
 594
 595                 case Top:
 596                 case Bottom:
 597                     hintDimension = itemSize.height();
 598                     if (hintDimension + splitterWidth() > rect.height()) {
 599                         hintDimension = item->minimumSize().height();
 600
 601                         if (hintDimension + splitterWidth() > rect.height())
 602                             rect.setHeight(hintDimension + splitterWidth());
 603                     }
 604                     break;
 605
 606                 default:
 607                     break;
 608             }
 609         }
 610
 611         switch (role) {
 612             case Left:
 613                 item->setGeometry(QRect(rect.x(), rect.y(), hintDimension, rect.height()));
 614                 area->mainSplitter()->setGeometry(QRect(rect.x() + hintDimension, rect.y(), splitterWidth(), rect.height()));
 615                 break;
 616
 617             case Right:
 618                 item->setGeometry(QRect(rect.x() + rect.width() - hintDimension, rect.y(), hintDimension, rect.height()));
 619                 area->mainSplitter()->setGeometry(QRect(rect.x() + rect.width() - hintDimension - splitterWidth(), rect.y(), splitterWidth(), rect.height()));
 620                 break;
 621
 622             case Top:
 623                 item->setGeometry(QRect(rect.x(), rect.y(), rect.width(), hintDimension));
 624                 area->mainSplitter()->setGeometry(QRect(rect.x(), rect.y() + hintDimension, rect.width(), splitterWidth()));
 625                 break;
 626
 627             case Bottom:
 628                 item->setGeometry(QRect(rect.x(), rect.y() + rect.height() - hintDimension, rect.width(), hintDimension));
 629                 area->mainSplitter()->setGeometry(QRect(rect.x(), rect.y() + rect.height() - hintDimension - splitterWidth(), rect.width(), splitterWidth()));
 630                 break;
 631
 632                 default:
 633                     break;
 634         }
 635
 636         if (m_items[role]->anchored) {
 637             switch (role) {
 638                 case Left:
 639                     rect.setX(rect.x() + hintDimension + splitterWidth());
 640                     break;
 641
 642                 case Right:
 643                     rect.setWidth(rect.width() - hintDimension - splitterWidth());
 644                     break;
 645
 646                 case Top:
 647                     rect.setY(rect.y() + hintDimension + splitterWidth());
 648                     break;
 649
 650                 case Bottom:
 651                     rect.setHeight(rect.height() - hintDimension - splitterWidth());
 652                     break;
 653
 654                 default:
 655                     break;
 656             }
 657         }
 658     }
 659 }
 660
 661 IdealSplitterHandle* IdealMainLayout::createSplitter(Role role, bool reverse)
 662 {
 663     IdealSplitterHandle* splitter = 0;
 664
 665     Qt::Orientation direction = ((role == Left || role == Right) ^ reverse)
 666       ? Qt::Vertical
 667       : Qt::Horizontal;
 668
 669     splitter = new IdealSplitterHandle(direction, parentWidget(), role);
 670     addChildWidget(splitter);
 671
 672     connect(splitter, SIGNAL(resize(int, IdealMainLayout::Role)),
 673             SLOT(resizeWidget(int, IdealMainLayout::Role)));
 674
 675     splitter->hide();
 676     return splitter;
 677 }
 678
 679 void IdealMainLayout::createArea(Role role)
 680 {
 681     DockArea* area = new DockArea(this, role);
 682     m_items.insert(role, area);
 683
 684     if (role != Central)
 685       area->setMainSplitter(createSplitter(role));
 686 }
 687
 688 void IdealMainLayout::addWidget(QWidget * widget, Role role)
 689 {
 690     if (m_maximizedWidget)
 691         maximizeWidget(0);
 692
 693     if (IdealDockWidget* dock = qobject_cast<IdealDockWidget*>(widget))
 694         if (dock->isFloating())
 695             dock->setFloating(false);
 696
 697     if (widget->parent() != parentWidget()) {
 698         widget->setParent(parentWidget());
 699         addChildWidget(widget);
 700     }
 701
 702     DockArea* area = m_items[role];
 703
 704     area->addWidget(widget);
 705
 706     area->setVisible(true, !m_maximizedWidget);
 707
 708     if (role != Central) {
 709         m_lastDockWidget = widget;
 710         m_lastDockWidgetRole = role;
 711         m_items[role]->last = widget;
 712         mainWidget()->setAnchorActionStatus(isAreaAnchored(role));
 713     }
 714
 715     area->raise();
 716     widget->setFocus();
 717 }
 718
 719 void IdealMainLayout::addButtonBar(QWidget* widget, Role role)
 720 {
 721     DockArea* area = m_items[role];
 722     area->setButtonBar(widget);
 723     addChildWidget(widget);
 724 }
 725
 726 void IdealMainLayout::removeWidgets(Role role)
 727 {
 728     if (m_maximizedWidget)
 729         // FIXME correct?
 730         maximizeWidget(0);
 731
 732     DockArea* area = m_items[role];
 733     area->setVisible(false);
 734 }
 735
 736 void IdealMainLayout::removeWidget(QWidget * widget, Role role)
 737 {
 738     DockArea* area = m_items[role];
 739     area->removeWidget(widget);
 740     if (area->items().isEmpty())
 741         area->setVisible(false, false);
 742 }
 743
 744 void IdealMainLayout::removeUnanchored()
 745 {
 746     if (!m_items[Left]->anchored)
 747         removeWidgets(Left);
 748
 749     if (!m_items[Right]->anchored)
 750         removeWidgets(Right);
 751
 752     if (!m_items[Top]->anchored)
 753         removeWidgets(Top);
 754
 755     if (!m_items[Bottom]->anchored)
 756         removeWidgets(Bottom);
 757 }
 758
 759 void IdealMainLayout::invalidate()
 760 {
 761     m_layoutDirty = true;
 762     m_minDirty = true;
 763     QLayout::invalidate();
 764 }
 765
 766 int IdealMainLayout::splitterWidth() const
 767 {
 768     return m_splitterWidth;
 769 }
 770
 771 void IdealMainLayout::resizeWidget(int thickness, IdealMainLayout::Role role)
 772 {
 773     int offset = 0;
 774
 775     if (QWidgetItem* bar = m_items[role]->buttonBar())
 776         if (role == Left || role == Right)
 777             offset = bar->geometry().width();
 778         else
 779             offset = bar->geometry().height();
 780
 781     m_items[role]->width = thickness - offset;
 782
 783     invalidate();
 784
 785     emit widgetResized(role, thickness);
 786 }
 787
 788 void IdealMainLayout::anchorWidget(bool anchor, IdealMainLayout::Role role)
 789 {
 790     m_items[role]->anchored = anchor;
 791
 792     invalidate();
 793 }
 794
 795 void IdealMainLayout::maximizeWidget(QWidget* widget)
 796 {
 797     m_maximizedWidget = widget;
 798
 799     if (m_maximizedWidget) {
 800         for (Role role = Left; role <= Central; role = static_cast<Role>(role + 1))
 801             m_items[role]->setVisible(false, false, m_maximizedWidget);
 802
 803     } else {
 804         for (Role role = Left; role <= Central; role = static_cast<Role>(role + 1))
 805             if (!m_items[role]->items().isEmpty())
 806                 m_items[role]->setVisible(true, role != Central, m_maximizedWidget);
 807     }
 808
 809     invalidate();
 810 }
 811
 812 int IdealMainLayout::widthForRole(Role role) const
 813 {
 814     return m_items[role]->width;
 815 }
 816
 817 void IdealMainLayout::setWidthForRole(Role role, int width)
 818 {
 819     m_items[role]->width = width;
 820     invalidate();
 821 }
 822
 823 bool IdealMainLayout::isAreaAnchored(Role role) const
 824 {
 825     return m_items[role]->anchored;
 826 }
 827
 828 IdealMainWidget * IdealMainLayout::mainWidget() const
 829 {
 830     return dynamic_cast<IdealMainWidget*>(parentWidget());
 831 }
 832
 833 void IdealMainLayout::loadSettings()
 834 {
 835     KConfigGroup cg(KGlobal::config(), "UiSettings");
 836
 837     bool invalid = false;
 838
 839     int topOwnsTopLeft = cg.readEntry("TopLeftCornerOwner", 0);
 840     if (m_topOwnsTopLeft != topOwnsTopLeft) {
 841         m_topOwnsTopLeft = topOwnsTopLeft;
 842         invalid = true;
 843     }
 844
 845     int topOwnsTopRight = cg.readEntry("TopRightCornerOwner", 0);
 846     if (m_topOwnsTopRight != topOwnsTopRight) {
 847         m_topOwnsTopRight = topOwnsTopRight;
 848         invalid = true;
 849     }
 850
 851     int bottomOwnsBottomLeft = cg.readEntry("BottomLeftCornerOwner", 0);
 852     if (m_bottomOwnsBottomLeft != bottomOwnsBottomLeft) {
 853         m_bottomOwnsBottomLeft = bottomOwnsBottomLeft;
 854         invalid = true;
 855     }
 856
 857     int bottomOwnsBottomRight = cg.readEntry("BottomRightCornerOwner", 0);
 858     if (m_bottomOwnsBottomRight != bottomOwnsBottomRight) {
 859         m_bottomOwnsBottomRight = bottomOwnsBottomRight;
 860         invalid = true;
 861     }
 862
 863     if (invalid)
 864         invalidate();
 865 }
 866
 867 IdealMainLayout::Role IdealMainLayout::lastDockWidgetRole() const
 868 {
 869     return m_lastDockWidgetRole;
 870 }
 871
 872 QWidgetItem * IdealMainLayout::DockArea::mainSplitter() const
 873 {
 874     return m_mainSplitter;
 875 }
 876
 877 void IdealMainLayout::DockArea::setMainSplitter(QWidget* widget)
 878 {
 879     m_mainSplitter = new QWidgetItem(widget);
 880 }
 881
 882 IdealMainLayout::DockArea::DockArea(IdealMainLayout* layout, Role role)
 883     : width(250)
 884     , anchored(false)
 885     , m_layout(layout)
 886     , m_role(role)
 887     , m_mainSplitter(0)
 888     , m_buttonBarItem(0)
 889 {
 890 }
 891
 892 void IdealMainLayout::DockArea::removeMainSplitter()
 893 {
 894     if (m_mainSplitter) {
 895         delete m_mainSplitter->widget();
 896         delete m_mainSplitter;
 897         m_mainSplitter = 0;
 898     }
 899 }
 900
 901 void IdealMainLayout::DockArea::setVisible(bool visible, bool showMainSplitter, QWidget* maximizedWidget)
 902 {
 903     foreach (QLayoutItem* item, m_items) {
 904         bool itemVisible = visible || item->widget() == maximizedWidget;
 905         if (item->widget()->isVisible() != itemVisible)
 906             item->widget()->setVisible(itemVisible);
 907     }
 908
 909     if (m_mainSplitter) {
 910         bool mainSplitterVisible = (visible && showMainSplitter && !maximizedWidget);
 911         if (m_mainSplitter->widget()->isVisible() != mainSplitterVisible)
 912             m_mainSplitter->widget()->setVisible(mainSplitterVisible);
 913     }
 914
 915     bool subSplitterVisible = visible && !maximizedWidget;
 916     foreach (QWidgetItem* item, m_subSplitters) {
 917         if (item->widget()->isVisible() != subSplitterVisible)
 918             item->widget()->setVisible(subSplitterVisible);
 919     }
 920 }
 921
 922 const QList< QWidgetItem * > IdealMainLayout::DockArea::items() const
 923 {
 924     return m_items;
 925 }
 926
 927 QWidgetItem * IdealMainLayout::DockArea::first() const
 928 {
 929     Q_ASSERT(!m_items.isEmpty());
 930     return m_items.first();
 931 }
 932
 933 void IdealMainLayout::DockArea::addWidget(QWidget * widget)
 934 {
 935     m_items.append(new QWidgetItem(widget));
 936     m_heights.append(-1);
 937 }
 938
 939 void IdealMainLayout::DockArea::removeWidget(QWidget * widget)
 940 {
 941     int index = 0;
 942     while (index < m_items.count()) {
 943         if (m_items.at(index)->widget() == widget)
 944             break;
 945         ++index;
 946     }
 947
 948     Q_ASSERT(index < m_items.count());
 949     Q_ASSERT(m_heights.count() == m_items.count());
 950
 951     QWidgetItem* item = m_items.takeAt(index);
 952     item->widget()->hide();
 953     delete item;
 954
 955     m_heights.removeAt(index);
 956 }
 957
 958 IdealMainLayout::DockArea::~DockArea()
 959 {
 960     removeButtonBar();
 961     removeMainSplitter();
 962     removeWidgets();
 963 }
 964
 965 void IdealMainLayout::DockArea::removeWidgets()
 966 {
 967     for (int i = m_items.count() - 1; i >= 0; --i)
 968         removeWidget(m_items.at(i)->widget());
 969 }
 970
 971 int Sublime::IdealMainLayout::DockArea::count() const
 972 {
 973     int count = 0;
 974     if (m_buttonBarItem)
 975         ++count;
 976     if (m_mainSplitter)
 977         ++count;
 978     count += m_items.count();
 979     count += m_subSplitters.count();
 980     return count;
 981 }
 982
 983 QLayoutItem * Sublime::IdealMainLayout::DockArea::itemAt(int index, int& at) const
 984 {
 985     if (m_buttonBarItem)
 986         if (index == at)
 987             return m_buttonBarItem;
 988         else
 989             ++at;
 990
 991     if (m_mainSplitter)
 992         if (index == at)
 993             return m_mainSplitter;
 994         else
 995             ++at;
 996
 997     if (index < m_items.count() + at)
 998         return m_items.at(index - at);
 999
1000     at += m_items.count();
1001     if (index < m_subSplitters.count())
1002         return m_subSplitters.at(index - at);
1003
1004     return 0;
1005 }
1006
1007 void Sublime::IdealMainLayout::DockArea::raise()
1008 {
1009     foreach (QLayoutItem* item, m_items)
1010         item->widget()->raise();
1011
1012     foreach (QLayoutItem* item, m_subSplitters)
1013         item->widget()->raise();
1014
1015     if (m_mainSplitter)
1016         m_mainSplitter->widget()->raise();
1017 }
1018
1019 Sublime::Position Sublime::IdealMainLayout::positionForRole(Role role)
1020 {
1021     switch (role)
1022     {
1023     case Left:
1024         return Sublime::Left;
1025     case Right:
1026         return Sublime::Right;
1027     case Bottom:
1028         return Sublime::Bottom;
1029     case Top:
1030         return Sublime::Top;
1031     default:
1032     case Central:
1033         Q_ASSERT (false && "called with center role");
1034         return Sublime::Left;
1035     }
1036 }
1037
1038 QWidgetItem * Sublime::IdealMainLayout::DockArea::buttonBar() const
1039 {
1040     return m_buttonBarItem;
1041 }
1042
1043 void Sublime::IdealMainLayout::DockArea::setButtonBar(QWidget * buttonBar)
1044 {
1045     delete m_buttonBarItem;
1046     m_buttonBarItem = new QWidgetItem(buttonBar);
1047 }
1048
1049 void Sublime::IdealMainLayout::DockArea::removeButtonBar()
1050 {
1051     if (m_buttonBarItem) {
1052         delete m_buttonBarItem->widget();
1053         delete m_buttonBarItem;
1054         m_buttonBarItem = 0;
1055     }
1056 }
1057
1058 #include "ideallayout.moc"