0
|
1 |
/****************************************************************************
|
|
2 |
**
|
|
3 |
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
4 |
** All rights reserved.
|
|
5 |
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
6 |
**
|
|
7 |
** This file is part of the demonstration applications of the Qt Toolkit.
|
|
8 |
**
|
|
9 |
** $QT_BEGIN_LICENSE:LGPL$
|
|
10 |
** No Commercial Usage
|
|
11 |
** This file contains pre-release code and may not be distributed.
|
|
12 |
** You may use this file in accordance with the terms and conditions
|
|
13 |
** contained in the Technology Preview License Agreement accompanying
|
|
14 |
** this package.
|
|
15 |
**
|
|
16 |
** GNU Lesser General Public License Usage
|
|
17 |
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
18 |
** General Public License version 2.1 as published by the Free Software
|
|
19 |
** Foundation and appearing in the file LICENSE.LGPL included in the
|
|
20 |
** packaging of this file. Please review the following information to
|
|
21 |
** ensure the GNU Lesser General Public License version 2.1 requirements
|
|
22 |
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
23 |
**
|
|
24 |
** In addition, as a special exception, Nokia gives you certain additional
|
|
25 |
** rights. These rights are described in the Nokia Qt LGPL Exception
|
|
26 |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
27 |
**
|
|
28 |
** If you have questions regarding the use of this file, please contact
|
|
29 |
** Nokia at qt-info@nokia.com.
|
|
30 |
**
|
|
31 |
**
|
|
32 |
**
|
|
33 |
**
|
|
34 |
**
|
|
35 |
**
|
|
36 |
**
|
|
37 |
**
|
|
38 |
** $QT_END_LICENSE$
|
|
39 |
**
|
|
40 |
****************************************************************************/
|
|
41 |
|
|
42 |
#include "mainwindow.h"
|
|
43 |
#include "colorswatch.h"
|
|
44 |
#include "toolbar.h"
|
|
45 |
|
|
46 |
#include <QAction>
|
|
47 |
#include <QLayout>
|
|
48 |
#include <QMenu>
|
|
49 |
#include <QMenuBar>
|
|
50 |
#include <QStatusBar>
|
|
51 |
#include <QTextEdit>
|
|
52 |
#include <QFile>
|
|
53 |
#include <QDataStream>
|
|
54 |
#include <QFileDialog>
|
|
55 |
#include <QMessageBox>
|
|
56 |
#include <QSignalMapper>
|
|
57 |
#include <QApplication>
|
|
58 |
#include <QPainter>
|
|
59 |
#include <QMouseEvent>
|
|
60 |
#include <QLineEdit>
|
|
61 |
#include <QComboBox>
|
|
62 |
#include <QLabel>
|
|
63 |
#include <QPushButton>
|
|
64 |
#include <qdebug.h>
|
|
65 |
|
|
66 |
static const char * const message =
|
|
67 |
"<p><b>Qt Main Window Demo</b></p>"
|
|
68 |
|
|
69 |
"<p>This is a demonstration of the QMainWindow, QToolBar and "
|
|
70 |
"QDockWidget classes.</p>"
|
|
71 |
|
|
72 |
"<p>The tool bar and dock widgets can be dragged around and rearranged "
|
|
73 |
"using the mouse or via the menu.</p>"
|
|
74 |
|
|
75 |
"<p>Each dock widget contains a colored frame and a context "
|
|
76 |
"(right-click) menu.</p>"
|
|
77 |
|
|
78 |
#ifdef Q_WS_MAC
|
|
79 |
"<p>On Mac OS X, the \"Black\" dock widget has been created as a "
|
|
80 |
"<em>Drawer</em>, which is a special kind of QDockWidget.</p>"
|
|
81 |
#endif
|
|
82 |
;
|
|
83 |
|
|
84 |
MainWindow::MainWindow(const QMap<QString, QSize> &customSizeHints,
|
|
85 |
QWidget *parent, Qt::WindowFlags flags)
|
|
86 |
: QMainWindow(parent, flags)
|
|
87 |
{
|
|
88 |
setObjectName("MainWindow");
|
|
89 |
setWindowTitle("Qt Main Window Demo");
|
|
90 |
|
|
91 |
center = new QTextEdit(this);
|
|
92 |
center->setReadOnly(true);
|
|
93 |
center->setMinimumSize(400, 205);
|
|
94 |
setCentralWidget(center);
|
|
95 |
|
|
96 |
setupToolBar();
|
|
97 |
setupMenuBar();
|
|
98 |
setupDockWidgets(customSizeHints);
|
|
99 |
|
|
100 |
statusBar()->showMessage(tr("Status Bar"));
|
|
101 |
}
|
|
102 |
|
|
103 |
void MainWindow::actionTriggered(QAction *action)
|
|
104 |
{
|
|
105 |
qDebug("action '%s' triggered", action->text().toLocal8Bit().data());
|
|
106 |
}
|
|
107 |
|
|
108 |
void MainWindow::setupToolBar()
|
|
109 |
{
|
|
110 |
for (int i = 0; i < 3; ++i) {
|
|
111 |
ToolBar *tb = new ToolBar(QString::fromLatin1("Tool Bar %1").arg(i + 1), this);
|
|
112 |
toolBars.append(tb);
|
|
113 |
addToolBar(tb);
|
|
114 |
}
|
|
115 |
}
|
|
116 |
|
|
117 |
void MainWindow::setupMenuBar()
|
|
118 |
{
|
|
119 |
QMenu *menu = menuBar()->addMenu(tr("&File"));
|
|
120 |
|
|
121 |
QAction *action = menu->addAction(tr("Save layout..."));
|
|
122 |
connect(action, SIGNAL(triggered()), this, SLOT(saveLayout()));
|
|
123 |
|
|
124 |
action = menu->addAction(tr("Load layout..."));
|
|
125 |
connect(action, SIGNAL(triggered()), this, SLOT(loadLayout()));
|
|
126 |
|
|
127 |
action = menu->addAction(tr("Switch layout direction"));
|
|
128 |
connect(action, SIGNAL(triggered()), this, SLOT(switchLayoutDirection()));
|
|
129 |
|
|
130 |
menu->addSeparator();
|
|
131 |
|
|
132 |
menu->addAction(tr("&Quit"), this, SLOT(close()));
|
|
133 |
|
|
134 |
mainWindowMenu = menuBar()->addMenu(tr("Main window"));
|
|
135 |
|
|
136 |
action = mainWindowMenu->addAction(tr("Animated docks"));
|
|
137 |
action->setCheckable(true);
|
|
138 |
action->setChecked(dockOptions() & AnimatedDocks);
|
|
139 |
connect(action, SIGNAL(toggled(bool)), this, SLOT(setDockOptions()));
|
|
140 |
|
|
141 |
action = mainWindowMenu->addAction(tr("Allow nested docks"));
|
|
142 |
action->setCheckable(true);
|
|
143 |
action->setChecked(dockOptions() & AllowNestedDocks);
|
|
144 |
connect(action, SIGNAL(toggled(bool)), this, SLOT(setDockOptions()));
|
|
145 |
|
|
146 |
action = mainWindowMenu->addAction(tr("Allow tabbed docks"));
|
|
147 |
action->setCheckable(true);
|
|
148 |
action->setChecked(dockOptions() & AllowTabbedDocks);
|
|
149 |
connect(action, SIGNAL(toggled(bool)), this, SLOT(setDockOptions()));
|
|
150 |
|
|
151 |
action = mainWindowMenu->addAction(tr("Force tabbed docks"));
|
|
152 |
action->setCheckable(true);
|
|
153 |
action->setChecked(dockOptions() & ForceTabbedDocks);
|
|
154 |
connect(action, SIGNAL(toggled(bool)), this, SLOT(setDockOptions()));
|
|
155 |
|
|
156 |
action = mainWindowMenu->addAction(tr("Vertical tabs"));
|
|
157 |
action->setCheckable(true);
|
|
158 |
action->setChecked(dockOptions() & VerticalTabs);
|
|
159 |
connect(action, SIGNAL(toggled(bool)), this, SLOT(setDockOptions()));
|
|
160 |
|
|
161 |
QMenu *toolBarMenu = menuBar()->addMenu(tr("Tool bars"));
|
|
162 |
for (int i = 0; i < toolBars.count(); ++i)
|
|
163 |
toolBarMenu->addMenu(toolBars.at(i)->menu);
|
|
164 |
|
|
165 |
dockWidgetMenu = menuBar()->addMenu(tr("&Dock Widgets"));
|
|
166 |
}
|
|
167 |
|
|
168 |
void MainWindow::setDockOptions()
|
|
169 |
{
|
|
170 |
DockOptions opts;
|
|
171 |
QList<QAction*> actions = mainWindowMenu->actions();
|
|
172 |
|
|
173 |
if (actions.at(0)->isChecked())
|
|
174 |
opts |= AnimatedDocks;
|
|
175 |
if (actions.at(1)->isChecked())
|
|
176 |
opts |= AllowNestedDocks;
|
|
177 |
if (actions.at(2)->isChecked())
|
|
178 |
opts |= AllowTabbedDocks;
|
|
179 |
if (actions.at(3)->isChecked())
|
|
180 |
opts |= ForceTabbedDocks;
|
|
181 |
if (actions.at(4)->isChecked())
|
|
182 |
opts |= VerticalTabs;
|
|
183 |
|
|
184 |
QMainWindow::setDockOptions(opts);
|
|
185 |
}
|
|
186 |
|
|
187 |
void MainWindow::saveLayout()
|
|
188 |
{
|
|
189 |
QString fileName
|
|
190 |
= QFileDialog::getSaveFileName(this, tr("Save layout"));
|
|
191 |
if (fileName.isEmpty())
|
|
192 |
return;
|
|
193 |
QFile file(fileName);
|
|
194 |
if (!file.open(QFile::WriteOnly)) {
|
|
195 |
QString msg = tr("Failed to open %1\n%2")
|
|
196 |
.arg(fileName)
|
|
197 |
.arg(file.errorString());
|
|
198 |
QMessageBox::warning(this, tr("Error"), msg);
|
|
199 |
return;
|
|
200 |
}
|
|
201 |
|
|
202 |
QByteArray geo_data = saveGeometry();
|
|
203 |
QByteArray layout_data = saveState();
|
|
204 |
|
|
205 |
bool ok = file.putChar((uchar)geo_data.size());
|
|
206 |
if (ok)
|
|
207 |
ok = file.write(geo_data) == geo_data.size();
|
|
208 |
if (ok)
|
|
209 |
ok = file.write(layout_data) == layout_data.size();
|
|
210 |
|
|
211 |
if (!ok) {
|
|
212 |
QString msg = tr("Error writing to %1\n%2")
|
|
213 |
.arg(fileName)
|
|
214 |
.arg(file.errorString());
|
|
215 |
QMessageBox::warning(this, tr("Error"), msg);
|
|
216 |
return;
|
|
217 |
}
|
|
218 |
}
|
|
219 |
|
|
220 |
void MainWindow::loadLayout()
|
|
221 |
{
|
|
222 |
QString fileName
|
|
223 |
= QFileDialog::getOpenFileName(this, tr("Load layout"));
|
|
224 |
if (fileName.isEmpty())
|
|
225 |
return;
|
|
226 |
QFile file(fileName);
|
|
227 |
if (!file.open(QFile::ReadOnly)) {
|
|
228 |
QString msg = tr("Failed to open %1\n%2")
|
|
229 |
.arg(fileName)
|
|
230 |
.arg(file.errorString());
|
|
231 |
QMessageBox::warning(this, tr("Error"), msg);
|
|
232 |
return;
|
|
233 |
}
|
|
234 |
|
|
235 |
uchar geo_size;
|
|
236 |
QByteArray geo_data;
|
|
237 |
QByteArray layout_data;
|
|
238 |
|
|
239 |
bool ok = file.getChar((char*)&geo_size);
|
|
240 |
if (ok) {
|
|
241 |
geo_data = file.read(geo_size);
|
|
242 |
ok = geo_data.size() == geo_size;
|
|
243 |
}
|
|
244 |
if (ok) {
|
|
245 |
layout_data = file.readAll();
|
|
246 |
ok = layout_data.size() > 0;
|
|
247 |
}
|
|
248 |
|
|
249 |
if (ok)
|
|
250 |
ok = restoreGeometry(geo_data);
|
|
251 |
if (ok)
|
|
252 |
ok = restoreState(layout_data);
|
|
253 |
|
|
254 |
if (!ok) {
|
|
255 |
QString msg = tr("Error reading %1")
|
|
256 |
.arg(fileName);
|
|
257 |
QMessageBox::warning(this, tr("Error"), msg);
|
|
258 |
return;
|
|
259 |
}
|
|
260 |
}
|
|
261 |
|
|
262 |
QAction *addAction(QMenu *menu, const QString &text, QActionGroup *group, QSignalMapper *mapper,
|
|
263 |
int id)
|
|
264 |
{
|
|
265 |
bool first = group->actions().isEmpty();
|
|
266 |
QAction *result = menu->addAction(text);
|
|
267 |
result->setCheckable(true);
|
|
268 |
result->setChecked(first);
|
|
269 |
group->addAction(result);
|
|
270 |
QObject::connect(result, SIGNAL(triggered()), mapper, SLOT(map()));
|
|
271 |
mapper->setMapping(result, id);
|
|
272 |
return result;
|
|
273 |
}
|
|
274 |
|
|
275 |
void MainWindow::setupDockWidgets(const QMap<QString, QSize> &customSizeHints)
|
|
276 |
{
|
|
277 |
mapper = new QSignalMapper(this);
|
|
278 |
connect(mapper, SIGNAL(mapped(int)), this, SLOT(setCorner(int)));
|
|
279 |
|
|
280 |
QMenu *corner_menu = dockWidgetMenu->addMenu(tr("Top left corner"));
|
|
281 |
QActionGroup *group = new QActionGroup(this);
|
|
282 |
group->setExclusive(true);
|
|
283 |
::addAction(corner_menu, tr("Top dock area"), group, mapper, 0);
|
|
284 |
::addAction(corner_menu, tr("Left dock area"), group, mapper, 1);
|
|
285 |
|
|
286 |
corner_menu = dockWidgetMenu->addMenu(tr("Top right corner"));
|
|
287 |
group = new QActionGroup(this);
|
|
288 |
group->setExclusive(true);
|
|
289 |
::addAction(corner_menu, tr("Top dock area"), group, mapper, 2);
|
|
290 |
::addAction(corner_menu, tr("Right dock area"), group, mapper, 3);
|
|
291 |
|
|
292 |
corner_menu = dockWidgetMenu->addMenu(tr("Bottom left corner"));
|
|
293 |
group = new QActionGroup(this);
|
|
294 |
group->setExclusive(true);
|
|
295 |
::addAction(corner_menu, tr("Bottom dock area"), group, mapper, 4);
|
|
296 |
::addAction(corner_menu, tr("Left dock area"), group, mapper, 5);
|
|
297 |
|
|
298 |
corner_menu = dockWidgetMenu->addMenu(tr("Bottom right corner"));
|
|
299 |
group = new QActionGroup(this);
|
|
300 |
group->setExclusive(true);
|
|
301 |
::addAction(corner_menu, tr("Bottom dock area"), group, mapper, 6);
|
|
302 |
::addAction(corner_menu, tr("Right dock area"), group, mapper, 7);
|
|
303 |
|
|
304 |
dockWidgetMenu->addSeparator();
|
|
305 |
|
|
306 |
static const struct Set {
|
|
307 |
const char * name;
|
|
308 |
uint flags;
|
|
309 |
Qt::DockWidgetArea area;
|
|
310 |
} sets [] = {
|
|
311 |
#ifndef Q_WS_MAC
|
|
312 |
{ "Black", 0, Qt::LeftDockWidgetArea },
|
|
313 |
#else
|
|
314 |
{ "Black", Qt::Drawer, Qt::LeftDockWidgetArea },
|
|
315 |
#endif
|
|
316 |
{ "White", 0, Qt::RightDockWidgetArea },
|
|
317 |
{ "Red", 0, Qt::TopDockWidgetArea },
|
|
318 |
{ "Green", 0, Qt::TopDockWidgetArea },
|
|
319 |
{ "Blue", 0, Qt::BottomDockWidgetArea },
|
|
320 |
{ "Yellow", 0, Qt::BottomDockWidgetArea }
|
|
321 |
};
|
|
322 |
const int setCount = sizeof(sets) / sizeof(Set);
|
|
323 |
|
|
324 |
for (int i = 0; i < setCount; ++i) {
|
|
325 |
ColorSwatch *swatch = new ColorSwatch(tr(sets[i].name), this, Qt::WindowFlags(sets[i].flags));
|
|
326 |
if (i%2)
|
|
327 |
swatch->setWindowIcon(QIcon(QPixmap(":/res/qt.png")));
|
|
328 |
if (qstrcmp(sets[i].name, "Blue") == 0) {
|
|
329 |
BlueTitleBar *titlebar = new BlueTitleBar(swatch);
|
|
330 |
swatch->setTitleBarWidget(titlebar);
|
|
331 |
connect(swatch, SIGNAL(topLevelChanged(bool)), titlebar, SLOT(updateMask()));
|
|
332 |
connect(swatch, SIGNAL(featuresChanged(QDockWidget::DockWidgetFeatures)), titlebar, SLOT(updateMask()));
|
|
333 |
|
|
334 |
#ifdef Q_WS_QWS
|
|
335 |
QPalette pal = palette();
|
|
336 |
pal.setBrush(backgroundRole(), QColor(0,0,0,0));
|
|
337 |
swatch->setPalette(pal);
|
|
338 |
#endif
|
|
339 |
}
|
|
340 |
|
|
341 |
QString name = QString::fromLatin1(sets[i].name);
|
|
342 |
if (customSizeHints.contains(name))
|
|
343 |
swatch->setCustomSizeHint(customSizeHints.value(name));
|
|
344 |
|
|
345 |
addDockWidget(sets[i].area, swatch);
|
|
346 |
dockWidgetMenu->addMenu(swatch->menu);
|
|
347 |
}
|
|
348 |
|
|
349 |
createDockWidgetAction = new QAction(tr("Add dock widget..."), this);
|
|
350 |
connect(createDockWidgetAction, SIGNAL(triggered()), this, SLOT(createDockWidget()));
|
|
351 |
destroyDockWidgetMenu = new QMenu(tr("Destroy dock widget"), this);
|
|
352 |
destroyDockWidgetMenu->setEnabled(false);
|
|
353 |
connect(destroyDockWidgetMenu, SIGNAL(triggered(QAction*)), this, SLOT(destroyDockWidget(QAction*)));
|
|
354 |
|
|
355 |
dockWidgetMenu->addSeparator();
|
|
356 |
dockWidgetMenu->addAction(createDockWidgetAction);
|
|
357 |
dockWidgetMenu->addMenu(destroyDockWidgetMenu);
|
|
358 |
}
|
|
359 |
|
|
360 |
void MainWindow::setCorner(int id)
|
|
361 |
{
|
|
362 |
switch (id) {
|
|
363 |
case 0:
|
|
364 |
QMainWindow::setCorner(Qt::TopLeftCorner, Qt::TopDockWidgetArea);
|
|
365 |
break;
|
|
366 |
case 1:
|
|
367 |
QMainWindow::setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
|
|
368 |
break;
|
|
369 |
case 2:
|
|
370 |
QMainWindow::setCorner(Qt::TopRightCorner, Qt::TopDockWidgetArea);
|
|
371 |
break;
|
|
372 |
case 3:
|
|
373 |
QMainWindow::setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
|
|
374 |
break;
|
|
375 |
case 4:
|
|
376 |
QMainWindow::setCorner(Qt::BottomLeftCorner, Qt::BottomDockWidgetArea);
|
|
377 |
break;
|
|
378 |
case 5:
|
|
379 |
QMainWindow::setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
|
|
380 |
break;
|
|
381 |
case 6:
|
|
382 |
QMainWindow::setCorner(Qt::BottomRightCorner, Qt::BottomDockWidgetArea);
|
|
383 |
break;
|
|
384 |
case 7:
|
|
385 |
QMainWindow::setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
|
|
386 |
break;
|
|
387 |
}
|
|
388 |
}
|
|
389 |
|
|
390 |
void MainWindow::showEvent(QShowEvent *event)
|
|
391 |
{
|
|
392 |
QMainWindow::showEvent(event);
|
|
393 |
}
|
|
394 |
|
|
395 |
void MainWindow::switchLayoutDirection()
|
|
396 |
{
|
|
397 |
if (layoutDirection() == Qt::LeftToRight)
|
|
398 |
qApp->setLayoutDirection(Qt::RightToLeft);
|
|
399 |
else
|
|
400 |
qApp->setLayoutDirection(Qt::LeftToRight);
|
|
401 |
}
|
|
402 |
|
|
403 |
class CreateDockWidgetDialog : public QDialog
|
|
404 |
{
|
|
405 |
public:
|
|
406 |
CreateDockWidgetDialog(QWidget *parent = 0);
|
|
407 |
|
|
408 |
QString objectName() const;
|
|
409 |
Qt::DockWidgetArea location() const;
|
|
410 |
|
|
411 |
private:
|
|
412 |
QLineEdit *m_objectName;
|
|
413 |
QComboBox *m_location;
|
|
414 |
};
|
|
415 |
|
|
416 |
CreateDockWidgetDialog::CreateDockWidgetDialog(QWidget *parent)
|
|
417 |
: QDialog(parent)
|
|
418 |
{
|
|
419 |
QGridLayout *layout = new QGridLayout(this);
|
|
420 |
|
|
421 |
layout->addWidget(new QLabel(tr("Object name:")), 0, 0);
|
|
422 |
m_objectName = new QLineEdit;
|
|
423 |
layout->addWidget(m_objectName, 0, 1);
|
|
424 |
|
|
425 |
layout->addWidget(new QLabel(tr("Location:")), 1, 0);
|
|
426 |
m_location = new QComboBox;
|
|
427 |
m_location->setEditable(false);
|
|
428 |
m_location->addItem(tr("Top"));
|
|
429 |
m_location->addItem(tr("Left"));
|
|
430 |
m_location->addItem(tr("Right"));
|
|
431 |
m_location->addItem(tr("Bottom"));
|
|
432 |
m_location->addItem(tr("Restore"));
|
|
433 |
layout->addWidget(m_location, 1, 1);
|
|
434 |
|
|
435 |
QHBoxLayout *buttonLayout = new QHBoxLayout;
|
|
436 |
layout->addLayout(buttonLayout, 2, 0, 1, 2);
|
|
437 |
buttonLayout->addStretch();
|
|
438 |
|
|
439 |
QPushButton *cancelButton = new QPushButton(tr("Cancel"));
|
|
440 |
connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
|
|
441 |
buttonLayout->addWidget(cancelButton);
|
|
442 |
QPushButton *okButton = new QPushButton(tr("Ok"));
|
|
443 |
connect(okButton, SIGNAL(clicked()), this, SLOT(accept()));
|
|
444 |
buttonLayout->addWidget(okButton);
|
|
445 |
|
|
446 |
okButton->setDefault(true);
|
|
447 |
}
|
|
448 |
|
|
449 |
QString CreateDockWidgetDialog::objectName() const
|
|
450 |
{
|
|
451 |
return m_objectName->text();
|
|
452 |
}
|
|
453 |
|
|
454 |
Qt::DockWidgetArea CreateDockWidgetDialog::location() const
|
|
455 |
{
|
|
456 |
switch (m_location->currentIndex()) {
|
|
457 |
case 0: return Qt::TopDockWidgetArea;
|
|
458 |
case 1: return Qt::LeftDockWidgetArea;
|
|
459 |
case 2: return Qt::RightDockWidgetArea;
|
|
460 |
case 3: return Qt::BottomDockWidgetArea;
|
|
461 |
default:
|
|
462 |
break;
|
|
463 |
}
|
|
464 |
return Qt::NoDockWidgetArea;
|
|
465 |
}
|
|
466 |
|
|
467 |
void MainWindow::createDockWidget()
|
|
468 |
{
|
|
469 |
CreateDockWidgetDialog dialog(this);
|
|
470 |
int ret = dialog.exec();
|
|
471 |
if (ret == QDialog::Rejected)
|
|
472 |
return;
|
|
473 |
|
|
474 |
QDockWidget *dw = new QDockWidget;
|
|
475 |
dw->setObjectName(dialog.objectName());
|
|
476 |
dw->setWindowTitle(dialog.objectName());
|
|
477 |
dw->setWidget(new QTextEdit);
|
|
478 |
|
|
479 |
Qt::DockWidgetArea area = dialog.location();
|
|
480 |
switch (area) {
|
|
481 |
case Qt::LeftDockWidgetArea:
|
|
482 |
case Qt::RightDockWidgetArea:
|
|
483 |
case Qt::TopDockWidgetArea:
|
|
484 |
case Qt::BottomDockWidgetArea:
|
|
485 |
addDockWidget(area, dw);
|
|
486 |
break;
|
|
487 |
default:
|
|
488 |
if (!restoreDockWidget(dw)) {
|
|
489 |
QMessageBox::warning(this, QString(), tr("Failed to restore dock widget"));
|
|
490 |
delete dw;
|
|
491 |
return;
|
|
492 |
}
|
|
493 |
break;
|
|
494 |
}
|
|
495 |
|
|
496 |
extraDockWidgets.append(dw);
|
|
497 |
destroyDockWidgetMenu->setEnabled(true);
|
|
498 |
destroyDockWidgetMenu->addAction(new QAction(dialog.objectName(), this));
|
|
499 |
}
|
|
500 |
|
|
501 |
void MainWindow::destroyDockWidget(QAction *action)
|
|
502 |
{
|
|
503 |
int index = destroyDockWidgetMenu->actions().indexOf(action);
|
|
504 |
delete extraDockWidgets.takeAt(index);
|
|
505 |
destroyDockWidgetMenu->removeAction(action);
|
|
506 |
action->deleteLater();
|
|
507 |
|
|
508 |
if (destroyDockWidgetMenu->isEmpty())
|
|
509 |
destroyDockWidgetMenu->setEnabled(false);
|
|
510 |
}
|