apps/konsole/src/ViewSplitter.cpp

   1 /*
   2     This file is part of the Konsole Terminal.
   3
   4     Copyright 2006-2008 Robert Knight <robertknight@gmail.com>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19     02110-1301  USA.
  20 */
  21
  22 // Own
  23 #include "ViewSplitter.h"
  24
  25 // Qt
  26 #include <QtGui/QKeyEvent>
  27
  28 // KDE
  29 #include "kdebug.h"
  30
  31 // Konsole
  32 #include "ViewContainer.h"
  33
  34 using namespace Konsole;
  35
  36 ViewSplitter::ViewSplitter(QWidget* parent)
  37     : QSplitter(parent)
  38     , _recursiveSplitting(true)
  39 {
  40 }
  41
  42 void ViewSplitter::childEmpty(ViewSplitter* splitter)
  43 {
  44     delete splitter;
  45
  46     if ( count() == 0 )
  47         emit empty(this);
  48 }
  49
  50 void ViewSplitter::adjustContainerSize(ViewContainer* container , int percentage)
  51 {
  52     int containerIndex = indexOf(container->containerWidget());
  53
  54     Q_ASSERT( containerIndex != -1 );
  55
  56     QList<int> containerSizes = sizes();
  57
  58     int oldSize = containerSizes[containerIndex];
  59     int newSize = (int)(oldSize * ( 1.0 + percentage/100.0 ));
  60
  61     int perContainerDelta = (count() == 1 ) ? 0 : ( (newSize-oldSize) / (count()-1) ) * (-1);
  62
  63     for ( int i = 0 ; i < containerSizes.count() ; i++ )
  64     {
  65         if ( i == containerIndex )
  66             containerSizes[i] = newSize;
  67         else
  68             containerSizes[i] = containerSizes[i] + perContainerDelta;
  69     }
  70
  71     setSizes(containerSizes);
  72 }
  73
  74 ViewSplitter* ViewSplitter::activeSplitter()
  75 {
  76     QWidget* widget = focusWidget() ? focusWidget() : this;
  77
  78     ViewSplitter* splitter = 0;
  79
  80     while ( !splitter && widget )
  81     {
  82         splitter = dynamic_cast<ViewSplitter*>(widget);
  83         widget = widget->parentWidget();
  84     }
  85
  86     Q_ASSERT( splitter );
  87     return splitter;
  88 }
  89
  90 void ViewSplitter::registerContainer( ViewContainer* container )
  91 {
  92     _containers << container;
  93     connect( container , SIGNAL(destroyed(ViewContainer*)) , this , SLOT( containerDestroyed(ViewContainer*) ) );
  94     connect( container , SIGNAL(empty(ViewContainer*)) , this , SLOT( containerEmpty(ViewContainer*) ) );
  95 }
  96
  97 void ViewSplitter::unregisterContainer( ViewContainer* container )
  98 {
  99     _containers.removeAll(container);
 100     disconnect( container , 0 , this , 0 );
 101 }
 102
 103 void ViewSplitter::updateSizes()
 104 {
 105     int space;
 106
 107     if ( orientation() == Qt::Horizontal )
 108     {
 109         space = width() / count();
 110     }
 111     else
 112     {
 113         space = height() / count();
 114     }
 115
 116     QList<int> widgetSizes;
 117     for (int i=0;i<count();i++)
 118         widgetSizes << space;
 119
 120     setSizes(widgetSizes);
 121 }
 122
 123 void ViewSplitter::setRecursiveSplitting(bool recursive)
 124 {
 125     _recursiveSplitting = recursive;
 126 }
 127 bool ViewSplitter::recursiveSplitting() const
 128 {
 129     return _recursiveSplitting;
 130 }
 131
 132 void ViewSplitter::removeContainer( ViewContainer* container )
 133 {
 134     Q_ASSERT( containers().contains(container) );
 135
 136     unregisterContainer(container);
 137 }
 138
 139 void ViewSplitter::addContainer( ViewContainer* container ,
 140                                  Qt::Orientation containerOrientation )
 141 {
 142    ViewSplitter* splitter = activeSplitter();
 143
 144     if ( splitter->count() < 2 ||
 145          containerOrientation == splitter->orientation() ||
 146          !_recursiveSplitting )
 147     {
 148         splitter->registerContainer(container);
 149         splitter->addWidget(container->containerWidget());
 150
 151         if ( splitter->orientation() != containerOrientation )
 152             splitter->setOrientation( containerOrientation );
 153
 154         splitter->updateSizes();
 155     }
 156     else
 157     {
 158         ViewSplitter* newSplitter = new ViewSplitter(this);
 159         connect( newSplitter , SIGNAL(empty(ViewSplitter*)) , splitter , SLOT(childEmpty(ViewSplitter*)) );
 160
 161         ViewContainer* oldContainer = splitter->activeContainer();
 162         int oldContainerIndex = splitter->indexOf(oldContainer->containerWidget());
 163
 164         splitter->unregisterContainer(oldContainer);
 165
 166         newSplitter->registerContainer(oldContainer);
 167         newSplitter->registerContainer(container);
 168
 169         newSplitter->addWidget(oldContainer->containerWidget());
 170         newSplitter->addWidget(container->containerWidget());
 171         newSplitter->setOrientation(containerOrientation);
 172         newSplitter->updateSizes();
 173         newSplitter->show();
 174
 175         splitter->insertWidget(oldContainerIndex,newSplitter);
 176     }
 177
 178 }
 179
 180 void ViewSplitter::containerEmpty(ViewContainer* /*object*/)
 181 {
 182     QListIterator<ViewContainer*> containerIter(_containers);
 183
 184     int children = 0;
 185     while (containerIter.hasNext())
 186     {
 187         children += containerIter.next()->views().count();
 188     }
 189
 190     if ( children == 0 )
 191         emit allContainersEmpty();
 192 }
 193
 194 void ViewSplitter::containerDestroyed(ViewContainer* object)
 195 {
 196     Q_ASSERT( _containers.contains(object) );
 197
 198     _containers.removeAll(object);
 199
 200     if ( count() == 0 )
 201     {
 202         emit empty(this);
 203     }
 204 }
 205
 206 void ViewSplitter::activateNextContainer()
 207 {
 208     ViewContainer* active = activeContainer();
 209
 210     int index = _containers.indexOf(active);
 211
 212     if ( index == -1 )
 213         return;
 214
 215     if ( index == _containers.count() -1 )
 216         index = 0;
 217     else
 218         index++;
 219
 220     setActiveContainer( _containers.at(index) );
 221 }
 222
 223 void ViewSplitter::activatePreviousContainer()
 224 {
 225     ViewContainer* active = activeContainer();
 226
 227     int index = _containers.indexOf(active);
 228
 229     if ( index == 0 )
 230        index = _containers.count() - 1;
 231     else
 232        index--;
 233
 234     setActiveContainer( _containers.at(index) );
 235 }
 236
 237
 238 void ViewSplitter::setActiveContainer(ViewContainer* container)
 239 {
 240     QWidget* activeView = container->activeView();
 241
 242     if ( activeView )
 243         activeView->setFocus( Qt::OtherFocusReason );
 244 }
 245
 246 ViewContainer* ViewSplitter::activeContainer() const
 247 {
 248    if ( QWidget* focusW = focusWidget() )
 249    {
 250         ViewContainer* focusContainer = 0;
 251
 252         while ( focusW != 0 )
 253         {
 254             QListIterator<ViewContainer*> containerIter(_containers);
 255             while (containerIter.hasNext())
 256             {
 257                 ViewContainer* nextContainer = containerIter.next();
 258
 259                 if (nextContainer->containerWidget() == focusW)
 260                 {
 261                     focusContainer = nextContainer;
 262                     break;
 263                 }
 264             }
 265             focusW = focusW->parentWidget();
 266         }
 267
 268         if ( focusContainer )
 269             return focusContainer;
 270    }
 271
 272    QList<ViewSplitter*> splitters = findChildren<ViewSplitter*>();
 273
 274    if (splitters.count() > 0)
 275    {
 276         return splitters.last()->activeContainer();
 277    }
 278    else
 279    {
 280        if ( _containers.count() > 0 )
 281            return _containers.last();
 282        else
 283            return 0;
 284    }
 285 }
 286
 287 #include "ViewSplitter.moc"