← Back to branch summary

~ubuntu-branches/ubuntu/natty/kadu/natty

« back to all changes in this revision

Viewing changes to kadu-core/kadu_main_window.cpp

  • Committer: Package Import Robot
  • Author(s): Kiszel Kristóf
  • Date: 2010-07-21 15:24:54 UTC
  • mfrom: (0.6.1) (0.5.1) (1.4.1) (22.1.2 maverick)
  • Revision ID: package-import@ubuntu.com-20100721152454-vttqle18lovfudni
Tags: 0.6.5.4.ds1-3ubuntu2
Remove libqt4-webkit-dev from build-depends and add
libqtwebkit-dev for qtwebkit transition

Show diffs side-by-side

added added

removed removed

Lines of Context:
kadu-core/kadu_main_window.cpp
 
1
/***************************************************************************
 
2
 *                                                                         *
 
3
 *   This program is free software; you can redistribute it and/or modify  *
 
4
 *   it under the terms of the GNU General Public License as published by  *
 
5
 *   the Free Software Foundation; either version 2 of the License, or     *
 
6
 *   (at your option) any later version.                                   *
 
7
 *                                                                         *
 
8
 ***************************************************************************/
 
9
 
 
10
#include <QtGui/QContextMenuEvent>
 
11
#include <QtGui/QMenu>
 
12
 
 
13
#include "config_file.h"
 
14
#include "debug.h"
 
15
#include "toolbar.h"
 
16
#include "userbox.h"
 
17
 
 
18
#include "kadu_main_window.h"
 
19
 
 
20
KaduMainWindow::KaduMainWindow(QWidget *parent)
 
21
        : QMainWindow(parent)
 
22
{
 
23
}
 
24
 
 
25
KaduMainWindow::~KaduMainWindow()
 
26
{
 
27
}
 
28
 
 
29
void KaduMainWindow::loadToolBarsFromConfig(const QString &prefix)
 
30
{
 
31
        QString realPrefix;
 
32
        if (prefix.isEmpty())
 
33
                realPrefix = "";
 
34
        else
 
35
                realPrefix = prefix + "_";
 
36
 
 
37
        loadToolBarsFromConfig(realPrefix + "topDockArea", Qt::TopToolBarArea);
 
38
        loadToolBarsFromConfig(realPrefix + "leftDockArea", Qt::LeftToolBarArea);
 
39
        loadToolBarsFromConfig(realPrefix + "bottomDockArea", Qt::BottomToolBarArea);
 
40
        loadToolBarsFromConfig(realPrefix + "rightDockArea", Qt::RightToolBarArea);
 
41
}
 
42
 
 
43
bool horizontalToolbarComparator(ToolBar *t1, ToolBar *t2)
 
44
{
 
45
        if (t1->yOffset() < t2->yOffset())
 
46
                return true;
 
47
        if (t1->yOffset() > t2->yOffset())
 
48
                return false;
 
49
        return t1->xOffset() < t2->xOffset();
 
50
}
 
51
 
 
52
bool verticalToolbarComparator(ToolBar *t1, ToolBar *t2)
 
53
{
 
54
        if (t1->xOffset() < t2->xOffset())
 
55
                return true;
 
56
        if (t1->xOffset() > t2->xOffset())
 
57
                return false;
 
58
        return t1->yOffset() < t2->yOffset();
 
59
}
 
60
 
 
61
bool KaduMainWindow::loadToolBarsFromConfig(const QString &configName, Qt::ToolBarArea area, bool remove)
 
