← Back to branch summary

~ubuntu-branches/ubuntu/wily/psi/wily-proposed

« back to all changes in this revision

Viewing changes to src/options/opt_toolbars.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jan Niehusmann
  • Date: 2008-08-28 18:46:52 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080828184652-iiik12dl91nq7cdi
Tags: 0.12-2
http://bugs.debian.org/494352
Uploading to unstable (Closes: Bug#494352)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/options/opt_toolbars.cpp
6
6
#include "psitoolbar.h"
7
7
#include "iconaction.h"
8
8
#include "psiactionlist.h"
 
9
#include "psioptions.h"
9
10
 
10
11
#include "ui_opt_lookfeel_toolbars.h"
11
 
#include "ui_ui_positiontoolbar.h"
12
12
 
13
13
#include <qlayout.h>
14
14
#include <qpushbutton.h>
27
27
class LookFeelToolbarsUI : public QWidget, public Ui::LookFeelToolbars
28
28
{
29
29
public:
30
 
        LookFeelToolbarsUI() : QWidget() { setupUi(this); }
31
 
};
32
 
 
33
 
//----------------------------------------------------------------------------
34
 
// PositionOptionsTabToolbars
35
 
//----------------------------------------------------------------------------
36
 
 
37
 
class PositionOptionsTabToolbars : public QDialog, public Ui::PositionToolbarUI
38
 
{
39
 
        Q_OBJECT
40
 
public:
41
 
        PositionOptionsTabToolbars(QWidget *parent, Options::ToolbarPrefs *, int);
42
 
        ~PositionOptionsTabToolbars();
43
 
 
44
 
        int n();
45
 
        bool dirty;
46
 
 
47
 
        bool eventFilter(QObject *watched, QEvent *e);
48
 
 
49
 
signals:
50
 
        void applyPressed();
51
 
 
52
 
private slots:
53
 
        void dataChanged();
54
 
        void apply();
55
 
 
56
 
private:
57
 
        int id;
58
 
        Options::ToolbarPrefs *tb;
59
 
};
60
 
 
61
 
PositionOptionsTabToolbars::PositionOptionsTabToolbars(QWidget *parent, Options::ToolbarPrefs *_tb, int _id)
62
 
: QDialog(parent)
63
 
{
64
 
        setupUi(this);
65
 
        setModal(true);
66
 
        tb = _tb;
67
 
        id = _id;
68
 
 
69
 
 
70
 
        connect(pb_ok, SIGNAL(clicked()), SLOT(apply()));
71
 
        connect(pb_ok, SIGNAL(clicked()), SLOT(accept()));
72
 
        connect(pb_apply, SIGNAL(clicked()), SLOT(apply()));
73
 
        connect(pb_cancel, SIGNAL(clicked()), SLOT(reject()));
74
 
 
75
 
        connect(cb_dock, SIGNAL(highlighted(int)), SLOT(dataChanged()));
76
 
        sb_index->installEventFilter( this );
77
 
        sb_extraOffset->installEventFilter( this );
78
 
        connect(ck_nl, SIGNAL(toggled(bool)), SLOT(dataChanged()));
79
 
 
80
 
        le_name->setText( tb->name );
81
 
        if ( tb->dock >= Qt::DockUnmanaged && tb->dock <= Qt::DockTornOff ) {
82
 
                cb_dock->setCurrentItem( tb->dock + Qt::DockMinimized - Qt::DockTornOff );
83
 
        }
84
 
        else {
85
 
                cb_dock->setCurrentItem( tb->dock - Qt::DockTop );
86
 
        }
87
 
        sb_index->setValue( tb->index );
88
 
        sb_extraOffset->setValue( tb->extraOffset );
89
 
        ck_nl->setChecked( tb->nl );
90
 
 
91
 
        dirty = false;
92
 
        pb_apply->setEnabled(false);
93
 
 
94
 
        resize(sizeHint());
95
 
}
96
 
 
97
 
PositionOptionsTabToolbars::~PositionOptionsTabToolbars()
98
 
{
99
 
}
100
 
 
101
 
int PositionOptionsTabToolbars::n()
102
 
{
103
 
        return id;
104
 
}
105
 
 
106
 
void PositionOptionsTabToolbars::dataChanged()
107
 
{
108
 
        dirty = true;
109
 
        pb_apply->setEnabled(true);
110
 
}
111
 
 
112
 
void PositionOptionsTabToolbars::apply()
113
 
{
114
 
        tb->dirty = true;
115
 
        if ( cb_dock->currentItem() >= 0 && cb_dock->currentItem() < 5 ) {
116
 
                // Top, Bottom, Left, Right and Minimised
117
 
                tb->dock = (Qt::ToolBarDock)(cb_dock->currentItem() + Qt::DockTop);
118
 
        }
119
 
        else {
120
 
                // Unmanaged and TornOff
121
 
                tb->dock = (Qt::ToolBarDock)(cb_dock->currentItem() - (Qt::DockMinimized - Qt::DockTornOff));
122
 
        }
123
 
 
124
 
        tb->index = sb_index->value();
125
 
        tb->extraOffset = sb_extraOffset->value();
126
 
        tb->nl = ck_nl->isChecked();
127
 
 
128
 
        if ( dirty )
129
 
                emit applyPressed();
130
 
        dirty = false;
131
 
        pb_apply->setEnabled(false);
132
 
}
133
 
 
134
 
bool PositionOptionsTabToolbars::eventFilter(QObject *watched, QEvent *e)
135
 
{
136
 
        if ( watched->inherits("QSpinBox") && e->type() == QEvent::KeyRelease )
137
 
                dataChanged();
138
 
        return false;
139
 
}
 
30
        LookFeelToolbarsUI() : QWidget() {
 
31
                setupUi(this);
 
32
        }
 
33
};
140
34
 
