sublime/controller.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 "controller.h"
  20
  21 #include <QMap>
  22 #include <QList>
  23 #include <QEvent>
  24 #include <QMouseEvent>
  25 #include <QApplication>
  26
  27 #include <kdebug.h>
  28
  29 #include "area.h"
  30 #include "view.h"
  31 #include "document.h"
  32 #include "mainwindow.h"
  33
  34 namespace Sublime {
  35
  36 struct WidgetFinder {
  37     WidgetFinder(QWidget *_w) :w(_w), view(0) {}
  38     Area::WalkerMode operator()(AreaIndex *index)
  39     {
  40         foreach (View *v, index->views())
  41         {
  42             if (v->hasWidget() && (v->widget() == w))
  43             {
  44                 view = v;
  45                 return Area::StopWalker;
  46             }
  47         }
  48         return Area::ContinueWalker;
  49     }
  50
  51     QWidget *w;
  52     View *view;
  53 };
  54
  55 struct ToolWidgetFinder {
  56     ToolWidgetFinder(QWidget *_w) :w(_w), view(0) {}
  57     Area::WalkerMode operator()(View *v, Sublime::Position /*position*/)
  58     {
  59         if (v->hasWidget() && (v->widget() == w))
  60         {
  61             view = v;
  62             return Area::StopWalker;
  63         }
  64         return Area::ContinueWalker;
  65     }
  66
  67     QWidget *w;
  68     View *view;
  69 };
  70
  71
  72 // struct ControllerPrivate
  73
  74 struct ControllerPrivate {
  75     ControllerPrivate()
  76     {
  77     }
  78
  79     void removeArea(QObject *obj)
  80     {
  81         areas.removeAll(reinterpret_cast<Area*>(obj));
  82     }
  83
  84     void removeDocument(QObject *obj)
  85     {
  86         documents.removeAll(reinterpret_cast<Document*>(obj));
  87     }
  88
  89     QList<Document*> documents;
  90     QList<Area*> areas;
  91     QList<Area*> allAreas;
  92     QMap<QString, Area*> namedAreas;
  93     // FIXME: remove this.
  94     QMap<Area*, MainWindow*> shownAreas;
  95     QList<MainWindow*> controlledWindows;
  96     QVector< QList<Area*> > mainWindowAreas;
  97 };
  98
  99
 100
 101 // class Controller
 102
 103 Controller::Controller(QObject *parent)
 104     :QObject(parent), MainWindowOperator(), d( new ControllerPrivate() )
 105 {
 106     init();
 107 }
 108
 109 void Controller::init()
 110 {
 111
 112     qApp->installEventFilter(this);
 113 }
 114
 115 Controller::~Controller()
 116 {
 117     // FIXME:
 118 //    foreach (MainWindow *w, d->controlledWindows)
 119 //        delete w;
 120     delete d;
 121 }
 122
 123 void Controller::showArea(Area *area, MainWindow *mainWindow)
 124 {
 125     Area *areaToShow = 0;
 126     //if the area is already shown in another mainwindow then we need to clone it
 127     if (d->shownAreas.contains(area) && (mainWindow != d->shownAreas[area]))
 128         areaToShow = new Area(*area);
 129     else
 130         areaToShow = area;
 131     d->shownAreas[areaToShow] = mainWindow;
 132
 133     showAreaInternal(areaToShow, mainWindow);
 134 }
 135
 136 void Controller::showAreaInternal(Area* area, MainWindow *mainWindow)
 137 {
 138     /* Disconnect the previous area.  We really don't want to mess with
 139        main window if an area not visible now is modified.  Further,
 140        if showAreaInternal is called with the same area as is current
 141        now, we don't want to connect the same signals twice.  */
 142     if (mainWindow->area())
 143         disconnect(mainWindow->area(), 0, mainWindow, 0);
 144     MainWindowOperator::setArea(mainWindow, area);
 145     connect(area, SIGNAL(viewAdded(Sublime::AreaIndex*, Sublime::View*)),
 146         mainWindow, SLOT(viewAdded(Sublime::AreaIndex*, Sublime::View*)));
 147     connect(area, SIGNAL(requestToolViewRaise(Sublime::View*)),
 148         mainWindow, SLOT(raiseToolView(Sublime::View*)));
 149     connect(area, SIGNAL(aboutToRemoveView(Sublime::AreaIndex*, Sublime::View*)),
 150         mainWindow, SLOT(aboutToRemoveView(Sublime::AreaIndex*, Sublime::View*)));
 151     connect(area, SIGNAL(toolViewAdded(Sublime::View*, Sublime::Position)),
 152         mainWindow, SLOT(toolViewAdded(Sublime::View*, Sublime::Position)));
 153     connect(area, SIGNAL(aboutToRemoveToolView(Sublime::View*, Sublime::Position)),
 154         mainWindow, SLOT(aboutToRemoveToolView(Sublime::View*, Sublime::Position)));
 155     connect(area, SIGNAL(toolViewMoved(Sublime::View*, Sublime::Position)),
 156         mainWindow, SLOT(toolViewMoved(Sublime::View*, Sublime::Position)));
 157 }
 158
 159 void Controller::showArea(const QString& areaTypeId, MainWindow *mainWindow)
 160 {
 161     int index = d->controlledWindows.indexOf(mainWindow);
 162     Q_ASSERT(index != -1);
 163
 164     Area* area = NULL;
 165     foreach (Area* a, d->mainWindowAreas[index])
 166     {
 167         kDebug() << "Object name: " << a->objectName() << " id "
 168                      << areaTypeId;
 169         if (a->objectName() == areaTypeId)
 170         {
 171             area = a;
 172             break;
 173         }
 174     }
 175     Q_ASSERT (area);
 176
 177     showAreaInternal(area, mainWindow);
 178 }
 179
 180 void Controller::resetCurrentArea(MainWindow *mainWindow)
 181 {
 182     QString id = mainWindow->area()->objectName();
 183
 184     int areaIndex = 0;
 185     Area* def = NULL;
 186     foreach (Area* a, d->areas) {
 187         if (a->objectName() == id)
 188         {
 189             def = a;
 190             break;
 191         }
 192         ++areaIndex;
 193     }
 194     Q_ASSERT(def);
 195
 196     int index = d->controlledWindows.indexOf(mainWindow);
 197     Q_ASSERT(index != -1);
 198
 199     Area* prev = d->mainWindowAreas[index][areaIndex];
 200     d->mainWindowAreas[index][areaIndex] = new Area(*def);
 201     showAreaInternal(d->mainWindowAreas[index][areaIndex], mainWindow);
 202     delete prev;
 203 }
 204
 205 const QList<Area*> &Controller::defaultAreas() const
 206 {
 207     return d->areas;
 208 }
 209
 210 const QList<Area*> &Controller::areas(int mainWindow) const
 211 {
 212     return d->mainWindowAreas[mainWindow];
 213 }
 214
 215 const QList<Area*> &Controller::allAreas() const
 216 {
 217     return d->allAreas;
 218 }
 219
 220 const QList<Document*> &Controller::documents() const
 221 {
 222     return d->documents;
 223 }
 224
 225 void Controller::addDefaultArea(Area *area)
 226 {
 227     d->areas.append(area);
 228     d->allAreas.append(area);
 229     d->namedAreas[area->objectName()] = area;
 230 }
 231
 232 void Controller::addMainWindow(MainWindow* mainWindow)
 233 {
 234     Q_ASSERT (!d->controlledWindows.contains(mainWindow));
 235     d->controlledWindows << mainWindow;
 236     d->mainWindowAreas.resize(d->controlledWindows.size());
 237     int index = d->controlledWindows.size()-1;
 238
 239     foreach (Area* area, defaultAreas())
 240     {
 241         Area *na = new Area(*area);
 242         d->allAreas.append(na);
 243         d->mainWindowAreas[index].push_back(na);
 244     }
 245     showAreaInternal(d->mainWindowAreas[index][0], mainWindow);
 246 }
 247
 248 void Controller::addDocument(Document *document)
 249 {
 250     d->documents.append(document);
 251 }
 252
 253 void Controller::areaReleased()
 254 {
 255     MainWindow *w = reinterpret_cast<Sublime::MainWindow*>(sender());
 256     kDebug() << "marking areas as mainwindow-free";
 257     foreach (Area *area, d->shownAreas.keys(w))
 258     {
 259         kDebug() << "" << area->objectName();
 260         areaReleased(area);
 261         disconnect(area, 0, w, 0);
 262     }
 263 }
 264
 265 void Controller::areaReleased(Sublime::Area *area)
 266 {
 267     d->controlledWindows.removeAll(d->shownAreas[area]);
 268     d->shownAreas.remove(area);
 269     d->namedAreas.remove(area->objectName());
 270 }
 271
 272 Area *Controller::defaultArea(const QString &id)
 273 {
 274     return d->namedAreas[id];
 275 }
 276
 277 Area *Controller::area(int mainWindow, const QString& id)
 278 {
 279     foreach (Area* area, areas(mainWindow))
 280     {
 281         if (area->objectName() == id)
 282             return area;
 283     }
 284     return 0;
 285 }
 286
 287 /*We need this to catch activation of views and toolviews
 288 so that we can always tell what view and toolview is active.
 289 "Active" doesn't mean focused. It means that it is focused now
 290 or was focused before and no other view/toolview wasn't focused
 291 after that."*/
 292 //implementation is based upon KParts::PartManager::eventFilter
 293 bool Controller::eventFilter(QObject *obj, QEvent *ev)
 294 {
 295
 296     if (ev->type() != QEvent::MouseButtonPress &&
 297         ev->type() != QEvent::MouseButtonDblClick &&
 298         ev->type() != QEvent::FocusIn)
 299         return false;
 300
 301     //not a widget? - return
 302     if (!obj->isWidgetType())
 303         return false;
 304
 305     //is dialog or popup? - return
 306     QWidget *w = static_cast<QWidget*>(obj);
 307     if (((w->windowFlags().testFlag(Qt::Dialog)) && w->isModal()) ||
 308             (w->windowFlags().testFlag(Qt::Popup)) || (w->windowFlags().testFlag(Qt::Tool)))
 309         return false;
 310
 311     //not a mouse button that should activate the widget? - return
 312     QMouseEvent *mev = 0;
 313     if (ev->type() == QEvent::MouseButtonPress || ev->type() == QEvent::MouseButtonDblClick)
 314     {
 315         mev = static_cast<QMouseEvent*>(ev);
 316         int activationButtonMask = Qt::LeftButton | Qt::MidButton | Qt::RightButton;
 317         if ((mev->button() & activationButtonMask) == 0)
 318             return false;
 319     }
 320
 321     while (w)
 322     {
 323         //not inside sublime mainwindow
 324         MainWindow *mw = qobject_cast<Sublime::MainWindow*>(w->topLevelWidget());
 325         if (!mw || !d->controlledWindows.contains(mw))
 326             return false;
 327
 328         Area *area = mw->area();
 329
 330         ///@todo adymo: this is extra slow - optimize
 331         //find this widget in views
 332         WidgetFinder widgetFinder(w);
 333         area->walkViews(widgetFinder, area->rootIndex());
 334         if (widgetFinder.view && widgetFinder.view != mw->activeView())
 335         {
 336             setActiveView(mw, widgetFinder.view);
 337             ///@todo adymo: shall we filter out the event?
 338             return false;
 339         }
 340
 341         //find this widget in toolviews
 342         ToolWidgetFinder toolFinder(w);
 343         area->walkToolViews(toolFinder, Sublime::AllPositions);
 344         if (toolFinder.view && toolFinder.view != mw->activeToolView())
 345         {
 346             setActiveToolView(mw, toolFinder.view);
 347             ///@todo adymo: shall we filter out the event?
 348             return false;
 349         }
 350
 351         w = w->parentWidget();
 352     }
 353
 354     return false;
 355 }
 356
 357 const QList< MainWindow * > & Controller::mainWindows() const
 358 {
 359     return d->controlledWindows;
 360 }
 361
 362
 363 void Controller::notifyToolViewRemoved(Sublime::View *view, Sublime::Position)
 364 {
 365     emit aboutToRemoveToolView(view);
 366 }
 367
 368 void Controller::notifyToolViewAdded(Sublime::View *view, Sublime::Position)
 369 {
 370     emit toolViewAdded(view);
 371 }
 372
 373 void Controller::notifyViewRemoved(Sublime::AreaIndex*, Sublime::View *view)
 374 {
 375     emit aboutToRemoveView(view);
 376 }
 377
 378 void Controller::notifyViewAdded(Sublime::AreaIndex*, Sublime::View *view)
 379 {
 380     emit viewAdded(view);
 381 }
 382
 383 void Controller::setStatusIcon(Document * document, const QIcon & icon)
 384 {
 385     foreach (MainWindow* mw, mainWindows())
 386         if (mw->area())
 387             foreach (View* view, mw->area()->views())
 388                 if (view->document() == document)
 389                     MainWindowOperator::setStatusIcon(mw, view, icon);
 390 }
 391
 392 }
 393
 394 #include "controller.moc"