62
{
 
63
        kdebugf();
 
64
 
 
65
        QDomElement toolbarsConfig = xml_config_file->findElement(xml_config_file->rootElement(), "Toolbars");
 
66
 
 
67
        if (toolbarsConfig.isNull())
 
68
                return false;
 
69
 
 
70
        QDomElement dockareaConfig = xml_config_file->findElementByProperty(toolbarsConfig, "DockArea", "name", configName);
 
71
        if (dockareaConfig.isNull())
 
72
                return false;
 
73
 
 
74
        QList<ToolBar *> toolBars;
 
75
        for (QDomNode n = dockareaConfig.firstChild(); !n.isNull(); n = n.nextSibling())
 
76
        {
 
77
                const QDomElement &toolbarConfig = n.toElement();
 
78
                if (toolbarConfig.isNull())
 
79
                        continue;
 
80
                if (toolbarConfig.tagName() != "ToolBar")
 
81
                        continue;
 
82
 
 
83
                ToolBar* toolbar = new ToolBar(this);
 
84
                toolbar->loadFromConfig(toolbarConfig);
 
85
                toolbar->show();
 
86
 
 
87
                toolBars.append(toolbar);
 
88
        }
 
89
 
 
90
        int currentLine = 0;
 
91
        if (area == Qt::LeftToolBarArea || area == Qt::RightToolBarArea)
 
92
        {
 
93
                qSort(toolBars.begin(), toolBars.end(), verticalToolbarComparator);
 
94
                foreach(ToolBar *toolBar, toolBars)
 
95
                {
 
96
                        if (toolBar->xOffset() != currentLine)
 
97
                                addToolBarBreak(area);
 
98
 
 
99
                        addToolBar(area, toolBar);
 
100
                        currentLine = toolBar->xOffset();
 
101
                }
 
102
        }
 
103
        else
 
104
        {
 
105
                qSort(toolBars.begin(), toolBars.end(), horizontalToolbarComparator);
 
106
                foreach(ToolBar *toolBar, toolBars)
 
107
                {
 
108
                        if (toolBar->yOffset() != currentLine)
 
109
                                addToolBarBreak(area);
 
110
 
 
111
                        addToolBar(area, toolBar);
 
112
                        currentLine = toolBar->yOffset();
 
113
                }
 
114
        }
 
115
 
 
116
        if (remove)
 
117
                toolbarsConfig.removeChild(dockareaConfig);
 
118
 
 
119
        kdebugf2();
 
120
 
 
121
        return true;
 
122
}
 
123
 
 
124
QDomElement KaduMainWindow::getToolbarsConfigElement()
 
125
{
 
126
        QDomElement toolbarsConfig = xml_config_file->findElement(xml_config_file->rootElement(), "Toolbars");
 
127
        if (toolbarsConfig.isNull())
 
128
                toolbarsConfig = xml_config_file->createElement(xml_config_file->rootElement(), "Toolbars");
 
129
 
 
130
        return toolbarsConfig;
 
131
}
 
132
 
 
133
QDomElement KaduMainWindow::getDockAreaConfigElement(QDomElement toolbarsConfig, const QString &name)
 
134
{
 
135
        QDomElement dockAreaConfig = xml_config_file->findElementByProperty(toolbarsConfig, "DockArea", "name", name);
 
136
        if (dockAreaConfig.isNull())
 
137
        {
 
138
                dockAreaConfig = xml_config_file->createElement(toolbarsConfig, "DockArea");
 
139
                dockAreaConfig.setAttribute("name", name);
 
140
        }
 
141
 
 
142
        return dockAreaConfig;
 
143
}
 
144
 
 
145
void KaduMainWindow::addToolButton(QDomElement toolbarConfig, const QString &actionName, bool showLabel)
 
146
{
 
147
        QDomElement buttonConfig = xml_config_file->findElementByProperty(toolbarConfig, "ToolButton", "action_name", actionName);
 
148
//don't add element if exists
 
149
        if (!buttonConfig.isNull())
 
150
                return;
 
151
        buttonConfig = xml_config_file->createElement(toolbarConfig, "ToolButton");
 
152
        buttonConfig.setAttribute("action_name", actionName);
 
153
        buttonConfig.setAttribute("uses_text_label", showLabel);
 
154
}
 
155
 
 
156
QDomElement KaduMainWindow::findExistingToolbarOnArea(const QString &areaName)
 
157
{
 
158
        QDomElement dockAreaConfig = xml_config_file->findElementByProperty(getToolbarsConfigElement(), "DockArea", "name", areaName);
 
159
        QDomElement nullResult;
 
160
 
 
161
        if (dockAreaConfig.isNull())
 
162
                return nullResult;
 
163
 
 
164
        QDomElement toolbarElement = xml_config_file->findElement(dockAreaConfig, "ToolBar");
 
165
        if (toolbarElement.isNull())
 
166
                return nullResult;
 
167
 
 
168
        return toolbarElement;
 
169
}
 
170
 
 
171
QDomElement KaduMainWindow::findExistingToolbar(const QString &prefix)
 