141
35
//----------------------------------------------------------------------------
142
36
// OptionsTabToolbars
145
39
class OptionsTabToolbars::Private
146
40
{
147
41
public:
148
 
        struct ToolbarItem {
149
 
                QString group;
150
 
                int index;
151
 
                ToolbarItem() {
152
 
                        group = "";
153
 
                        index = -1;
154
 
                }
155
 
                ToolbarItem( QString _w, int _i ) {
156
 
                        group = _w;
157
 
                        index = _i;
158
 
                }
159
 
        };
160
 
 
161
 
        QMap<int, ToolbarItem> toolbars;
162
 
 
163
 
        PsiActionList::ActionsType class2id( QString name ) {
 
42
        QMap<QString, ToolbarPrefs> toolbars;
 
43
 
 
44
        PsiActionList::ActionsType class2id() {
164
45
                int ret = (int)PsiActionList::Actions_Common;
165
 
 
166
 
                if ( name == "mainWin" )
167
 
                        ret |= (int)PsiActionList::Actions_MainWin;
168
 
 
 
46
                ret |= (int)PsiActionList::Actions_MainWin;
169
47
                return (PsiActionList::ActionsType)ret;
170
48
        }
171
49
};
172
50
 
173
 
OptionsTabToolbars::OptionsTabToolbars(QObject *parent) 
174
 
: OptionsTab(parent, "toolbars", "", tr("Toolbars"), tr("Configure Psi toolbars"), "psi/toolbars")
 
51
OptionsTabToolbars::OptionsTabToolbars(QObject *parent)
 
52
        : OptionsTab(parent, "toolbars", "", tr("Toolbars"), tr("Configure Psi toolbars"), "psi/toolbars")
175
53
{
176
54
        w = 0;
177
55
        p = new Private();
178
56
 
179
57
        noDirty = false;
180
 
        opt = new Options;
181
58
}
182
59
 
183
60
QWidget *OptionsTabToolbars::widget()
184
61
{
185
62
        if (w)
186
63
                return 0;
187
 
        
 
64
 
188
65
        w = new LookFeelToolbarsUI();
189
66
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI*) w;
190
 
        
 
67
 
191
68
        connect(d->pb_addToolbar, SIGNAL(clicked()), SLOT(toolbarAdd()));
192
69
        connect(d->pb_deleteToolbar, SIGNAL(clicked()), SLOT(toolbarDelete()));
193
70
        connect(d->cb_toolbars, SIGNAL(activated(int)), SLOT(toolbarSelectionChanged(int)));
194
71
        connect(d->le_toolbarName, SIGNAL(textChanged(const QString &)), SLOT(toolbarNameChanged()));
195
 
        connect(d->pb_toolbarPosition, SIGNAL(clicked()), SLOT(toolbarPosition()));
 
72
        // connect(d->pb_toolbarPosition, SIGNAL(clicked()), SLOT(toolbarPosition()));
196
73
        connect(d->tb_up, SIGNAL(clicked()), SLOT(toolbarActionUp()));
197
74
        connect(d->tb_down, SIGNAL(clicked()), SLOT(toolbarActionDown()));
198
75
        connect(d->tb_right, SIGNAL(clicked()), SLOT(toolbarAddAction()));
200
77
 
201
78
        connect(d->ck_toolbarOn, SIGNAL(toggled(bool)), SLOT(toolbarDataChanged()));
202
79
        connect(d->ck_toolbarLocked, SIGNAL(toggled(bool)), SLOT(toolbarDataChanged()));
203
 
        connect(d->ck_toolbarStretch, SIGNAL(toggled(bool)), SLOT(toolbarDataChanged()));
 
80
        // connect(d->ck_toolbarStretch, SIGNAL(toggled(bool)), SLOT(toolbarDataChanged()));
204
81
        connect(d->lw_selectedActions, SIGNAL(currentItemChanged(QListWidgetItem *, QListWidgetItem *)), SLOT(selAct_selectionChanged(QListWidgetItem *)));
205
82
        connect(d->tw_availActions, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)), SLOT(avaAct_selectionChanged(QTreeWidgetItem *)));
