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 Qt Designer 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 "formlayoutmenu_p.h"
|
|
43 |
#include "layoutinfo_p.h"
|
|
44 |
#include "qdesigner_command_p.h"
|
|
45 |
#include "qdesigner_utils_p.h"
|
|
46 |
#include "qdesigner_propertycommand_p.h"
|
|
47 |
#include "ui_formlayoutrowdialog.h"
|
|
48 |
|
|
49 |
#include <QtDesigner/QDesignerFormWindowInterface>
|
|
50 |
#include <QtDesigner/QDesignerFormEditorInterface>
|
|
51 |
#include <QtDesigner/QDesignerWidgetFactoryInterface>
|
|
52 |
#include <QtDesigner/QDesignerPropertySheetExtension>
|
|
53 |
#include <QtDesigner/QExtensionManager>
|
|
54 |
#include <QtDesigner/QDesignerWidgetDataBaseInterface>
|
|
55 |
#include <QtDesigner/QDesignerLanguageExtension>
|
|
56 |
|
|
57 |
#include <QtGui/QAction>
|
|
58 |
#include <QtGui/QWidget>
|
|
59 |
#include <QtGui/QFormLayout>
|
|
60 |
#include <QtGui/QUndoStack>
|
|
61 |
#include <QtGui/QDialog>
|
|
62 |
#include <QtGui/QPushButton>
|
|
63 |
#include <QtGui/QRegExpValidator>
|
|
64 |
|
|
65 |
#include <QtCore/QPair>
|
|
66 |
#include <QtCore/QCoreApplication>
|
|
67 |
#include <QtCore/QRegExp>
|
|
68 |
#include <QtCore/QMultiHash>
|
|
69 |
#include <QtCore/QDebug>
|
|
70 |
|
|
71 |
static const char *buddyPropertyC = "buddy";
|
|
72 |
static const char *fieldWidgetBaseClasses[] = {
|
|
73 |
"QLineEdit", "QComboBox", "QSpinBox", "QDoubleSpinBox", "QCheckBox",
|
|
74 |
"QDateEdit", "QTimeEdit", "QDateTimeEdit", "QDial", "QWidget"
|
|
75 |
};
|
|
76 |
|
|
77 |
QT_BEGIN_NAMESPACE
|
|
78 |
|
|
79 |
namespace qdesigner_internal {
|
|
80 |
|
|
81 |
// Struct that describes a row of controls (descriptive label and control) to
|
|
82 |
// be added to a form layout.
|
|
83 |
struct FormLayoutRow {
|
|
84 |
FormLayoutRow() : buddy(false) {}
|
|
85 |
|
|
86 |
QString labelName;
|
|
87 |
QString labelText;
|
|
88 |
QString fieldClassName;
|
|
89 |
QString fieldName;
|
|
90 |
bool buddy;
|
|
91 |
};
|
|
92 |
|
|
93 |
// A Dialog to edit a FormLayoutRow. Lets the user input a label text, label
|
|
94 |
// name, field widget type, field object name and buddy setting. As the
|
|
95 |
// user types the label text; the object names to be used for label and field
|
|
96 |
// are updated. It also checks the buddy setting depending on whether the
|
|
97 |
// label text contains a buddy marker.
|
|
98 |
class FormLayoutRowDialog : public QDialog {
|
|
99 |
Q_DISABLE_COPY(FormLayoutRowDialog)
|
|
100 |
Q_OBJECT
|
|
101 |
public:
|
|
102 |
explicit FormLayoutRowDialog(QDesignerFormEditorInterface *core,
|
|
103 |
QWidget *parent);
|
|
104 |
|
|
105 |
FormLayoutRow formLayoutRow() const;
|
|
106 |
|
|
107 |
bool buddy() const;
|
|
108 |
void setBuddy(bool);
|
|
109 |
|
|
110 |
// Accessors for form layout row numbers using 0..[n-1] convention
|
|
111 |
int row() const;
|
|
112 |
void setRow(int);
|
|
113 |
void setRowRange(int, int);
|
|
114 |
|
|
115 |
QString fieldClass() const;
|
|
116 |
QString labelText() const;
|
|
117 |
|
|
118 |
static QStringList fieldWidgetClasses(QDesignerFormEditorInterface *core);
|
|
119 |
|
|
120 |
private slots:
|
|
121 |
void labelTextEdited(const QString &text);
|
|
122 |
void labelNameEdited(const QString &text);
|
|
123 |
void fieldNameEdited(const QString &text);
|
|
124 |
void buddyClicked();
|
|
125 |
void fieldClassChanged(int);
|
|
126 |
|
|
127 |
private:
|
|
128 |
bool isValid() const;
|
|
129 |
void updateObjectNames(bool updateLabel, bool updateField);
|
|
130 |
void updateOkButton();
|
|
131 |
|
|
132 |
// Check for buddy marker in string
|
|
133 |
const QRegExp m_buddyMarkerRegexp;
|
|
134 |
|
|
135 |
Ui::FormLayoutRowDialog m_ui;
|
|
136 |
bool m_labelNameEdited;
|
|
137 |
bool m_fieldNameEdited;
|
|
138 |
bool m_buddyClicked;
|
|
139 |
};
|
|
140 |
|
|
141 |
FormLayoutRowDialog::FormLayoutRowDialog(QDesignerFormEditorInterface *core,
|
|
142 |
QWidget *parent) :
|
|
143 |
QDialog(parent),
|
|
144 |
m_buddyMarkerRegexp(QLatin1String("\\&[^&]")),
|
|
145 |
m_labelNameEdited(false),
|
|
146 |
m_fieldNameEdited(false),
|
|
147 |
m_buddyClicked(false)
|
|
148 |
{
|
|
149 |
Q_ASSERT(m_buddyMarkerRegexp.isValid());
|
|
150 |
|
|
151 |
setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
|
|
152 |
setModal(true);
|
|
153 |
m_ui.setupUi(this);
|
|
154 |
connect(m_ui.labelTextLineEdit, SIGNAL(textEdited(QString)), this, SLOT(labelTextEdited(QString)));
|
|
155 |
|
|
156 |
QRegExpValidator *nameValidator = new QRegExpValidator(QRegExp(QLatin1String("^[a-zA-Z0-9_]+$")), this);
|
|
157 |
Q_ASSERT(nameValidator->regExp().isValid());
|
|
158 |
|
|
159 |
m_ui.labelNameLineEdit->setValidator(nameValidator);
|
|
160 |
connect(m_ui.labelNameLineEdit, SIGNAL(textEdited(QString)),
|
|
161 |
this, SLOT(labelNameEdited(QString)));
|
|
162 |
|
|
163 |
m_ui.fieldNameLineEdit->setValidator(nameValidator);
|
|
164 |
connect(m_ui.fieldNameLineEdit, SIGNAL(textEdited(QString)),
|
|
165 |
this, SLOT(fieldNameEdited(QString)));
|
|
166 |
|
|
167 |
connect(m_ui.buddyCheckBox, SIGNAL(clicked()), this, SLOT(buddyClicked()));
|
|
168 |
|
|
169 |
m_ui.fieldClassComboBox->addItems(fieldWidgetClasses(core));
|
|
170 |
m_ui.fieldClassComboBox->setCurrentIndex(0);
|
|
171 |
connect(m_ui.fieldClassComboBox, SIGNAL(currentIndexChanged(int)),
|
|
172 |
this, SLOT(fieldClassChanged(int)));
|
|
173 |
|
|
174 |
updateOkButton();
|
|
175 |
}
|
|
176 |
|
|
177 |
FormLayoutRow FormLayoutRowDialog::formLayoutRow() const
|
|
178 |
{
|
|
179 |
FormLayoutRow rc;
|
|
180 |
rc.labelText = labelText();
|
|
181 |
rc.labelName = m_ui.labelNameLineEdit->text();
|
|
182 |
rc.fieldClassName = fieldClass();
|
|
183 |
rc.fieldName = m_ui.fieldNameLineEdit->text();
|
|
184 |
rc.buddy = buddy();
|
|
185 |
return rc;
|
|
186 |
}
|
|
187 |
|
|
188 |
bool FormLayoutRowDialog::buddy() const
|
|
189 |
{
|
|
190 |
return m_ui.buddyCheckBox->checkState() == Qt::Checked;
|
|
191 |
}
|
|
192 |
|
|
193 |
void FormLayoutRowDialog::setBuddy(bool b)
|
|
194 |
{
|
|
195 |
m_ui.buddyCheckBox->setCheckState(b ? Qt::Checked : Qt::Unchecked);
|
|
196 |
}
|
|
197 |
|
|
198 |
// Convert rows to 1..n convention for users
|
|
199 |
int FormLayoutRowDialog::row() const
|
|
200 |
{
|
|
201 |
return m_ui.rowSpinBox->value() - 1;
|
|
202 |
}
|
|
203 |
|
|
204 |
void FormLayoutRowDialog::setRow(int row)
|
|
205 |
{
|
|
206 |
m_ui.rowSpinBox->setValue(row + 1);
|
|
207 |
}
|
|
208 |
|
|
209 |
void FormLayoutRowDialog::setRowRange(int from, int to)
|
|
210 |
{
|
|
211 |
m_ui.rowSpinBox->setMinimum(from + 1);
|
|
212 |
m_ui.rowSpinBox->setMaximum(to + 1);
|
|
213 |
m_ui.rowSpinBox->setEnabled(to - from > 0);
|
|
214 |
}
|
|
215 |
|
|
216 |
QString FormLayoutRowDialog::fieldClass() const
|
|
217 |
{
|
|
218 |
return m_ui.fieldClassComboBox->itemText(m_ui.fieldClassComboBox->currentIndex());
|
|
219 |
}
|
|
220 |
|
|
221 |
QString FormLayoutRowDialog::labelText() const
|
|
222 |
{
|
|
223 |
return m_ui.labelTextLineEdit->text();
|
|
224 |
}
|
|
225 |
|
|
226 |
bool FormLayoutRowDialog::isValid() const
|
|
227 |
{
|
|
228 |
// Check for non-empty names and presence of buddy marker if checked
|
|
229 |
const QString name = labelText();
|
|
230 |
if (name.isEmpty() || m_ui.labelNameLineEdit->text().isEmpty() || m_ui.fieldNameLineEdit->text().isEmpty())
|
|
231 |
return false;
|
|
232 |
if (buddy() && !name.contains(m_buddyMarkerRegexp))
|
|
233 |
return false;
|
|
234 |
return true;
|
|
235 |
}
|
|
236 |
|
|
237 |
void FormLayoutRowDialog::updateOkButton()
|
|
238 |
{
|
|
239 |
m_ui.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(isValid());
|
|
240 |
}
|
|
241 |
|
|
242 |
void FormLayoutRowDialog::labelTextEdited(const QString &text)
|
|
243 |
{
|
|
244 |
updateObjectNames(true, true);
|
|
245 |
// Set buddy if '&' is present unless the user changed it
|
|
246 |
if (!m_buddyClicked)
|
|
247 |
setBuddy(text.contains(m_buddyMarkerRegexp));
|
|
248 |
|
|
249 |
updateOkButton();
|
|
250 |
}
|
|
251 |
|
|
252 |
// Get a suitable object name postfix from a class name:
|
|
253 |
// "namespace::QLineEdit"->"LineEdit"
|
|
254 |
static inline QString postFixFromClassName(QString className)
|
|
255 |
{
|
|
256 |
const int index = className.lastIndexOf(QLatin1String("::"));
|
|
257 |
if (index != -1)
|
|
258 |
className.remove(0, index + 2);
|
|
259 |
if (className.size() > 2)
|
|
260 |
if (className.at(0) == QLatin1Char('Q') || className.at(0) == QLatin1Char('K'))
|
|
261 |
if (className.at(1).isUpper())
|
|
262 |
className.remove(0, 1);
|
|
263 |
return className;
|
|
264 |
}
|
|
265 |
|
|
266 |
// Helper routines to filter out characters for converting texts into
|
|
267 |
// class name prefixes. Only accepts ASCII characters/digits and underscores.
|
|
268 |
|
|
269 |
enum PrefixCharacterKind { PC_Digit, PC_UpperCaseLetter, PC_LowerCaseLetter,
|
|
270 |
PC_Other, PC_Invalid };
|
|
271 |
|
|
272 |
static inline PrefixCharacterKind prefixCharacterKind(const QChar &c)
|
|
273 |
{
|
|
274 |
switch (c.category()) {
|
|
275 |
case QChar::Number_DecimalDigit:
|
|
276 |
return PC_Digit;
|
|
277 |
case QChar::Letter_Lowercase: {
|
|
278 |
const char a = c.toAscii();
|
|
279 |
if (a >= 'a' && a <= 'z')
|
|
280 |
return PC_LowerCaseLetter;
|
|
281 |
}
|
|
282 |
break;
|
|
283 |
case QChar::Letter_Uppercase: {
|
|
284 |
const char a = c.toAscii();
|
|
285 |
if (a >= 'A' && a <= 'Z')
|
|
286 |
return PC_UpperCaseLetter;
|
|
287 |
}
|
|
288 |
break;
|
|
289 |
case QChar::Punctuation_Connector:
|
|
290 |
if (c.toAscii() == '_')
|
|
291 |
return PC_Other;
|
|
292 |
break;
|
|
293 |
default:
|
|
294 |
break;
|
|
295 |
}
|
|
296 |
return PC_Invalid;
|
|
297 |
}
|
|
298 |
|
|
299 |
// Convert the text the user types into a usable class name prefix by filtering
|
|
300 |
// characters, lower-casing the first character and camel-casing subsequent
|
|
301 |
// words. ("zip code:") --> ("zipCode").
|
|
302 |
|
|
303 |
static QString prefixFromLabel(const QString &prefix)
|
|
304 |
{
|
|
305 |
QString rc;
|
|
306 |
const int length = prefix.size();
|
|
307 |
bool lastWasAcceptable = false;
|
|
308 |
for (int i = 0 ; i < length; i++) {
|
|
309 |
const QChar c = prefix.at(i);
|
|
310 |
const PrefixCharacterKind kind = prefixCharacterKind(c);
|
|
311 |
const bool acceptable = kind != PC_Invalid;
|
|
312 |
if (acceptable) {
|
|
313 |
if (rc.isEmpty()) {
|
|
314 |
// Lower-case first character
|
|
315 |
rc += kind == PC_UpperCaseLetter ? c.toLower() : c;
|
|
316 |
} else {
|
|
317 |
// Camel-case words
|
|
318 |
rc += !lastWasAcceptable && kind == PC_LowerCaseLetter ? c.toUpper() : c;
|
|
319 |
}
|
|
320 |
}
|
|
321 |
lastWasAcceptable = acceptable;
|
|
322 |
}
|
|
323 |
return rc;
|
|
324 |
}
|
|
325 |
|
|
326 |
void FormLayoutRowDialog::updateObjectNames(bool updateLabel, bool updateField)
|
|
327 |
{
|
|
328 |
// Generate label + field object names from the label text, that is,
|
|
329 |
// "&Zip code:" -> "zipcodeLabel", "zipcodeLineEdit" unless the user
|
|
330 |
// edited it.
|
|
331 |
const bool doUpdateLabel = !m_labelNameEdited && updateLabel;
|
|
332 |
const bool doUpdateField = !m_fieldNameEdited && updateField;
|
|
333 |
if (!doUpdateLabel && !doUpdateField)
|
|
334 |
return;
|
|
335 |
|
|
336 |
const QString prefix = prefixFromLabel(labelText());
|
|
337 |
// Set names
|
|
338 |
if (doUpdateLabel)
|
|
339 |
m_ui.labelNameLineEdit->setText(prefix + QLatin1String("Label"));
|
|
340 |
if (doUpdateField)
|
|
341 |
m_ui.fieldNameLineEdit->setText(prefix + postFixFromClassName(fieldClass()));
|
|
342 |
}
|
|
343 |
|
|
344 |
void FormLayoutRowDialog::fieldClassChanged(int)
|
|
345 |
{
|
|
346 |
updateObjectNames(false, true);
|
|
347 |
}
|
|
348 |
|
|
349 |
void FormLayoutRowDialog::labelNameEdited(const QString & /*text*/)
|
|
350 |
{
|
|
351 |
m_labelNameEdited = true; // stop auto-updating after user change
|
|
352 |
updateOkButton();
|
|
353 |
}
|
|
354 |
|
|
355 |
void FormLayoutRowDialog::fieldNameEdited(const QString & /*text*/)
|
|
356 |
{
|
|
357 |
m_fieldNameEdited = true; // stop auto-updating after user change
|
|
358 |
updateOkButton();
|
|
359 |
}
|
|
360 |
|
|
361 |
void FormLayoutRowDialog::buddyClicked()
|
|
362 |
{
|
|
363 |
m_buddyClicked = true; // stop auto-updating after user change
|
|
364 |
updateOkButton();
|
|
365 |
}
|
|
366 |
|
|
367 |
/* Create a list of classes suitable for field widgets. Take the fixed base
|
|
368 |
* classes provided and look in the widget database for custom widgets derived
|
|
369 |
* from them ("QLineEdit", "CustomLineEdit", "QComboBox"...). */
|
|
370 |
QStringList FormLayoutRowDialog::fieldWidgetClasses(QDesignerFormEditorInterface *core)
|
|
371 |
{
|
|
372 |
// Base class -> custom widgets map
|
|
373 |
typedef QMultiHash<QString, QString> ClassMap;
|
|
374 |
|
|
375 |
static QStringList rc;
|
|
376 |
if (rc.empty()) {
|
|
377 |
const int fwCount = sizeof(fieldWidgetBaseClasses)/sizeof(const char*);
|
|
378 |
// Turn known base classes into list
|
|
379 |
QStringList baseClasses;
|
|
380 |
for (int i = 0; i < fwCount; i++)
|
|
381 |
baseClasses.push_back(QLatin1String(fieldWidgetBaseClasses[i]));
|
|
382 |
// Scan for custom widgets that inherit them and store them in a
|
|
383 |
// multimap of base class->custom widgets unless we have a language
|
|
384 |
// extension installed which might do funny things with custom widgets.
|
|
385 |
ClassMap customClassMap;
|
|
386 |
if (qt_extension<QDesignerLanguageExtension *>(core->extensionManager(), core) == 0) {
|
|
387 |
const QDesignerWidgetDataBaseInterface *wdb = core->widgetDataBase();
|
|
388 |
const int wdbCount = wdb->count();
|
|
389 |
for (int w = 0; w < wdbCount; ++w) {
|
|
390 |
// Check for non-container custom types that extend the
|
|
391 |
// respective base class.
|
|
392 |
const QDesignerWidgetDataBaseItemInterface *dbItem = wdb->item(w);
|
|
393 |
if (!dbItem->isPromoted() && !dbItem->isContainer() && dbItem->isCustom()) {
|
|
394 |
const int index = baseClasses.indexOf(dbItem->extends());
|
|
395 |
if (index != -1)
|
|
396 |
customClassMap.insert(baseClasses.at(index), dbItem->name());
|
|
397 |
}
|
|
398 |
}
|
|
399 |
}
|
|
400 |
// Compile final list, taking each base class and append custom widgets
|
|
401 |
// based on it.
|
|
402 |
for (int i = 0; i < fwCount; i++) {
|
|
403 |
rc.push_back(baseClasses.at(i));
|
|
404 |
rc += customClassMap.values(baseClasses.at(i));
|
|
405 |
}
|
|
406 |
}
|
|
407 |
return rc;
|
|
408 |
}
|
|
409 |
|
|
410 |
// ------------------ Utilities
|
|
411 |
|
|
412 |
static QFormLayout *managedFormLayout(const QDesignerFormEditorInterface *core, const QWidget *w)
|
|
413 |
{
|
|
414 |
QLayout *l = 0;
|
|
415 |
if (LayoutInfo::managedLayoutType(core, w, &l) == LayoutInfo::Form)
|
|
416 |
return qobject_cast<QFormLayout *>(l);
|
|
417 |
return 0;
|
|
418 |
}
|
|
419 |
|
|
420 |
// Create the widgets of a control row and apply text properties contained
|
|
421 |
// in the struct, called by addFormLayoutRow()
|
|
422 |
static QPair<QWidget *,QWidget *>
|
|
423 |
createWidgets(const FormLayoutRow &row, QWidget *parent,
|
|
424 |
QDesignerFormWindowInterface *formWindow)
|
|
425 |
{
|
|
426 |
QDesignerFormEditorInterface *core = formWindow->core();
|
|
427 |
QDesignerWidgetFactoryInterface *wf = core->widgetFactory();
|
|
428 |
|
|
429 |
QPair<QWidget *,QWidget *> rc = QPair<QWidget *,QWidget *>(wf->createWidget(QLatin1String("QLabel"), parent),
|
|
430 |
wf->createWidget(row.fieldClassName, parent));
|
|
431 |
// Set up properties of the label
|
|
432 |
const QString objectNameProperty = QLatin1String("objectName");
|
|
433 |
QDesignerPropertySheetExtension *labelSheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), rc.first);
|
|
434 |
int nameIndex = labelSheet->indexOf(objectNameProperty);
|
|
435 |
labelSheet->setProperty(nameIndex, qVariantFromValue(PropertySheetStringValue(row.labelName)));
|
|
436 |
labelSheet->setChanged(nameIndex, true);
|
|
437 |
formWindow->ensureUniqueObjectName(rc.first);
|
|
438 |
const int textIndex = labelSheet->indexOf(QLatin1String("text"));
|
|
439 |
labelSheet->setProperty(textIndex, qVariantFromValue(PropertySheetStringValue(row.labelText)));
|
|
440 |
labelSheet->setChanged(textIndex, true);
|
|
441 |
// Set up properties of the control
|
|
442 |
QDesignerPropertySheetExtension *controlSheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), rc.second);
|
|
443 |
nameIndex = controlSheet->indexOf(objectNameProperty);
|
|
444 |
controlSheet->setProperty(nameIndex, qVariantFromValue(PropertySheetStringValue(row.fieldName)));
|
|
445 |
controlSheet->setChanged(nameIndex, true);
|
|
446 |
formWindow->ensureUniqueObjectName(rc.second);
|
|
447 |
return rc;
|
|
448 |
}
|
|
449 |
|
|
450 |
// Create a command sequence on the undo stack of the form window that creates
|
|
451 |
// the widgets of the row and inserts them into the form layout.
|
|
452 |
static void addFormLayoutRow(const FormLayoutRow &formLayoutRow, int row, QWidget *w,
|
|
453 |
QDesignerFormWindowInterface *formWindow)
|
|
454 |
{
|
|
455 |
QFormLayout *formLayout = managedFormLayout(formWindow->core(), w);
|
|
456 |
Q_ASSERT(formLayout);
|
|
457 |
QUndoStack *undoStack = formWindow->commandHistory();
|
|
458 |
const QString macroName = QCoreApplication::translate("Command", "Add '%1' to '%2'").arg(formLayoutRow.labelText, formLayout->objectName());
|
|
459 |
undoStack->beginMacro(macroName);
|
|
460 |
|
|
461 |
// Create a list of widget insertion commands and pass them a cell position
|
|
462 |
const QPair<QWidget *,QWidget *> widgetPair = createWidgets(formLayoutRow, w, formWindow);
|
|
463 |
|
|
464 |
InsertWidgetCommand *labelCmd = new InsertWidgetCommand(formWindow);
|
|
465 |
labelCmd->init(widgetPair.first, false, row, 0);
|
|
466 |
undoStack->push(labelCmd);
|
|
467 |
InsertWidgetCommand *controlCmd = new InsertWidgetCommand(formWindow);
|
|
468 |
controlCmd->init(widgetPair.second, false, row, 1);
|
|
469 |
undoStack->push(controlCmd);
|
|
470 |
if (formLayoutRow.buddy) {
|
|
471 |
SetPropertyCommand *buddyCommand = new SetPropertyCommand(formWindow);
|
|
472 |
buddyCommand->init(widgetPair.first, QLatin1String(buddyPropertyC), widgetPair.second->objectName());
|
|
473 |
undoStack->push(buddyCommand);
|
|
474 |
}
|
|
475 |
undoStack->endMacro();
|
|
476 |
}
|
|
477 |
|
|
478 |
// ---------------- FormLayoutMenu
|
|
479 |
FormLayoutMenu::FormLayoutMenu(QObject *parent) :
|
|
480 |
QObject(parent),
|
|
481 |
m_separator1(new QAction(this)),
|
|
482 |
m_populateFormAction(new QAction(tr("Add form layout row..."), this)),
|
|
483 |
m_separator2(new QAction(this))
|
|
484 |
{
|
|
485 |
m_separator1->setSeparator(true);
|
|
486 |
connect(m_populateFormAction, SIGNAL(triggered()), this, SLOT(slotAddRow()));
|
|
487 |
m_separator2->setSeparator(true);
|
|
488 |
}
|
|
489 |
|
|
490 |
void FormLayoutMenu::populate(QWidget *w, QDesignerFormWindowInterface *fw, ActionList &actions)
|
|
491 |
{
|
|
492 |
switch (LayoutInfo::managedLayoutType(fw->core(), w)) {
|
|
493 |
case LayoutInfo::Form:
|
|
494 |
if (!actions.empty() && !actions.back()->isSeparator())
|
|
495 |
actions.push_back(m_separator1);
|
|
496 |
actions.push_back(m_populateFormAction);
|
|
497 |
actions.push_back(m_separator2);
|
|
498 |
m_widget = w;
|
|
499 |
break;
|
|
500 |
default:
|
|
501 |
m_widget = 0;
|
|
502 |
break;
|
|
503 |
}
|
|
504 |
}
|
|
505 |
|
|
506 |
void FormLayoutMenu::slotAddRow()
|
|
507 |
{
|
|
508 |
QDesignerFormWindowInterface *fw = QDesignerFormWindowInterface::findFormWindow(m_widget);
|
|
509 |
Q_ASSERT(m_widget && fw);
|
|
510 |
const int rowCount = managedFormLayout(fw->core(), m_widget)->rowCount();
|
|
511 |
|
|
512 |
FormLayoutRowDialog dialog(fw->core(), fw);
|
|
513 |
dialog.setRowRange(0, rowCount);
|
|
514 |
dialog.setRow(rowCount);
|
|
515 |
|
|
516 |
if (dialog.exec() != QDialog::Accepted)
|
|
517 |
return;
|
|
518 |
addFormLayoutRow(dialog.formLayoutRow(), dialog.row(), m_widget, fw);
|
|
519 |
}
|
|
520 |
|
|
521 |
QAction *FormLayoutMenu::preferredEditAction(QWidget *w, QDesignerFormWindowInterface *fw)
|
|
522 |
{
|
|
523 |
if (LayoutInfo::managedLayoutType(fw->core(), w) == LayoutInfo::Form) {
|
|
524 |
m_widget = w;
|
|
525 |
return m_populateFormAction;
|
|
526 |
}
|
|
527 |
return 0;
|
|
528 |
}
|
|
529 |
}
|
|
530 |
|
|
531 |
QT_END_NAMESPACE
|
|
532 |
|
|
533 |
#include "formlayoutmenu.moc"
|
|
534 |
|