172
{
 
173
        QString realPrefix;
 
174
        if (prefix.isEmpty())
 
175
                realPrefix = "";
 
176
        else
 
177
                realPrefix = prefix + "_";
 
178
 
 
179
        QDomElement toolbarElement = findExistingToolbarOnArea(realPrefix + "topDockArea");
 
180
        if (!toolbarElement.isNull())
 
181
                return toolbarElement;
 
182
 
 
183
        toolbarElement = findExistingToolbarOnArea(realPrefix + "leftDockArea");
 
184
        if (!toolbarElement.isNull())
 
185
                return toolbarElement;
 
186
 
 
187
        toolbarElement = findExistingToolbarOnArea(realPrefix + "rightDockArea");
 
188
        if (!toolbarElement.isNull())
 
189
                return toolbarElement;
 
190
 
 
191
        toolbarElement = findExistingToolbarOnArea(realPrefix + "bottomDockArea");
 
192
        if (!toolbarElement.isNull())
 
193
                return toolbarElement;
 
194
 
 
195
        QDomElement dockAreaConfig = getDockAreaConfigElement(getToolbarsConfigElement(), realPrefix + "topDockArea");
 
196
        return xml_config_file->createElement(dockAreaConfig, "ToolBar");
 
197
}
 
198
 
 
199
void KaduMainWindow::writeToolBarsToConfig(const QString &prefix)
 
200
{
 
201
        QString realPrefix;
 
202
        if (prefix.isEmpty())
 
203
                realPrefix = "";
 
204
        else
 
205
                realPrefix = prefix + "_";
 
206
 
 
207
        QDomElement toolbarsConfig = getToolbarsConfigElement();
 
208
 
 
209
        writeToolBarsToConfig(toolbarsConfig, realPrefix + "topDockArea", Qt::TopToolBarArea);
 
210
        writeToolBarsToConfig(toolbarsConfig, realPrefix + "leftDockArea", Qt::LeftToolBarArea);
 
211
        writeToolBarsToConfig(toolbarsConfig, realPrefix + "bottomDockArea", Qt::BottomToolBarArea);
 
212
        writeToolBarsToConfig(toolbarsConfig, realPrefix + "rightDockArea", Qt::RightToolBarArea);
 
213
}
 
214
 
 
215
void KaduMainWindow::writeToolBarsToConfig(QDomElement toolbarsConfig, const QString &configName, Qt::ToolBarArea area)
 
216
{
 
217
        QDomElement dockAreaConfig = getDockAreaConfigElement(toolbarsConfig, configName);
 
218
        xml_config_file->removeChildren(dockAreaConfig);
 
219
 
 
220
        // TODO: laaaaame
 
221
        foreach(QObject *child, children())
 
222
        {
 
223
                ToolBar *toolBar = dynamic_cast<ToolBar *>(child);
 
224
                if (!toolBar)
 
225
                        continue;
 
226
 
 
227
                if (toolBarArea(toolBar) != area)
 
228
                        continue;
 
229
 
 
230
                toolBar->writeToConfig(dockAreaConfig);
 
231
        }
 
232
}
 
233
 
 
234
void KaduMainWindow::refreshToolBars(const QString &prefix)
 
235
{
 
236
        foreach (const QObject *object, children())
 
237
        {
 
238
                const QToolBar *toolBar = dynamic_cast<const QToolBar *>(object);
 
239
                if (toolBar)
 
240
                        removeToolBar(const_cast<QToolBar *>(toolBar));
 
241
        }
 
242
        loadToolBarsFromConfig(prefix);
 
243
}
 
244
 
 
245
void KaduMainWindow::contextMenuEvent(QContextMenuEvent *event)
 
246
{
 
247
        QMenu *menu = new QMenu(this);
 
248
        menu->addAction(tr("Create new toolbar"), this, SLOT(addTopToolbar()));
 
249
 
 
250
        menu->exec(event->globalPos());
 
251
}
 
252
 
 
253
void KaduMainWindow::addTopToolbar()
 
254
{
 
255
        addToolBar(Qt::TopToolBarArea, new ToolBar(this));
 
256
}
 
257
 
 
258
void KaduMainWindow::addBottomToolbar()
 
259
{
 
260
        addToolBar(Qt::BottomToolBarArea, new ToolBar(this));
 
261
}
 
262
 
 
263
void KaduMainWindow::addLeftToolbar()
 
264
{
 
265
        addToolBar(Qt::LeftToolBarArea, new ToolBar(this));
 
266
}
 
267
 
 
268
void KaduMainWindow::addRightToolbar()
 
269
{
 
270
        addToolBar(Qt::RightToolBarArea, new ToolBar(this));
 
271
}
 
272
 
 
273
void KaduMainWindow::actionAdded(KaduAction *action)
 
274
{
 
275
        if (userBox())
 
276
                connect(userBox(), SIGNAL(userListChanged()), action, SLOT(checkState()));
 
277
}