sublime/mainwindow.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 "mainwindow.h"
  20 #include "mainwindow_p.h"
  21
  22 #include <kdebug.h>
  23 #include <kglobal.h>
  24 #include <kconfig.h>
  25 #include <ksharedconfig.h>
  26 #include <kconfiggroup.h>
  27 #include <ktoolbar.h>
  28 #include <kwindowsystem.h>
  29
  30 #include <QApplication>
  31 #include <QDesktopWidget>
  32 #include <KStatusBar>
  33 #include <KMenuBar>
  34
  35 #include "area.h"
  36 #include "view.h"
  37 #include "controller.h"
  38 #include "container.h"
  39
  40 namespace Sublime {
  41
  42 MainWindow::MainWindow(Controller *controller, Qt::WindowFlags flags)
  43 : KParts::MainWindow(0, flags), d(new MainWindowPrivate(this, controller))
  44 {
  45     connect(this, SIGNAL(destroyed()), controller, SLOT(areaReleased()));
  46     connect(this, SIGNAL(areaCleared(Sublime::Area*)), controller, SLOT(areaReleased(Sublime::Area*)));
  47
  48     loadGeometry(KGlobal::config()->group("Main Window"));
  49 }
  50
  51 MainWindow::~MainWindow()
  52 {
  53     kDebug() << "destroying mainwindow";
  54     delete d;
  55 }
  56
  57 void MainWindow::setArea(Area *area)
  58 {
  59     bool differentArea = (area != d->area);
  60     /* All views will be removed from dock area now.  However, this does
  61        not mean those are removed from area, so prevent slotDockShown
  62        from recording those views as no longer shown in the area.  */
  63     d->ignoreDockShown = true;
  64
  65     if (d->autoAreaSettingsSave && differentArea)
  66         saveSettings();
  67
  68     if (d->area)
  69         clearArea();
  70     d->area = area;
  71     d->reconstruct();
  72     d->activateFirstVisibleView();
  73     emit areaChanged(area);
  74     d->ignoreDockShown = false;
  75
  76     loadSettings();
  77 }
  78
  79 void MainWindow::resizeEvent(QResizeEvent* event)
  80 {
  81     return KParts::MainWindow::resizeEvent(event);
  82 }
  83
  84 void MainWindow::clearArea()
  85 {
  86     emit areaCleared(d->area);
  87     d->clearArea();
  88 }
  89
  90 QList<View*> MainWindow::toolDocks() const
  91 {
  92     return d->docks;
  93 }
  94
  95 Area *Sublime::MainWindow::area() const
  96 {
  97     return d->area;
  98 }
  99
 100 Controller *MainWindow::controller() const
 101 {
 102     return d->controller;
 103 }
 104
 105 View *MainWindow::activeView()
 106 {
 107     return d->activeView;
 108 }
 109
 110 View *MainWindow::activeToolView()
 111 {
 112     return d->activeToolView;
 113 }
 114
 115 void MainWindow::activateView(View *view)
 116 {
 117     if (!d->viewContainers.contains(view))
 118         return;
 119     d->viewContainers[view]->setCurrentWidget(view->widget());
 120
 121     setActiveView(view);
 122 }
 123
 124 void MainWindow::setActiveView(View *view)
 125 {
 126     d->activeView = view;
 127     if (view && !view->widget()->hasFocus())
 128         view->widget()->setFocus();
 129     emit activeViewChanged(view);
 130 }
 131
 132 void Sublime::MainWindow::setActiveToolView(View *view)
 133 {
 134     d->activeToolView = view;
 135     emit activeToolViewChanged(view);
 136 }
 137
 138 void MainWindow::saveSettings()
 139 {
 140     QString group = "MainWindow";
 141     if (area())
 142         group += '_' + area()->objectName();
 143     KConfigGroup cg = KGlobal::config()->group(group);
 144     /* This will try to save window size, too.  But it's OK, since we
 145        won't use this information when loading.  */
 146     saveMainWindowSettings(cg);
 147     cg.sync();
 148 }
 149
 150 void MainWindow::loadSettings()
 151 {
 152     kDebug() << "loading settings for " << (area() ? area()->objectName() : "");
 153     QString group = "MainWindow";
 154     if (area())
 155         group += '_' + area()->objectName();
 156     KConfigGroup cg = KGlobal::config()->group(group);
 157
 158     // What follows is copy-paste from applyMainWindowSettings.  Unfortunately,
 159     // we don't really want that one to try restoring window size, and we also
 160     // cannot stop it from doing that in any clean way.
 161     QStatusBar* sb = qFindChild<KStatusBar *>(this);
 162     if (sb) {
 163         QString entry = cg.readEntry("StatusBar", "Enabled");
 164         if ( entry == "Disabled" )
 165            sb->hide();
 166         else
 167            sb->show();
 168     }
 169
 170     QMenuBar* mb = qFindChild<KMenuBar *>(this);
 171     if (mb) {
 172         QString entry = cg.readEntry ("MenuBar", "Enabled");
 173         if ( entry == "Disabled" )
 174            mb->hide();
 175         else
 176            mb->show();
 177     }
 178
 179     if ( !autoSaveSettings() || cg.name() == autoSaveGroup() ) {
 180         QString entry = cg.readEntry ("ToolBarsMovable", "Enabled");
 181         if ( entry == "Disabled" )
 182             KToolBar::setToolBarsLocked(true);
 183         else
 184             KToolBar::setToolBarsLocked(false);
 185     }
 186
 187     int n = 1; // Toolbar counter. toolbars are counted from 1,
 188     foreach (KToolBar* toolbar, toolBars()) {
 189         QString group("Toolbar");
 190         // Give a number to the toolbar, but prefer a name if there is one,
 191         // because there's no real guarantee on the ordering of toolbars
 192         group += (toolbar->objectName().isEmpty() ? QString::number(n) : QString(" ")+toolbar->objectName());
 193
 194         KConfigGroup toolbarGroup(&cg, group);
 195         toolbar->applySettings(toolbarGroup, false);
 196         n++;
 197     }
 198
 199     // Utilise the QMainWindow::restoreState() functionality
 200     // Note that we're fixing KMainWindow bug here -- the original
 201     // code has this fragment above restoring toolbar properties.
 202     // As result, each save/restore would move the toolbar a bit to
 203     // the left.
 204     if (cg.hasKey("State")) {
 205         QByteArray state;
 206         state = cg.readEntry("State", state);
 207         state = QByteArray::fromBase64(state);
 208         // One day will need to load the version number, but for now, assume 0
 209         restoreState(state);
 210     }
 211
 212     KConfigGroup uiGroup = KGlobal::config()->group("UiSettings");
 213     foreach (Container *container, findChildren<Container*>())
 214         container->setTabBarHidden(uiGroup.readEntry("TabBarVisibility", 1) == 0);
 215
 216     cg.sync();
 217
 218     emit settingsLoaded();
 219 }
 220
 221 bool MainWindow::queryClose()
 222 {
 223 //    saveSettings();
 224     KConfigGroup config(KGlobal::config(), "Main Window");
 225     saveGeometry(config);
 226     config.sync();
 227
 228     return KParts::MainWindow::queryClose();
 229 }
 230
 231 void Sublime::MainWindow::setStatusIcon(View * view, const QIcon & icon)
 232 {
 233     d->setStatusIcon(view, icon);
 234 }
 235
 236 void MainWindow::saveGeometry(KConfigGroup &config)
 237 {
 238     int scnum = QApplication::desktop()->screenNumber(parentWidget());
 239     QRect desk = QApplication::desktop()->screenGeometry(scnum);
 240
 241     // if the desktop is virtual then use virtual screen size
 242     if (QApplication::desktop()->isVirtualDesktop())
 243         desk = QApplication::desktop()->screenGeometry(QApplication::desktop()->screen());
 244
 245     QString key = QString::fromLatin1("Desktop %1 %2")
 246         .arg(desk.width()).arg(desk.height());
 247     config.writeEntry(key, geometry());
 248
 249 }
 250 void MainWindow::loadGeometry(const KConfigGroup &config)
 251 {
 252     // The below code, essentially, is copy-paste from
 253     // KMainWindow::restoreWindowSize.  Right now, that code is buggy,
 254     // as per http://permalink.gmane.org/gmane.comp.kde.devel.core/52423
 255     // so we implement a less theoretically correct, but working, version
 256     // below
 257     const int scnum = QApplication::desktop()->screenNumber(parentWidget());
 258     QRect desk = QApplication::desktop()->screenGeometry(scnum);
 259
 260     // if the desktop is virtual then use virtual screen size
 261     if (QApplication::desktop()->isVirtualDesktop())
 262         desk = QApplication::desktop()->screenGeometry(QApplication::desktop()->screen());
 263
 264     QString key = QString::fromLatin1("Desktop %1 %2")
 265         .arg(desk.width()).arg(desk.height());
 266     QRect g = config.readEntry(key, QRect());
 267     if (!g.isEmpty())
 268         setGeometry(g);
 269 }
 270
 271 void MainWindow::enableAreaSettingsSave()
 272 {
 273     d->autoAreaSettingsSave = true;
 274 }
 275
 276 }
 277
 278 #include "mainwindow.moc"