206
83
 
253
130
 
254
131
OptionsTabToolbars::~OptionsTabToolbars()
255
132
{
256
 
        delete opt;
257
133
        delete p;
258
134
}
259
135
 
289
165
        }
290
166
}*/
291
167
 
292
 
void OptionsTabToolbars::applyOptions(Options *o)
293
 
{
294
 
        if ( !w )
295
 
                opt->toolbars = o->toolbars;
296
 
 
297
 
        // get current toolbars' positions
298
 
        QList<PsiToolBar*> toolbars = psi->toolbarList();
299
 
        for (int i = 0; i < opt->toolbars["mainWin"].count() && i < toolbars.count(); i++) {
300
 
                //if ( toolbarPositionInProgress && posTbDlg->n() == (int)i )
301
 
                //      continue;
302
 
 
303
 
                Options::ToolbarPrefs &tbPref = opt->toolbars["mainWin"][i];
304
 
                psi->getToolbarLocation(toolbars.at(i), tbPref.dock, tbPref.index, tbPref.nl, tbPref.extraOffset);
305
 
        }
306
 
 
307
 
        // apply options
308
 
        o->toolbars = opt->toolbars;
309
 
 
310
 
        doApply();
311
 
}
312
 
 
313
 
void OptionsTabToolbars::rebuildToolbarList()
314
 
{
315
 
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
316
 
 
317
 
        d->cb_toolbars->clear();
318
 
        p->toolbars.clear();
319
 
 
320
 
        QMap< QString, QList<Options::ToolbarPrefs> >::Iterator it = opt->toolbars.begin();
321
 
        for ( ; it != opt->toolbars.end(); ++it ) {
322
 
                if ( p->toolbars.count() )
323
 
                        d->cb_toolbars->insertItem( "---" ); // TODO: think of better separator
324
 
 
325
 
                int i = 0;
326
 
                QList<Options::ToolbarPrefs>::Iterator it2 = it.data().begin();
327
 
                for ( ; it2 != it.data().end(); ++it2, ++i ) {
328
 
                        d->cb_toolbars->insertItem( (*it2).name );
329
 
                        p->toolbars[d->cb_toolbars->count()-1] = Private::ToolbarItem( it.key(), i );
330
 
                }
331
 
        }
332
 
}
333
 
 
334
 
void OptionsTabToolbars::restoreOptions(const Options *o)
335
 
