sublime/areaindex.cpp

   1 /***************************************************************************
   2  *   Copyright 2006-2007 Alexander Dymo  <adymo@kdevelop.org>       *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU Library General Public License as       *
   6  *   published by the Free Software Foundation; either version 2 of the    *
   7  *   License, or (at your option) any later version.                       *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU Library General Public     *
  15  *   License along with this program; if not, write to the                 *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  18  ***************************************************************************/
  19 #include "areaindex.h"
  20
  21 #include <QList>
  22
  23 #include <kdebug.h>
  24
  25 #include "view.h"
  26 #include "document.h"
  27
  28 namespace Sublime {
  29
  30 // struct AreaIndexPrivate
  31
  32 struct AreaIndexPrivate {
  33     AreaIndexPrivate()
  34         :parent(0), first(0), second(0), orientation(Qt::Horizontal)
  35     {
  36     }
  37     ~AreaIndexPrivate()
  38     {
  39         delete first;
  40         delete second;
  41     }
  42     AreaIndexPrivate(const AreaIndexPrivate &p)
  43     {
  44         parent = 0;
  45         orientation = p.orientation;
  46         first = p.first ? new AreaIndex(*(p.first)) : 0;
  47         second = p.second ? new AreaIndex(*(p.second)) : 0;
  48     }
  49
  50     bool isSplitted() const
  51     {
  52         return first || second;
  53     }
  54
  55     QList<View*> views;
  56
  57     AreaIndex *parent;
  58     AreaIndex *first;
  59     AreaIndex *second;
  60     Qt::Orientation orientation;
  61 };
  62
  63
  64
  65 // class AreaIndex
  66
  67 AreaIndex::AreaIndex() : d(new AreaIndexPrivate)
  68 {
  69 }
  70
  71 AreaIndex::AreaIndex(AreaIndex *parent) : d(new AreaIndexPrivate)
  72 {
  73     d->parent = parent;
  74 }
  75
  76 AreaIndex::AreaIndex(const AreaIndex &index)  : d(new AreaIndexPrivate( *(index.d) ) )
  77 {
  78     kDebug() << "copying area index";
  79     if (d->first)
  80         d->first->setParent(this);
  81     if (d->second)
  82         d->second->setParent(this);
  83     //clone views in this index
  84     d->views.clear();
  85     foreach (View *view, index.views())
  86         add(view->document()->createView());
  87 }
  88
  89 AreaIndex::~AreaIndex()
  90 {
  91     delete d;
  92 }
  93
  94 void AreaIndex::add(View *view, View *after)
  95 {
  96     //we can not add views to the areas that have already been splitted
  97     if (d->isSplitted())
  98         return;
  99
 100     if (after)
 101         d->views.insert(d->views.indexOf(after), view);
 102     else
 103         d->views.append(view);
 104 }
 105
 106 void AreaIndex::remove(View *view)
 107 {
 108     if (d->isSplitted())
 109         return;
 110
 111     d->views.removeAll(view);
 112     if (d->parent && (d->views.count() == 0))
 113         d->parent->unsplit(this);
 114 }
 115
 116 void Sublime::AreaIndex::split(Qt::Orientation orientation)
 117 {
 118     //we can not split areas that have already been splitted
 119     if (d->isSplitted())
 120         return;
 121
 122     d->first = new AreaIndex(this);
 123     d->second = new AreaIndex(this);
 124     d->orientation = orientation;
 125
 126     //assign current views to the first part of splitter
 127     copyTo(d->first);
 128 }
 129
 130 void AreaIndex::split(View *newView, Qt::Orientation orientation)
 131 {
 132     split(orientation);
 133
 134     //make new view as second widget in splitter
 135     d->second->add(newView);
 136 }
 137
 138 void AreaIndex::unsplit(AreaIndex *childToRemove)
 139 {
 140     if (!d->isSplitted())
 141         return;
 142
 143     AreaIndex *other = d->first == childToRemove ? d->second : d->first;
 144     other->copyTo(this);
 145     d->orientation = other->orientation();
 146     d->first = 0;
 147     d->second = 0;
 148     other->copyChildrenTo(this);
 149
 150     delete other;
 151     delete childToRemove;
 152 }
 153
 154 void AreaIndex::copyChildrenTo(AreaIndex *target)
 155 {
 156     if (!d->first || !d->second)
 157         return;
 158     target->d->first = d->first;
 159     target->d->second = d->second;
 160     target->d->first->setParent(target);
 161     target->d->second->setParent(target);
 162
 163     d->first = 0;
 164     d->second = 0;
 165 }
 166
 167 void AreaIndex::copyTo(AreaIndex *target)
 168 {
 169     target->d->views = d->views;
 170     d->views.clear();
 171 }
 172
 173 QList<View*> &AreaIndex::views() const
 174 {
 175     return d->views;
 176 }
 177
 178 View *AreaIndex::viewAt(int position) const
 179 {
 180     return d->views.value(position, 0);
 181 }
 182
 183 int AreaIndex::viewCount() const
 184 {
 185     return d->views.count();
 186 }
 187
 188 bool AreaIndex::hasView(View *view) const
 189 {
 190     return d->views.contains(view);
 191 }
 192
 193 AreaIndex *AreaIndex::parent() const
 194 {
 195     return d->parent;
 196 }
 197
 198 void AreaIndex::setParent(AreaIndex *parent)
 199 {
 200     d->parent = parent;
 201 }
 202
 203 AreaIndex *AreaIndex::first() const
 204 {
 205     return d->first;
 206 }
 207
 208 AreaIndex *AreaIndex::second() const
 209 {
 210     return d->second;
 211 }
 212
 213 Qt::Orientation AreaIndex::orientation() const
 214 {
 215     return d->orientation;
 216 }
 217
 218 bool Sublime::AreaIndex::isSplitted() const
 219 {
 220     return d->isSplitted();
 221 }
 222
 223 void Sublime::AreaIndex::setOrientation(Qt::Orientation orientation) const
 224 {
 225     d->orientation = orientation;
 226 }
 227
 228 // class RootAreaIndex
 229
 230 RootAreaIndex::RootAreaIndex()
 231     :AreaIndex(), d(0)
 232 {
 233 }
 234
 235 }