sublime/area.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 "area.h"
  20
  21 #include <QMap>
  22 #include <QList>
  23 #include <QStringList>
  24
  25 #include <kdebug.h>
  26
  27 #include "view.h"
  28 #include "document.h"
  29 #include "areaindex.h"
  30 #include "controller.h"
  31
  32 namespace Sublime {
  33
  34 // struct AreaPrivate
  35
  36 struct AreaPrivate {
  37     AreaPrivate()
  38     {
  39         rootIndex = new RootAreaIndex();
  40         currentIndex = rootIndex;
  41         controller = 0;
  42     }
  43     AreaPrivate(const AreaPrivate &p)
  44     {
  45         rootIndex = new RootAreaIndex(*(p.rootIndex));
  46         currentIndex = rootIndex;
  47         controller = p.controller;
  48         toolViewPositions.clear();
  49         desiredToolViews = p.desiredToolViews;
  50         shownToolView = p.shownToolView;
  51
  52         title = p.title;
  53     }
  54     ~AreaPrivate()
  55     {
  56         delete rootIndex;
  57     }
  58
  59     struct ViewFinder {
  60         ViewFinder(View *_view): view(_view), index(0) {}
  61         Area::WalkerMode operator() (AreaIndex *idx) {
  62             if (idx->hasView(view))
  63             {
  64                 index = idx;
  65                 return Area::StopWalker;
  66             }
  67             return Area::ContinueWalker;
  68         }
  69         View *view;
  70         AreaIndex *index;
  71     };
  72
  73     struct ViewLister {
  74         Area::WalkerMode operator()(AreaIndex *idx) {
  75             views += idx->views();
  76             return Area::ContinueWalker;
  77         }
  78         QList<View*> views;
  79     };
  80
  81     QString title;
  82
  83     RootAreaIndex *rootIndex;
  84     AreaIndex *currentIndex;
  85     Controller *controller;
  86
  87     QList<View*> toolViews;
  88     QMap<View *, Sublime::Position> toolViewPositions;
  89     QMap<QString, Sublime::Position> desiredToolViews;
  90     QMap<Sublime::Position, QString> shownToolView;
  91     QMap<Sublime::Position, int> thickness;
  92 };
  93
  94
  95
  96 // class Area
  97
  98 Area::Area(Controller *controller, const QString &name, const QString &title)
  99     :QObject(controller), d( new AreaPrivate() )
 100 {
 101     // FIXME: using objectName seems fishy. Introduce areaType method,
 102     // or some such.
 103     setObjectName(name);
 104     d->title = title;
 105     d->controller = controller;
 106     initialize();
 107 }
 108
 109 Area::Area(const Area &area)
 110     : QObject(area.controller()), d( new AreaPrivate( *(area.d) ) )
 111 {
 112     setObjectName(area.objectName());
 113
 114     //clone toolviews
 115     d->toolViews.clear();
 116     foreach (View *view, area.toolViews())
 117         addToolView(view->document()->createView(), area.toolViewPosition(view));
 118     initialize();
 119 }
 120
 121 void Area::initialize()
 122 {
 123     connect(this, SIGNAL(viewAdded(Sublime::AreaIndex*, Sublime::View*)),
 124             d->controller, SLOT(notifyViewAdded(Sublime::AreaIndex*, Sublime::View*)));
 125     connect(this, SIGNAL(aboutToRemoveView(Sublime::AreaIndex*, Sublime::View*)),
 126             d->controller, SLOT(notifyViewRemoved(Sublime::AreaIndex*, Sublime::View*)));
 127     connect(this, SIGNAL(toolViewAdded(Sublime::View*, Sublime::Position)),
 128             d->controller, SLOT(notifyToolViewAdded(Sublime::View*, Sublime::Position)));
 129     connect(this, SIGNAL(aboutToRemoveToolView(Sublime::View*, Sublime::Position)),
 130             d->controller, SLOT(notifyToolViewRemoved(Sublime::View*, Sublime::Position)));
 131     connect(this, SIGNAL(toolViewMoved(Sublime::View*, Sublime::Position)),
 132             d->controller, SIGNAL(toolViewMoved(Sublime::View*)));
 133
 134     /* In theory, ownership is passed to us, so should not bother detecting
 135     deletion outside.  */
 136     connect(this, SIGNAL(destroyed(QObject*)),
 137             d->controller, SLOT(removeArea(QObject*)));
 138 }
 139
 140 Area::~Area()
 141 {
 142     delete d;
 143 }
 144
 145 void Sublime::Area::addView(View *view, AreaIndex *index)
 146 {
 147     index->add(view);
 148     emit viewAdded(index, view);
 149     connect(this, SIGNAL(destroyed()), view, SLOT(deleteLater()));
 150 }
 151
 152 void Area::addView(View *view, View *after)
 153 {
 154     AreaIndex *index = d->currentIndex;
 155     if (after)
 156     {
 157         AreaIndex *i = indexOf(after);
 158         if (i)
 159             index = i;
 160     }
 161     addView(view, index);
 162 }
 163
 164 void Area::addView(View *view, View *viewToSplit, Qt::Orientation orientation)
 165 {
 166     AreaIndex *indexToSplit = indexOf(viewToSplit);
 167     indexToSplit->split(view, orientation);
 168     emit viewAdded(indexToSplit, view);
 169     connect(this, SIGNAL(destroyed()), view, SLOT(deleteLater()));
 170 }
 171
 172 View* Area::removeView(View *view)
 173 {
 174     AreaIndex *index = indexOf(view);
 175     Q_ASSERT(index);
 176
 177     emit aboutToRemoveView(index, view);
 178     index->remove(view);
 179     return view;
 180 }
 181
 182 AreaIndex *Area::indexOf(View *view)
 183 {
 184     AreaPrivate::ViewFinder f(view);
 185     walkViews(f, d->rootIndex);
 186     return f.index;
 187 }
 188
 189 RootAreaIndex *Area::rootIndex() const
 190 {
 191     return d->rootIndex;
 192 }
 193
 194 void Area::addToolView(View *view, Position defaultPosition)
 195 {
 196     d->toolViews.append(view);
 197     QString id = view->document()->documentSpecifier();
 198     Position position = defaultPosition;
 199     if (d->desiredToolViews.contains(id))
 200         position = d->desiredToolViews[id];
 201     d->desiredToolViews[id] = position;
 202     d->toolViewPositions[view] = position;
 203     emit toolViewAdded(view, position);
 204 }
 205
 206 void Sublime::Area::raiseToolView(View * toolView)
 207 {
 208     emit requestToolViewRaise(toolView);
 209 }
 210
 211 View* Area::removeToolView(View *view)
 212 {
 213     if (!d->toolViews.contains(view))
 214         return 0;
 215
 216     emit aboutToRemoveToolView(view, d->toolViewPositions[view]);
 217     QString id = view->document()->documentSpecifier();
 218     kDebug() << this << "removed tool view " << id;
 219     d->desiredToolViews.remove(id);
 220     d->toolViews.removeAll(view);
 221     d->toolViewPositions.remove(view);
 222     return view;
 223 }
 224
 225 void Area::moveToolView(View *toolView, Position newPosition)
 226 {
 227     if (!d->toolViews.contains(toolView))
 228         return;
 229
 230     QString id = toolView->document()->documentSpecifier();
 231     d->desiredToolViews[id] = newPosition;
 232     d->toolViewPositions[toolView] = newPosition;
 233     emit toolViewMoved(toolView, newPosition);
 234 }
 235
 236 QList<View*> &Area::toolViews() const
 237 {
 238     return d->toolViews;
 239 }
 240
 241 Position Area::toolViewPosition(View *toolView) const
 242 {
 243     return d->toolViewPositions[toolView];
 244 }
 245
 246 Controller *Area::controller() const
 247 {
 248     return d->controller;
 249 }
 250
 251 QList<View*> Sublime::Area::views()
 252 {
 253     AreaPrivate::ViewLister lister;
 254     walkViews(lister, d->rootIndex);
 255     return lister.views;
 256 }
 257
 258 QString Area::title() const
 259 {
 260     return d->title;
 261 }
 262
 263 void Area::setTitle(const QString &title)
 264 {
 265     d->title = title;
 266 }
 267
 268 void Area::save(KConfigGroup& group) const
 269 {
 270     QStringList desired;
 271     QMap<QString, Sublime::Position>::iterator i, e;
 272     for (i = d->desiredToolViews.begin(), e = d->desiredToolViews.end(); i != e; ++i)
 273     {
 274         desired << i.key() + ":" + QString::number(static_cast<int>(i.value()));
 275     }
 276     group.writeEntry("desired views", desired);
 277     kDebug() << "save " << this << "wrote" << group.readEntry("desired views", "");
 278     group.writeEntry("view on left", shownToolView(Sublime::Left));
 279     group.writeEntry("view on right", shownToolView(Sublime::Right));
 280     group.writeEntry("view on top", shownToolView(Sublime::Top));
 281     group.writeEntry("view on bottom", shownToolView(Sublime::Bottom));
 282     group.writeEntry("thickness left", thickness(Sublime::Left));
 283     group.writeEntry("thickness right", thickness(Sublime::Right));
 284     group.writeEntry("thickness bottom", thickness(Sublime::Bottom));
 285     group.writeEntry("thickness top", thickness(Sublime::Top));
 286 }
 287
 288 void Area::load(const KConfigGroup& group)
 289 {
 290     kDebug() << "loading areas config";
 291     d->desiredToolViews.clear();
 292     QStringList desired = group.readEntry("desired views", QStringList());
 293     foreach (const QString &s, desired)
 294     {
 295         int i = s.indexOf(':');
 296         if (i != -1)
 297         {
 298             QString id = s.left(i);
 299             int pos_i = s.mid(i+1).toInt();
 300             Sublime::Position pos = static_cast<Sublime::Position>(pos_i);
 301             if (pos != Sublime::Left && pos != Sublime::Right
 302                 && pos != Sublime::Top && pos != Sublime::Bottom)
 303                 pos = Sublime::Bottom;
 304             d->desiredToolViews[id] = pos;
 305         }
 306     }
 307     setShownToolView(Sublime::Left, group.readEntry("view on left", QString()));
 308     setShownToolView(Sublime::Right,
 309                      group.readEntry("view on right", QString()));
 310     setShownToolView(Sublime::Top, group.readEntry("view on top", QString()));
 311     setShownToolView(Sublime::Bottom,
 312                      group.readEntry("view on bottom", QString()));
 313     setThickness(Sublime::Left, group.readEntry("thickness left", -1));
 314     setThickness(Sublime::Right, group.readEntry("thickness right", -1));
 315     setThickness(Sublime::Bottom, group.readEntry("thickness bottom", -1));
 316     setThickness(Sublime::Top, group.readEntry("thickness top", -1));
 317 }
 318
 319 bool Area::wantToolView(const QString& id)
 320 {
 321     kDebug() << d->desiredToolViews << " " << id;
 322     return (d->desiredToolViews.contains(id));
 323 }
 324
 325 void Area::setShownToolView(Sublime::Position pos, const QString& id)
 326 {
 327     d->shownToolView[pos] = id;
 328 }
 329
 330 QString Area::shownToolView(Sublime::Position pos) const
 331 {
 332     return d->shownToolView[pos];
 333 }
 334
 335 void Area::setDesiredToolViews(
 336     const QMap<QString, Sublime::Position>& desiredToolViews)
 337 {
 338     d->desiredToolViews = desiredToolViews;
 339 }
 340
 341 void Area::setThickness(Sublime::Position pos, int thickness)
 342 {
 343     d->thickness[pos] = thickness;
 344 }
 345
 346 int Area::thickness(Sublime::Position pos) const
 347 {
 348     if (!d->thickness.count(pos))
 349         return -1;
 350     return (d->thickness)[pos];
 351 }
 352
 353 }
 354
 355 #include "area.moc"