{
336
 
        if ( !w )
337
 
                return;
338
 
 
339
 
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
340
 
        opt->toolbars = o->toolbars;
341
 
        opt->hideMenubar = o->hideMenubar;
342
 
 
343
 
        rebuildToolbarList();
344
 
 
345
 
        if(d->cb_toolbars->count() > 0) {
346
 
                d->cb_toolbars->setCurrentIndex( 0 );
347
 
                toolbarSelectionChanged( 0 );
 
168
void OptionsTabToolbars::applyOptions()
 
169
{
 
170
        if (!w)
 
171
                return;
 
172
 
 
173
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
174
 
 
175
        PsiOptions *o = PsiOptions::instance();
 
176
        o->removeOption("options.ui.contactlist.toolbars", true);
 
177
        QMap<QString, ToolbarPrefs>::Iterator it = p->toolbars.begin();
 
178
        for (; it != p->toolbars.end(); ++it) {
 
179
                PsiToolBar::structToOptions(o, it.data());
 
180
        }
 
181
}
 
182
 
 
183
void OptionsTabToolbars::restoreOptions()
 
184
{
 
185
        if (!w)
 
186
                return;
 
187
 
 
188
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
189
 
 
190
        PsiOptions *o = PsiOptions::instance();
 
191
 
 
192
        QStringList toolbarBases = o->getChildOptionNames("options.ui.contactlist.toolbars", true, true);
 
193
 
 
194
        foreach(QString base, toolbarBases) {
 
195
                ToolbarPrefs tb;
 
196
                tb.id = o->getOption(base + ".key").toString();
 
197
                tb.name = o->getOption(base + ".name").toString();
 
198
                tb.on = o->getOption(base + ".visible").toBool();
 
199
                tb.locked = o->getOption(base + ".locked").toBool();
 
200
                // tb.stretchable = o->getOption(base + ".stretchable").toBool();
 
201
                tb.dock = (Qt::Dock)o->getOption(base + ".dock.position").toInt(); //FIXME
 
202
                // tb.index = o->getOption(base + ".dock.index").toInt();
 
203
                tb.nl = o->getOption(base + ".dock.nl").toBool();
 
204
                // tb.extraOffset = o->getOption(base + ".dock.extra-offset").toInt();
 
205
                tb.keys = o->getOption(base + ".actions").toStringList();
 
206
 
 
207
                p->toolbars[base] = tb;
 
208
                d->cb_toolbars->addItem(tb.name, base);
 
209
        }
 
210
 
 
211
        if (d->cb_toolbars->count() > 0) {
 
212
                d->cb_toolbars->setCurrentIndex(0);
 
213
                toolbarSelectionChanged(0);
348
214
        }
349
215
        else
350
 
                toolbarSelectionChanged( -1 );
 
216
                toolbarSelectionChanged(-1);
351
217
}
352
218
 
353
219
//----------------------------------------------------------------------------
358
224
 
359
225
        int i = d->cb_toolbars->count();
360
226
 
361
 
        Options::ToolbarPrefs tb;
362
 
        tb.name = QObject::tr("<unnamed>");
 
227
        ToolbarPrefs tb;
 
228
        int j = 0;
 
229
        bool ok;
 
230
        do {
 
231
                ok = true;
 
232
                tb.name = QObject::tr("<unnamed%1>").arg(j++);
 
233
                foreach(ToolbarPrefs other, p->toolbars) {
 
234
                        if (other.name == tb.name) {
 
235
                                ok = false;
 
236
                                break;
 
237
                        }
 
238
                }
 
239
        }
 
240
        while (!ok);
 
241
 
363
242
        tb.on = false;
364
243
        tb.locked = false;
365
 
        tb.stretchable = false;
 
244
        // tb.stretchable = false;
366
245
        tb.keys.clear();
367
246
 
368
247
        tb.dock = Qt::DockTop;
369
 
        tb.index = i;
 
248
        // tb.index = i;
370
249
        tb.nl = true;
371
 
        tb.extraOffset = 0;
 
250
        // tb.extraOffset = 0;
372
251
 
373
252
        tb.dirty = true;
374
253
 
375
 
        opt->toolbars["mainWin"].append(tb);
376
 
 
377
 
        rebuildToolbarList();
378
 
        d->cb_toolbars->setCurrentIndex( d->cb_toolbars->count()-1 );
379
 
        toolbarSelectionChanged( d->cb_toolbars->currentIndex() );
 
254
        QString base;
 
255
        j = 0;
 
256
        do {
 
257
                ok = true;
 
258
                base = ".." + QString::number(j++);
 
259
        }
 
260
        while (p->toolbars.keys().contains(base));
 
261
 
 
262
        p->toolbars[base] = tb;
 
263
 
 
264
        d->cb_toolbars->addItem(tb.name, base);
 
265
 
 
266
        d->cb_toolbars->setCurrentIndex(d->cb_toolbars->count() - 1);
 
267
        toolbarSelectionChanged(d->cb_toolbars->currentIndex());
380
268
 
381
269
        d->le_toolbarName->setFocus();
382
270
}
386
274
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
387
275
        int n = d->cb_toolbars->currentIndex();
388
276
 
389
 
        {
390
 
                int idx = p->toolbars[n].index;
391
 
                QList<Options::ToolbarPrefs>::Iterator it = opt->toolbars[p->toolbars[n].group].begin();
392
 
                for (int i = 0; i < idx; i++)
393
 
                        ++it;
394
 
 
395
 
                noDirty = true;
396
 
                opt->toolbars[p->toolbars[n].group].remove(it);
397
 
 
398
 
                toolbarSelectionChanged(-1);
399
 
                rebuildToolbarList();
400
 
                noDirty = false;
401
 
                toolbarSelectionChanged( d->cb_toolbars->currentIndex() );
402
 
        }
 
277
        QString base = d->cb_toolbars->itemData(n).toString();
 
278
 
 
279
        noDirty = true;
 
280
        toolbarSelectionChanged(-1);
 
281
 
 
282
        p->toolbars.remove(base);
 
283
 
 
284
        d->cb_toolbars->removeItem(d->cb_toolbars->findData(base));
 
285
 
 
286
        noDirty = false;
 
287
        toolbarSelectionChanged(d->cb_toolbars->currentIndex());
403
288
}
404
289
 
