feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Internally use a fancy mainwindow in form editor.

Browse Source
This commit is contained in:
con
2009-08-10 16:24:29 +02:00
parent 6d12f9a5a7
commit ba219e2a77
5 changed files with 95 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/libs/utils/fancymainwindow.cpp
View File

@@ -174,7 +174,8 @@ QHash<QString, QVariant> FancyMainWindow::saveSettings() const
void FancyMainWindow::restoreSettings(const QHash<QString, QVariant> &settings) void FancyMainWindow::restoreSettings(const QHash<QString, QVariant> &settings)
{ {
QByteArray ba = settings.value("State", QByteArray()).toByteArray(); QByteArray ba = settings.value("State", QByteArray()).toByteArray();
restoreState(ba); if (!ba.isEmpty())
restoreState(ba);
m_locked = settings.value("Locked", true).toBool(); m_locked = settings.value("Locked", true).toBool();
for (int i = 0; i < m_dockWidgetActiveState.count(); ++i) { for (int i = 0; i < m_dockWidgetActiveState.count(); ++i) {
m_dockWidgetActiveState[i] = settings.value(m_dockWidgets.at(i)->objectName(), false).toBool(); m_dockWidgetActiveState[i] = settings.value(m_dockWidgets.at(i)->objectName(), false).toBool();

225
src/plugins/designer/editorwidget.cpp
View File

@@ -37,9 +37,9 @@
#include <QtGui/QVBoxLayout> #include <QtGui/QVBoxLayout>
#include <QtGui/QTabWidget> #include <QtGui/QTabWidget>
using namespace Designer::Constants; static const char *editorWidgetStateKeyC = "editorWidgetState";
enum { ActionEditorTab, SignalSlotEditorTab }; using namespace Designer::Constants;
namespace Designer { namespace Designer {
namespace Internal { namespace Internal {
@@ -62,198 +62,113 @@ void SharedSubWindow::activate()
if (currentParent == this) if (currentParent == this)
return; return;
if (currentParent) {
QVBoxLayout *lt = qobject_cast<QVBoxLayout *>(currentParent->layout());
QTC_ASSERT(lt, return);
m_shared->setParent(0);
delete lt->takeAt(0);
}
m_layout->addWidget(m_shared); m_layout->addWidget(m_shared);
m_layout->invalidate(); m_shared->show();
} }
SharedSubWindow::~SharedSubWindow() SharedSubWindow::~SharedSubWindow()
{ {
// Do not destroy the shared sub window if we currently own it // Do not destroy the shared sub window if we currently own it
if (m_layout->count()) { if (m_shared->parent() == this) {
m_shared->hide();
m_shared->setParent(0); m_shared->setParent(0);
delete m_layout->takeAt(0);
} }
} }
// ---------- Global EditorState
Q_GLOBAL_STATIC(EditorWidgetState, editorWidgetState)
enum { Version = 1 };
// Simple conversion of an int list to QVariantList, size as leading element
static void intToVariantList(const QList<int> &il, QVariantList& vl)
{
const int size = il.size();
vl.push_back(size);
if (size != 0) {
const QList<int>::const_iterator cend = il.constEnd();
for (QList<int>::const_iterator it = il.constBegin(); it != cend; ++it)
vl.push_back(QVariant(*it));
}
}
// Simple conversion of a QVariantList portion saved by the above function to int list
bool variantListToIntList(const QVariantList& vl, int &index, QList<int> &list)
{
list.clear();
if (index >= vl.size())
return false;
const int size = vl.at(index++).toInt();
const int end = index + size;
if (end > vl.size())
return false;
if (size != 0) {
for ( ; index < end; index++)
list.push_back(vl.at(index).toInt());
}
return true;
}
// ------------------ EditorWidgetState
QVariant EditorWidgetState::toVariant() const
{
QVariantList rc;
rc.push_back(Version);
intToVariantList(horizontalSizes, rc);
intToVariantList(centerVerticalSizes, rc);
intToVariantList(rightVerticalSizes, rc);
return QVariant(rc);
}
bool EditorWidgetState::fromVariant(const QVariant &v)
{
// Restore state. The weird thing is that QSettings might return
// a QStringList although it was saved as QVariantList<int>.
if (v.type() != QVariant::List && v.type() != QVariant::StringList)
return false;
const QVariantList vl = v.toList();
if (vl.empty())
return false;
int index = 0;
const QVariant &versionV = vl.at(index++);
if (versionV.type() != QVariant::Int && versionV.type() != QVariant::String)
return false;
if (versionV.toInt() > Version)
return false;
return variantListToIntList(vl, index, horizontalSizes) &&
variantListToIntList(vl, index, centerVerticalSizes) &&
variantListToIntList(vl, index, rightVerticalSizes);
}
// ---------- EditorWidget // ---------- EditorWidget
EditorWidget::EditorWidget(QWidget *formWindow) :
Core::MiniSplitter(Qt::Horizontal), QHash<QString, QVariant> EditorWidget::m_globalState = QHash<QString, QVariant>();
m_centerVertSplitter(new Core::MiniSplitter(Qt::Vertical)),
m_bottomTab(0), EditorWidget::EditorWidget(QWidget *formWindow)
m_rightVertSplitter(new Core::MiniSplitter(Qt::Vertical)) : m_mainWindow(new Core::Utils::FancyMainWindow)
{ {
QVBoxLayout *layout = new QVBoxLayout;
layout->setMargin(0);
layout->setSpacing(0);
setLayout(layout);
layout->addWidget(m_mainWindow);
m_mainWindow->setCentralWidget(formWindow);
m_mainWindow->setDocumentMode(true);
m_mainWindow->setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::South);
m_mainWindow->setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
m_mainWindow->setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
// Get shared sub windows from Form Editor // Get shared sub windows from Form Editor
FormEditorW *few = FormEditorW::instance(); FormEditorW *few = FormEditorW::instance();
QWidget * const*subs = few->designerSubWindows(); QWidget * const*subs = few->designerSubWindows();
// Create shared sub windows // Create shared sub windows
for (int i=0; i < DesignerSubWindowCount; i++) for (int i=0; i < DesignerSubWindowCount; i++) {
m_designerSubWindows[i] = new SharedSubWindow(subs[i]); m_designerSubWindows[i] = new SharedSubWindow(subs[i]);
// Create splitter m_designerSubWindows[i]->setWindowTitle(subs[i]->windowTitle());
addWidget(m_designerSubWindows[WidgetBoxSubWindow]); m_designerDockWidgets[i] = m_mainWindow->addDockForWidget(m_designerSubWindows[i]);
}
// center
m_centerVertSplitter->addWidget(formWindow);
m_bottomTab = new QTabWidget;
m_bottomTab->setTabPosition(QTabWidget::South);
m_bottomTab->setDocumentMode(true);
m_bottomTab->addTab(m_designerSubWindows[ActionEditorSubWindow], tr("Action editor"));
m_bottomTab->addTab(m_designerSubWindows[SignalSlotEditorSubWindow], tr("Signals and slots editor"));
m_centerVertSplitter->addWidget(m_bottomTab);
addWidget(m_centerVertSplitter);
m_rightVertSplitter->addWidget(m_designerSubWindows[ObjectInspectorSubWindow]);
m_rightVertSplitter->addWidget(m_designerSubWindows[PropertyEditorSubWindow]);
addWidget(m_rightVertSplitter);
} }
void EditorWidget::setInitialSizes() void EditorWidget::setDefaultLayout()
{ {
QList<int> sizes; m_mainWindow->setTrackingEnabled(false);
// center vertical. Either the tab containing signal slot editor/ QList<QDockWidget *> dockWidgets = m_mainWindow->dockWidgets();
// action editor or the action editor itself foreach (QDockWidget *dockWidget, dockWidgets)
const QWidget *bottomWidget = m_bottomTab; m_mainWindow->removeDockWidget(dockWidget);
if (!bottomWidget)
bottomWidget = m_designerSubWindows[ActionEditorSubWindow]; m_mainWindow->addDockWidget(Qt::LeftDockWidgetArea, m_designerDockWidgets[WidgetBoxSubWindow]);
const int tabHeight = bottomWidget->sizeHint().height(); m_mainWindow->addDockWidget(Qt::RightDockWidgetArea, m_designerDockWidgets[ObjectInspectorSubWindow]);
sizes.push_back(height() - handleWidth() - tabHeight); m_mainWindow->addDockWidget(Qt::RightDockWidgetArea, m_designerDockWidgets[PropertyEditorSubWindow]);
sizes.push_back( tabHeight); m_mainWindow->addDockWidget(Qt::BottomDockWidgetArea, m_designerDockWidgets[ActionEditorSubWindow]);
m_centerVertSplitter->setSizes(sizes); m_mainWindow->addDockWidget(Qt::BottomDockWidgetArea, m_designerDockWidgets[SignalSlotEditorSubWindow]);
// right vert
sizes.clear(); m_mainWindow->tabifyDockWidget(m_designerDockWidgets[ActionEditorSubWindow],
sizes.push_back(height() /2 - (handleWidth() / 2)); m_designerDockWidgets[SignalSlotEditorSubWindow]);
sizes.push_back(height() / 2 - (handleWidth() / 2));
m_rightVertSplitter->setSizes(sizes); foreach (QDockWidget *dockWidget, dockWidgets) {
// horiz sizes dockWidget->show();
sizes.clear(); }
const int wboxWidth = m_designerSubWindows[WidgetBoxSubWindow]->sizeHint().width();
const int vSplitterWidth = m_rightVertSplitter->sizeHint().width(); m_mainWindow->setTrackingEnabled(true);
sizes.push_back(wboxWidth); m_globalState = m_mainWindow->saveSettings();
sizes.push_back(width() - 2 * handleWidth() - wboxWidth - vSplitterWidth);
sizes.push_back(vSplitterWidth);
setSizes(sizes);
} }
void EditorWidget::activate() void EditorWidget::activate()
{ {
for (int i=0; i < DesignerSubWindowCount; i++) for (int i=0; i < DesignerSubWindowCount; i++)
m_designerSubWindows[i]->activate(); m_designerSubWindows[i]->activate();
if (!restore(*editorWidgetState()))
setInitialSizes(); if (!m_globalState.isEmpty())
m_mainWindow->restoreSettings(m_globalState);
else
setDefaultLayout();
} }
bool EditorWidget::event(QEvent * e) void EditorWidget::hideEvent(QHideEvent *)
{ {
if (e->type() == QEvent::Hide) m_globalState = m_mainWindow->saveSettings();
*editorWidgetState() = save();
return QSplitter::event(e);
} }
EditorWidgetState EditorWidget::save() const void EditorWidget::saveState(QSettings *settings)
{ {
EditorWidgetState rc; settings->beginGroup(editorWidgetStateKeyC);
rc.horizontalSizes = sizes(); QHashIterator<QString, QVariant> it(m_globalState);
rc.centerVerticalSizes = m_centerVertSplitter->sizes(); while (it.hasNext()) {
rc.rightVerticalSizes = m_rightVertSplitter->sizes(); it.next();
return rc; settings->setValue(it.key(), it.value());
}
settings->endGroup();
} }
bool EditorWidget::restore(const EditorWidgetState &s) void EditorWidget::restoreState(QSettings *settings)
{ {
if (s.horizontalSizes.size() != count() || m_globalState.clear();
s.centerVerticalSizes.size() != m_centerVertSplitter->count() || settings->beginGroup(editorWidgetStateKeyC);
s.rightVerticalSizes.size() != m_rightVertSplitter->count()) foreach (const QString &key, settings->childKeys()) {
return false; m_globalState.insert(key, settings->value(key));
m_centerVertSplitter->setSizes(s.centerVerticalSizes); }
m_rightVertSplitter->setSizes(s.rightVerticalSizes); settings->endGroup();
setSizes(s.horizontalSizes);
return true;
} }
void EditorWidget::toolChanged(int i) void EditorWidget::toolChanged(int i)
{ {
if (m_bottomTab) // if (m_bottomTab)
m_bottomTab->setCurrentIndex(i == EditModeSignalsSlotEditor ? SignalSlotEditorTab : ActionEditorTab); // m_bottomTab->setCurrentIndex(i == EditModeSignalsSlotEditor ? SignalSlotEditorTab : ActionEditorTab);
}
EditorWidgetState EditorWidget::state()
{
return *editorWidgetState();
}
void EditorWidget::setState(const EditorWidgetState& st)
{
*editorWidgetState() = st;
} }
} // namespace Internal } // namespace Internal

50
src/plugins/designer/editorwidget.h
View File

@@ -32,17 +32,17 @@
#include "designerconstants.h" #include "designerconstants.h"
#include <coreplugin/minisplitter.h> #include <utils/fancymainwindow.h>
#include <QtCore/QPointer> #include <QtCore/QPointer>
#include <QtCore/QList> #include <QtCore/QList>
#include <QtCore/QHash>
#include <QtCore/QVariant> #include <QtCore/QVariant>
#include <QtCore/QSettings>
#include <QtGui/QWidget> #include <QtGui/QWidget>
#include <QtGui/QVBoxLayout>
QT_BEGIN_NAMESPACE #include <QtGui/QDockWidget>
class QTabWidget; #include <QtGui/QHideEvent>
class QVBoxLayout;
QT_END_NAMESPACE
namespace Designer { namespace Designer {
namespace Internal { namespace Internal {
@@ -68,49 +68,33 @@ private:
QVBoxLayout *m_layout; QVBoxLayout *m_layout;
}; };
/** State of the editor window (splitter sizes)
* Shared as a global struct between the instances and stored
* in QSettings. */
struct EditorWidgetState
{
QVariant toVariant() const; // API to conveniently store in QSettings
bool fromVariant(const QVariant &v);
QList<int> horizontalSizes;
QList<int> centerVerticalSizes;
QList<int> rightVerticalSizes;
};
/* Form editor splitter used as editor window. Contains the shared designer /* Form editor splitter used as editor window. Contains the shared designer
* windows. */ * windows. */
class EditorWidget : public Core::MiniSplitter class EditorWidget : public QWidget
{ {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(EditorWidget) Q_DISABLE_COPY(EditorWidget)
public: public:
explicit EditorWidget(QWidget *formWindow); explicit EditorWidget(QWidget *formWindow);
virtual bool event(QEvent * e); void setDefaultLayout();
EditorWidgetState save() const; static void saveState(QSettings *settings);
bool restore(const EditorWidgetState &s); static void restoreState(QSettings *settings);
// Get/Set the shared splitter state of all editors of that type for
// settings
static EditorWidgetState state();
static void setState(const EditorWidgetState&st);
public slots: public slots:
void activate(); void activate();
void toolChanged(int); void toolChanged(int);
private: protected:
void setInitialSizes(); void hideEvent(QHideEvent * e);
private:
SharedSubWindow* m_designerSubWindows[Designer::Constants::DesignerSubWindowCount]; SharedSubWindow* m_designerSubWindows[Designer::Constants::DesignerSubWindowCount];
QSplitter *m_centerVertSplitter; QDockWidget *m_designerDockWidgets[Designer::Constants::DesignerSubWindowCount];
QTabWidget *m_bottomTab; Core::Utils::FancyMainWindow *m_mainWindow;
QSplitter *m_rightVertSplitter;
static QHash<QString, QVariant> m_globalState;
}; };
} // namespace Internal } // namespace Internal

16
src/plugins/designer/formeditorw.cpp
View File

@@ -80,7 +80,6 @@
#include <QtCore/QDebug> #include <QtCore/QDebug>
#include <QtCore/QSettings> #include <QtCore/QSettings>
static const char *editorWidgetStateKeyC = "editorWidgetState";
static const char *settingsGroup = "Designer"; static const char *settingsGroup = "Designer";
#ifdef Q_OS_MAC #ifdef Q_OS_MAC
@@ -522,20 +521,15 @@ Core::ActionContainer *FormEditorW::createPreviewStyleMenu(Core::ActionManager *
void FormEditorW::saveSettings(QSettings *s) void FormEditorW::saveSettings(QSettings *s)
{ {
s->beginGroup(settingsGroup); s->beginGroup(settingsGroup);
s->setValue(QLatin1String(editorWidgetStateKeyC), EditorWidget::state().toVariant()); EditorWidget::saveState(s);
s->endGroup(); s->endGroup();
} }
void FormEditorW::restoreSettings(const QSettings *s) void FormEditorW::restoreSettings(QSettings *s)
{ {
QString key = QLatin1String(settingsGroup) + QLatin1Char('/') s->beginGroup(settingsGroup);
+ QLatin1String(editorWidgetStateKeyC); EditorWidget::restoreState(s);
const QVariant ev = s->value(key); s->endGroup();
if (ev.type() != QVariant::Invalid) {
EditorWidgetState st;
if (st.fromVariant(ev))
EditorWidget::setState(st);
}
} }

2
src/plugins/designer/formeditorw.h
View File

@@ -130,7 +130,7 @@ private:
void fullInit(); void fullInit();
void saveSettings(QSettings *s); void saveSettings(QSettings *s);
void restoreSettings(const QSettings *s); void restoreSettings(QSettings *s);
void initDesignerSubWindows(); void initDesignerSubWindows();