405
290
void OptionsTabToolbars::addToolbarAction(QListWidget *parent, QString name, int toolbarId)
406
291
{
407
 
        ActionList actions = psi->actionList()->suitableActions( (PsiActionList::ActionsType)toolbarId );
408
 
        const QAction *action = (QAction *)actions.action( name );
409
 
        if ( !action )
 
292
        ActionList actions = psi->actionList()->suitableActions((PsiActionList::ActionsType)toolbarId);
 
293
        const QAction *action = (QAction *)actions.action(name);
 
294
        if (!action)
410
295
                return;
411
296
        addToolbarAction(parent, action, name);
412
297
}
416
301
        QListWidgetItem *item = new QListWidgetItem(parent);
417
302
 
418
303
        QString n = actionName(action);
419
 
        if ( !action->whatsThis().isEmpty() )
 
304
        if (!action->whatsThis().isEmpty())
420
305
                n += " - " + action->whatsThis();
421
306
        item->setText(n);
422
307
        item->setData(Qt::UserRole, name);
423
308
        item->setIcon(action->iconSet());
 
309
        item->setHidden(!action->isVisible());
424
310
}
425
311
 
426
312
void OptionsTabToolbars::toolbarSelectionChanged(int item)
427
313
{
428
 
        if ( noDirty )
 
314
        if (noDirty)
429
315
                return;
430
316
 
431
317
        int n = item;
432
 
        PsiToolBar *toolBar = 0;
433
 
        if ( item != -1 )
434
 
                toolBar = psi->findToolBar( p->toolbars[n].group, p->toolbars[n].index );
 
318
//      PsiToolBar *toolBar = 0;
 
319
//      if ( item != -1 )
 
320
//              toolBar = psi->findToolBar( p->toolbars[n].group, p->toolbars[n].index );
435
321
 
436
 
        bool customizeable = toolBar ? toolBar->isCustomizeable() : true;
437
 
        bool moveable      = toolBar ? toolBar->isMoveable() : true;
 
322
        bool customizeable = true;
 
323
        bool moveable      = true;
438
324
 
439
325
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
440
 
        bool enable = (item == -1) ? false: true;
441
 
        d->le_toolbarName->setEnabled( enable );
442
 
        d->pb_toolbarPosition->setEnabled( enable && moveable );
443
 
        d->ck_toolbarOn->setEnabled( enable );
444
 
        d->ck_toolbarLocked->setEnabled( enable && moveable );
445
 
        d->ck_toolbarStretch->setEnabled( enable && moveable );
446
 
        d->lw_selectedActions->setEnabled( enable && customizeable );
447
 
        d->tw_availActions->setEnabled( enable && customizeable );
448
 
        d->tb_up->setEnabled( enable && customizeable );
449
 
        d->tb_down->setEnabled( enable && customizeable );
450
 
        d->tb_left->setEnabled( enable && customizeable );
451
 
        d->tb_right->setEnabled( enable && customizeable );
452
 
        d->pb_deleteToolbar->setEnabled( enable && p->toolbars[n].group == "mainWin" );
453
 
        d->cb_toolbars->setEnabled( enable );
 
326
        bool enable = (item == -1) ? false : true;
 
327
        d->le_toolbarName->setEnabled(enable);
 
328
        // d->pb_toolbarPosition->setEnabled(enable && moveable);
 
329
        d->ck_toolbarOn->setEnabled(enable);
 
330
        d->ck_toolbarLocked->setEnabled(enable && moveable);
 
331
        // d->ck_toolbarStretch->setEnabled(enable && moveable);
 
332
        d->lw_selectedActions->setEnabled(enable && customizeable);
 
333
        d->tw_availActions->setEnabled(enable && customizeable);
 
334
        d->tb_up->setEnabled(enable && customizeable);
 
335
        d->tb_down->setEnabled(enable && customizeable);
 
336
        d->tb_left->setEnabled(enable && customizeable);
 
337
        d->tb_right->setEnabled(enable && customizeable);
 
338
        d->pb_deleteToolbar->setEnabled(enable);
 
339
        d->cb_toolbars->setEnabled(enable);
454
340
 
455
341
        d->tw_availActions->clear();
456
342
        d->lw_selectedActions->clear();
457
343
 
458
 
        if ( !enable ) {
459
 
                d->le_toolbarName->setText( "" );
 
344
        if (!enable) {
 
345
                d->le_toolbarName->setText("");
460
346
                return;
461
347
        }
462
348
 
463
349
        noDirty = true;
464
350
 
465
 
        Options::ToolbarPrefs tb = opt->toolbars[p->toolbars[n].group][p->toolbars[n].index];
466
 
        d->le_toolbarName->setText( tb.name );
467
 
        d->ck_toolbarOn->setChecked( tb.on );
468
 
        d->ck_toolbarLocked->setChecked( tb.locked || !moveable );
469
 
        d->ck_toolbarStretch->setChecked( tb.stretchable );
 
351
        QString base = d->cb_toolbars->itemData(n).toString();
 
352
        ToolbarPrefs tb;
 
353
        tb = p->toolbars[base];
 
354
 
 
355
        d->le_toolbarName->setText(tb.name);
 
356
        d->ck_toolbarOn->setChecked(tb.on);
 
357
        d->ck_toolbarLocked->setChecked(tb.locked || !moveable);
 
358
        // d->ck_toolbarStretch->setChecked(tb.stretchable);
470
359
 
471
360
        {
472
361
                // Fill the TreeWidget with toolbar-specific actions
473
362
                QTreeWidget *tw = d->tw_availActions;
474
363
                QTreeWidgetItem *lastRoot = 0;
475
364
 
476
 
                foreach(ActionList* actionList, psi->actionList()->actionLists( p->class2id( p->toolbars[n].group ) )) {
 
365
                foreach(ActionList* actionList, psi->actionList()->actionLists(p->class2id())) {
477
366
                        QTreeWidgetItem *root = new QTreeWidgetItem(tw, lastRoot);
478
367
                        lastRoot = root;
479
 
                        root->setText( 0, actionList->name() );
480
 
                        root->setData( 0, Qt::UserRole, QString("") );
481
 
                        root->setExpanded( true );
 
368
                        root->setText(0, actionList->name());
 
369
                        root->setData(0, Qt::UserRole, QString(""));
 
370
                        root->setExpanded(true);
482
371
 
483
372
                        QTreeWidgetItem *last = 0;
484
373
                        QStringList actionNames = actionList->actions();
485
374
                        QStringList::Iterator it2 = actionNames.begin();
486
 
                        for ( ; it2 != actionNames.end(); ++it2 ) {
487
 
                                IconAction *action = actionList->action( *it2 );
488
 
                                QTreeWidgetItem *item = new QTreeWidgetItem( root, last );
 
375
                        for (; it2 != actionNames.end(); ++it2) {
 
376
                                IconAction *action = actionList->action(*it2);
 
377
                                if (!action->isVisible())
 
378
                                        continue;
 
379
                                QTreeWidgetItem *item = new QTreeWidgetItem(root, last);
489
380
                                last = item;
490
381
 
491
382
                                QString n = actionName((QAction *)action);
492
 
                                if ( !action->whatsThis().isEmpty() )
 
383
                                if (!action->whatsThis().isEmpty()) {
493
384
                                        n += " - " + action->whatsThis();
494
 
                                item->setText( 0, n );
495
 
                                item->setIcon( 0, action->iconSet() );
496
 
                                item->setData( 0, Qt::UserRole, action->name() );
 
385
                                }
 
386
                                item->setText(0, n);
 
387
                                item->setIcon(0, action->iconSet());
 
388
                                item->setData(0, Qt::UserRole, action->name());
497
389
                        }
498
390
                }
499
391
                tw->resizeColumnToContents(0);
500
392
        }
501
393
 
502
394
        QStringList::Iterator it = tb.keys.begin();
503
 
        for ( ; it != tb.keys.end(); ++it) {
504
 
                addToolbarAction(d->lw_selectedActions, *it, p->class2id( p->toolbars[n].group ) );
 
395
        for (; it != tb.keys.end(); ++it) {
 
396
                addToolbarAction(d->lw_selectedActions, *it, p->class2id());
505
397
        }
506
398
        updateArrows();
507
399
 
511
403
void OptionsTabToolbars::rebuildToolbarKeys()
512
404
{
513
405
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
514
 
        if ( !d->cb_toolbars->count() )
 
406
        if (!d->cb_toolbars->count())
515
407
                return;
516
408
        int n = d->cb_toolbars->currentIndex();
517
409
 
520
412
        int count = d->lw_selectedActions->count();
521
413
        for (int i = 0; i < count; i++) {
522
414
                keys << d->lw_selectedActions->item(i)->data(Qt::UserRole).toString();
523
 
        }
524
 
 
525
 
        opt->toolbars["mainWin"][n].keys  = keys;
526
 
        opt->toolbars["mainWin"][n].dirty = true;
 
415
        }
 
416
 
 
417
        QString base = d->cb_toolbars->itemData(n).toString();
 
418
        p->toolbars[base].keys = keys;
 
419
 
527
420
        emit dataChanged();
528
421
}
529
422
 
532
425
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
533
426
        bool up = false, down = false, left = false, right = false;
534
427
 
535
 
        if(d->tw_availActions->currentItem() && !d->tw_availActions->currentItem()->data(0, Qt::UserRole).toString().isEmpty())
 
428
        if (d->tw_availActions->currentItem() && !d->tw_availActions->currentItem()->data(0, Qt::UserRole).toString().isEmpty())
536
429
                right = true;
537
430
        QListWidgetItem *i = d->lw_selectedActions->currentItem();
538
 
        if(i) {
 
431
        if (i) {
539
432
                left = true;
540
433
 
541
434
                // get numeric index of item
542
435
                int n = d->lw_selectedActions->row(i);
543
436
 
544
 
                if(n > 0)
545
 
                        up = true;
546
 
                if(n < d->lw_selectedActions->count() - 1)
547
 
                        down = true;
 
437
                int i = n;
 
438
                while (--i > 0) {
 
439
                        if (!d->lw_selectedActions->item(i)->isHidden()) {
 
440
                                up = true;
 
441
                                break;
 
442
                        }
 
443
                }
 
444
 
 
445
                i = n;
 
446
                while (++i < d->lw_selectedActions->count()) {
 
447
                        if (!d->lw_selectedActions->item(i)->isHidden()) {
 
448
                                down = true;
 
449
                                break;
 
450
                        }
 
451
                }
548
452
        }
549
453
 
550
454
        d->tb_up->setEnabled(up);
556
460
void OptionsTabToolbars::toolbarNameChanged()
557
461
{
558
462
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
559
 
        if ( !d->cb_toolbars->count() )
 
463
        if (!d->cb_toolbars->count())
560
464
                return;
561
465
 
 
466
        QString name = d->le_toolbarName->text();
 
467
 
562
468
        int n = d->cb_toolbars->currentIndex();
563
 
        d->cb_toolbars->changeItem(d->le_toolbarName->text(), n);
564
 
        opt->toolbars["mainWin"][n].name = d->le_toolbarName->text();
 
469
        QString base = d->cb_toolbars->itemData(n).toString();
 
470
        p->toolbars[base].name = name;
 
471
 
 
472
        d->cb_toolbars->setItemText(d->cb_toolbars->findData(base), name);
565
473
 
566
474
        emit dataChanged();
567
475
}
570
478
{
571
479
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
572
480
        QListWidgetItem *item = d->lw_selectedActions->currentItem();
573
 
        if ( !item )
 
481
        if (!item)
574
482
                return;
575
483
 
576
484
        int row = d->lw_selectedActions->row(item);
577
 
        if ( row > 0 ) {
 
485
        if (row > 0) {
578
486
                d->lw_selectedActions->takeItem(row);
579
 
                d->lw_selectedActions->insertItem(row - 1, item);
 
487
                --row;
 
488
                while (row > 0 && d->lw_selectedActions->item(row)->isHidden()) {
 
489
                        --row;
 
490
                }
 
491
                d->lw_selectedActions->insertItem(row, item);
580
492
                d->lw_selectedActions->setCurrentItem(item);
581
493
        }
582
494
 
588
500
{
589
501
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
590
502
        QListWidgetItem *item = d->lw_selectedActions->currentItem();
591
 
        if ( !item )
 
503
        if (!item)
592
504
                return;
593
505
 
594
506
        int row = d->lw_selectedActions->row(item);
595
 
        if ( row < d->lw_selectedActions->count() ) {
 
507
        if (row < d->lw_selectedActions->count()) {
596
508
                d->lw_selectedActions->takeItem(row);
597
 
                d->lw_selectedActions->insertItem(row + 1, item);
 
509
                ++row;
 
510
                while (row < d->lw_selectedActions->count() && d->lw_selectedActions->item(row)->isHidden()) {
 
511
                        ++row;
 
512
                }
 
513
                d->lw_selectedActions->insertItem(row, item);
598
514
                d->lw_selectedActions->setCurrentItem(item);
599
515
        }
600
516
 
606
522
{
607
523
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
608
524
        QTreeWidgetItem *item = d->tw_availActions->currentItem();
609
 
        if ( !item || item->data(0, Qt::UserRole).toString().isEmpty() )
 
525
        if (!item || item->data(0, Qt::UserRole).toString().isEmpty())
610
526
                return;
611
527
 
612
 
        addToolbarAction(d->lw_selectedActions, item->data(0, Qt::UserRole).toString(), p->class2id( p->toolbars[d->cb_toolbars->currentIndex()].group ) );
 
528
        addToolbarAction(d->lw_selectedActions, item->data(0, Qt::UserRole).toString(), p->class2id());
613
529
        rebuildToolbarKeys();
614
530
        updateArrows();
615
531
}
618
534
{
619
535
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
620
536
        QListWidgetItem *item = d->lw_selectedActions->currentItem();
621
 
        if ( !item )
 
537
        if (!item)
622
538
                return;
623
539
 
624
540
        delete item;
629
545
 
630
546
void OptionsTabToolbars::toolbarDataChanged()
631
547
{
632
 
        if ( noDirty )
 
548
        if (noDirty)
633
549
                return;
634
550
 
635
551
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
636
 
        if ( !d->cb_toolbars->count() )
 
552
        if (!d->cb_toolbars->count())
637
553
                return;
638
554
        int n = d->cb_toolbars->currentIndex();
639
555
 
640
 
        opt->toolbars["mainWin"][n].dirty = true;
641
 
        opt->toolbars["mainWin"][n].name = d->le_toolbarName->text();
642
 
        opt->toolbars["mainWin"][n].on = d->ck_toolbarOn->isChecked();
643
 
        opt->toolbars["mainWin"][n].locked = d->ck_toolbarLocked->isChecked();
644
 
        opt->toolbars["mainWin"][n].stretchable = d->ck_toolbarStretch->isChecked();
 
556
        QString base = d->cb_toolbars->itemData(n).toString();
 
557
        ToolbarPrefs tb;
 
558
        tb = p->toolbars[base];
 
559
 
 
560
        tb.dirty = true;
 
561
        tb.name = d->le_toolbarName->text();
 
562
        tb.on = d->ck_toolbarOn->isChecked();
 
563
        tb.locked = d->ck_toolbarLocked->isChecked();
 
564
        // tb.stretchable = d->ck_toolbarStretch->isChecked();
 
565
 
 
566
        p->toolbars[base] = tb;
645
567
 
646
568
        emit dataChanged();
647
569
}
650
572
{
651
573
        QString n = a->menuText(), n2;
652
574
        for (int i = 0; i < (int)n.length(); i++) {
653
 
                if ( n[i] == '&' && n[i+1] != '&' )
 
575
                if (n[i] == '&' && n[i+1] != '&')
654
576
                        continue;
655
 
                else if ( n[i] == '&' && n[i+1] == '&' )
 
577
                else if (n[i] == '&' && n[i+1] == '&')
656
578
                        n2 += '&';
657
579
                else
658
580
                        n2 += n[i];
663
585
 
664
586
void OptionsTabToolbars::toolbarPosition()
665
587
{
 
588
#if 0
 
589
        LEGOPTFIXME
666
590
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
667
 
        if ( !d->cb_toolbars->count() )
 
591
        if (!d->cb_toolbars->count())
668
592
                return;
669
593
        int n = d->cb_toolbars->currentIndex();
670
594
 
671
 
        PositionOptionsTabToolbars *posTbDlg = new PositionOptionsTabToolbars(w, &opt->toolbars["mainWin"][n], n);
 
595
        PositionOptionsTabToolbars *posTbDlg = new PositionOptionsTabToolbars(w, &LEGOPTS.toolbars["mainWin"][n], n);
672
596
        connect(posTbDlg, SIGNAL(applyPressed()), SLOT(toolbarPositionApply()));
673
597
 
674
598
        posTbDlg->exec();
675
599
        delete posTbDlg;
 
600
#endif
676
601
}
677
602
 
678
603
void OptionsTabToolbars::toolbarPositionApply()
679
604
{
 
605
#if 0
 
606
        LEGOPTFIXME
680
607
        emit dataChanged();
681
608
 
682
 
        option.toolbars = opt->toolbars;
683
 
        psi->buildToolbars();
684
 
}
685
 
 
686
 
void OptionsTabToolbars::doApply()
687
 
{
688
 
        option.toolbars = opt->toolbars;
689
 
        psi->buildToolbars();
 
609
        LEGOPTS.toolbars = LEGOPTS.toolbars;
 
610
        psi->buildToolbars();
 
611
#endif
690
612
}
691
613
 
692
614
void OptionsTabToolbars::selAct_selectionChanged(QListWidgetItem *)
698
620
{
699
621
        updateArrows();
700
622
}
701
 
 
702
 
#include "opt_toolbars.moc"