← Back to branch summary

~ubuntu-branches/ubuntu/karmic/psi/karmic

« 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-04-14 18:57:30 UTC
  • mfrom: (2.1.9 hardy)
  • Revision ID: james.westby@ubuntu.com-20080414185730-528re3zp0m2hdlhi
Tags: 0.11-8
http://bugs.debian.org/476122
* added CONFIG -= link_prl to .pro files and removed dependencies
  which are made unnecessary by this change
* Fix segfault when closing last chat tab with qt4.4
  (This is from upstream svn, rev. 1101) (Closes: Bug#476122)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/options/opt_toolbars.cpp
 
1
#include "opt_toolbars.h"
 
2
 
 
3
#include "psicon.h"
 
4
#include "common.h"
 
5
#include "iconwidget.h"
 
6
#include "psitoolbar.h"
 
7
#include "iconaction.h"
 
8
#include "psiactionlist.h"
 
9
 
 
10
#include "ui_opt_lookfeel_toolbars.h"
 
11
#include "ui_ui_positiontoolbar.h"
 
12
 
 
13
#include <qlayout.h>
 
14
#include <qpushbutton.h>
 
15
#include <qcombobox.h>
 
16
#include <qaction.h>
 
17
#include <qlineedit.h>
 
18
#include <qcheckbox.h>
 
19
#include <qspinbox.h>
 
20
#include <QHeaderView>
 
21
//Added by qt3to4:
 
22
#include <QEvent>
 
23
#include <QHBoxLayout>
 
24
#include <QList>
 
25
#include <QVBoxLayout>
 
26
 
 
27
class LookFeelToolbarsUI : public QWidget, public Ui::LookFeelToolbars
 
28
{
 
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
}
 
140
 
 
141
//----------------------------------------------------------------------------
 
142
// OptionsTabToolbars
 
143
//----------------------------------------------------------------------------
 
144
 
 
145
class OptionsTabToolbars::Private
 
146
{
 
147
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 ) {
 
164
                int ret = (int)PsiActionList::Actions_Common;
 
165
 
 
166
                if ( name == "mainWin" )
 
167
                        ret |= (int)PsiActionList::Actions_MainWin;
 
168
 
 
169
                return (PsiActionList::ActionsType)ret;
 
170
        }
 
171
};
 
172
 
 
173
OptionsTabToolbars::OptionsTabToolbars(QObject *parent) 
 
174
: OptionsTab(parent, "toolbars", "", tr("Toolbars"), tr("Configure Psi toolbars"), "psi/toolbars")
 
175
{
 
176
        w = 0;
 
177
        p = new Private();
 
178
 
 
179
        noDirty = false;
 
180
        opt = new Options;
 
181
}
 
182
 
 
183
QWidget *OptionsTabToolbars::widget()
 
184
{
 
185
        if (w)
 
186
                return 0;
 
187
        
 
188
        w = new LookFeelToolbarsUI();
 
189
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI*) w;
 
190
        
 
191
        connect(d->pb_addToolbar, SIGNAL(clicked()), SLOT(toolbarAdd()));
 
192
        connect(d->pb_deleteToolbar, SIGNAL(clicked()), SLOT(toolbarDelete()));
 
193
        connect(d->cb_toolbars, SIGNAL(activated(int)), SLOT(toolbarSelectionChanged(int)));
 
194
        connect(d->le_toolbarName, SIGNAL(textChanged(const QString &)), SLOT(toolbarNameChanged()));
 
195
        connect(d->pb_toolbarPosition, SIGNAL(clicked()), SLOT(toolbarPosition()));
 
196
        connect(d->tb_up, SIGNAL(clicked()), SLOT(toolbarActionUp()));
 
197
        connect(d->tb_down, SIGNAL(clicked()), SLOT(toolbarActionDown()));
 
198
        connect(d->tb_right, SIGNAL(clicked()), SLOT(toolbarAddAction()));
 
199
        connect(d->tb_left, SIGNAL(clicked()), SLOT(toolbarRemoveAction()));
 
200
 
 
201
        connect(d->ck_toolbarOn, SIGNAL(toggled(bool)), SLOT(toolbarDataChanged()));
 
202
        connect(d->ck_toolbarLocked, SIGNAL(toggled(bool)), SLOT(toolbarDataChanged()));
 
203
        connect(d->ck_toolbarStretch, SIGNAL(toggled(bool)), SLOT(toolbarDataChanged()));
 
204
        connect(d->lw_selectedActions, SIGNAL(currentItemChanged(QListWidgetItem *, QListWidgetItem *)), SLOT(selAct_selectionChanged(QListWidgetItem *)));
 
205
        connect(d->tw_availActions, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)), SLOT(avaAct_selectionChanged(QTreeWidgetItem *)));
 
206
 
 
207
        connect(d->pb_deleteToolbar, SIGNAL(clicked()), SIGNAL(dataChanged()));
 
208
        connect(d->tb_up, SIGNAL(clicked()), SIGNAL(dataChanged()));
 
209
        connect(d->tb_down, SIGNAL(clicked()), SIGNAL(dataChanged()));
 
210
        connect(d->tb_left, SIGNAL(clicked()), SIGNAL(dataChanged()));
 
211
        connect(d->tb_right, SIGNAL(clicked()), SIGNAL(dataChanged()));
 
212
        connect(d->pb_addToolbar, SIGNAL(clicked()), SIGNAL(dataChanged()));
 
213
        connect(d->pb_deleteToolbar, SIGNAL(clicked()), SIGNAL(dataChanged()));
 
214
 
 
215
        d->tw_availActions->header()->hide();
 
216
 
 
217
        return w;
 
218
        // TODO: add QWhatsThis to all widgets
 
219
        /*
 
220
        QFrame *line = new QFrame( this );
 
221
        line->setFrameShape( QFrame::HLine );
 
222
        line->setFrameShadow( QFrame::Sunken );
 
223
        line->setFrameShape( QFrame::HLine );
 
224
        vbox->addWidget( line );
 
225
 
 
226
        QHBoxLayout *hbox = new QHBoxLayout( 0, 0, 6 );
 
227
        vbox->addLayout(hbox);
 
228
 
 
229
        QSpacerItem *spacer = new QSpacerItem( 40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
 
230
        hbox->addItem( spacer );
 
231
 
 
232
        IconButton *pb_ok = new IconButton( this );
 
233
        hbox->addWidget( pb_ok );
 
234
        pb_ok->setText( tr("&OK") );
 
235
        connect(pb_ok, SIGNAL(clicked()), SLOT(doApply()));
 
236
        connect(pb_ok, SIGNAL(clicked()), SLOT(accept()));
 
237
 
 
238
        //pb_apply = 0;
 
239
        pb_apply = new IconButton( this );
 
240
        hbox->addWidget( pb_apply );
 
241
        pb_apply->setText( tr("&Apply") );
 
242
        connect(pb_apply, SIGNAL(clicked()), SLOT(doApply()));
 
243
        pb_apply->setEnabled(false);
 
244
 
 
245
        IconButton *pb_cancel = new IconButton( this );
 
246
        hbox->addWidget( pb_cancel );
 
247
        pb_cancel->setText( tr("&Cancel") );
 
248
        connect(pb_cancel, SIGNAL(clicked()), SLOT(reject()));
 
249
 
 
250
        restoreOptions( &option );
 
251
        resize( minimumSize() );*/
 
252
}
 
253
 
 
254
OptionsTabToolbars::~OptionsTabToolbars()
 
255
{
 
256
        delete opt;
 
257
        delete p;
 
258
}
 
259
 
 
260
/**
 
261
 * setData is called by the OptionsDlg private, after calling
 
262
 * the constructor, to assign the PsiCon object and the parent window
 
263
 * to all tabs.
 
264
 * /par psi_: PsiCon* object to apply the changes when needed
 
265
 * /par parent_: QWidget which is parent from the current object
 
266
 */
 
267
void OptionsTabToolbars::setData(PsiCon * psi_, QWidget *parent_)
 
268
{
 
269
        // the Psi con object is needed to apply the changes
 
270
        // the parent object is needed to show some popups
 
271
        psi  = psi_;
 
272
        parent = parent_;
 
273
}
 
274
 
 
275
/*void OptionsTabToolbars::setCurrentToolbar(PsiToolBar *t)
 
276
{
 
277
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
278
 
 
279
        if ( pb_apply->isEnabled() )
 
280
                return;
 
281
 
 
282
        QMap<int, Private::ToolbarItem>::Iterator it = p->toolbars.begin();
 
283
        for ( ; it != p->toolbars.end(); ++it ) {
 
284
                if ( it.data().group == t->group() && it.data().index == t->groupIndex() ) {
 
285
                        d->cb_toolbars->setCurrentIndex( it.key() );
 
286
                        toolbarSelectionChanged( it.key() );
 
287
                        break;
 
288
                }
 
289
        }
 
290
}*/
 
291
 
 
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 );
 
348
        }
 
349
        else
 
350
                toolbarSelectionChanged( -1 );
 
351
}
 
352
 
 
353
//----------------------------------------------------------------------------
 
354
 
 
355
void OptionsTabToolbars::toolbarAdd()
 
356
{
 
357
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
358
 
 
359
        int i = d->cb_toolbars->count();
 
360
 
 
361
        Options::ToolbarPrefs tb;
 
362
        tb.name = QObject::tr("<unnamed>");
 
363
        tb.on = false;
 
364
        tb.locked = false;
 
365
        tb.stretchable = false;
 
366
        tb.keys.clear();
 
367
 
 
368
        tb.dock = Qt::DockTop;
 
369
        tb.index = i;
 
370
        tb.nl = true;
 
371
        tb.extraOffset = 0;
 
372
 
 
373
        tb.dirty = true;
 
374
 
 
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() );
 
380
 
 
381
        d->le_toolbarName->setFocus();
 
382
}
 
383
 
 
384
void OptionsTabToolbars::toolbarDelete()
 
385
{
 
386
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
387
        int n = d->cb_toolbars->currentIndex();
 
388
 
 
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
        }
 
403
}
 
404
 
 
405
void OptionsTabToolbars::addToolbarAction(QListWidget *parent, QString name, int toolbarId)
 
406
{
 
407
        ActionList actions = psi->actionList()->suitableActions( (PsiActionList::ActionsType)toolbarId );
 
408
        const QAction *action = (QAction *)actions.action( name );
 
409
        if ( !action )
 
410
                return;
 
411
        addToolbarAction(parent, action, name);
 
412
}
 
413
 
 
414
void OptionsTabToolbars::addToolbarAction(QListWidget *parent, const QAction *action, QString name)
 
415
{
 
416
        QListWidgetItem *item = new QListWidgetItem(parent);
 
417
 
 
418
        QString n = actionName(action);
 
419
        if ( !action->whatsThis().isEmpty() )
 
420
                n += " - " + action->whatsThis();
 
421
        item->setText(n);
 
422
        item->setData(Qt::UserRole, name);
 
423
        item->setIcon(action->iconSet());
 
424
}
 
425
 
 
426
void OptionsTabToolbars::toolbarSelectionChanged(int item)
 
427
{
 
428
        if ( noDirty )
 
429
                return;
 
430
 
 
431
        int n = item;
 
432
        PsiToolBar *toolBar = 0;
 
433
        if ( item != -1 )
 
434
                toolBar = psi->findToolBar( p->toolbars[n].group, p->toolbars[n].index );
 
435
 
 
436
        bool customizeable = toolBar ? toolBar->isCustomizeable() : true;
 
437
        bool moveable      = toolBar ? toolBar->isMoveable() : true;
 
438
 
 
439
        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 );
 
454
 
 
455
        d->tw_availActions->clear();
 
456
        d->lw_selectedActions->clear();
 
457
 
 
458
        if ( !enable ) {
 
459
                d->le_toolbarName->setText( "" );
 
460
                return;
 
461
        }
 
462
 
 
463
        noDirty = true;
 
464
 
 
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 );
 
470
 
 
471
        {
 
472
                // Fill the TreeWidget with toolbar-specific actions
 
473
                QTreeWidget *tw = d->tw_availActions;
 
474
                QTreeWidgetItem *lastRoot = 0;
 
475
 
 
476
                foreach(ActionList* actionList, psi->actionList()->actionLists( p->class2id( p->toolbars[n].group ) )) {
 
477
                        QTreeWidgetItem *root = new QTreeWidgetItem(tw, lastRoot);
 
478
                        lastRoot = root;
 
479
                        root->setText( 0, actionList->name() );
 
480
                        root->setData( 0, Qt::UserRole, QString("") );
 
481
                        root->setExpanded( true );
 
482
 
 
483
                        QTreeWidgetItem *last = 0;
 
484
                        QStringList actionNames = actionList->actions();
 
485
                        QStringList::Iterator it2 = actionNames.begin();
 
486
                        for ( ; it2 != actionNames.end(); ++it2 ) {
 
487
                                IconAction *action = actionList->action( *it2 );
 
488
                                QTreeWidgetItem *item = new QTreeWidgetItem( root, last );
 
489
                                last = item;
 
490
 
 
491
                                QString n = actionName((QAction *)action);
 
492
                                if ( !action->whatsThis().isEmpty() )
 
493
                                        n += " - " + action->whatsThis();
 
494
                                item->setText( 0, n );
 
495
                                item->setIcon( 0, action->iconSet() );
 
496
                                item->setData( 0, Qt::UserRole, action->name() );
 
497
                        }
 
498
                }
 
499
                tw->resizeColumnToContents(0);
 
500
        }
 
501
 
 
502
        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 ) );
 
505
        }
 
506
        updateArrows();
 
507
 
 
508
        noDirty = false;
 
509
}
 
510
 
 
511
void OptionsTabToolbars::rebuildToolbarKeys()
 
512
{
 
513
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
514
        if ( !d->cb_toolbars->count() )
 
515
                return;
 
516
        int n = d->cb_toolbars->currentIndex();
 
517
 
 
518
        QStringList keys;
 
519
 
 
520
        int count = d->lw_selectedActions->count();
 
521
        for (int i = 0; i < count; i++) {
 
522
                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;
 
527
        emit dataChanged();
 
528
}
 
529
 
 
530
void OptionsTabToolbars::updateArrows()
 
531
{
 
532
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
533
        bool up = false, down = false, left = false, right = false;
 
534
 
 
535
        if(d->tw_availActions->currentItem() && !d->tw_availActions->currentItem()->data(0, Qt::UserRole).toString().isEmpty())
 
536
                right = true;
 
537
        QListWidgetItem *i = d->lw_selectedActions->currentItem();
 
538
        if(i) {
 
539
                left = true;
 
540
 
 
541
                // get numeric index of item
 
542
                int n = d->lw_selectedActions->row(i);
 
543
 
 
544
                if(n > 0)
 
545
                        up = true;
 
546
                if(n < d->lw_selectedActions->count() - 1)
 
547
                        down = true;
 
548
        }
 
549
 
 
550
        d->tb_up->setEnabled(up);
 
551
        d->tb_down->setEnabled(down);
 
552
        d->tb_left->setEnabled(left);
 
553
        d->tb_right->setEnabled(right);
 
554
}
 
555
 
 
556
void OptionsTabToolbars::toolbarNameChanged()
 
557
{
 
558
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
559
        if ( !d->cb_toolbars->count() )
 
560
                return;
 
561
 
 
562
        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();
 
565
 
 
566
        emit dataChanged();
 
567
}
 
568
 
 
569
void OptionsTabToolbars::toolbarActionUp()
 
570
{
 
571
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
572
        QListWidgetItem *item = d->lw_selectedActions->currentItem();
 
573
        if ( !item )
 
574
                return;
 
575
 
 
576
        int row = d->lw_selectedActions->row(item);
 
577
        if ( row > 0 ) {
 
578
                d->lw_selectedActions->takeItem(row);
 
579
                d->lw_selectedActions->insertItem(row - 1, item);
 
580
                d->lw_selectedActions->setCurrentItem(item);
 
581
        }
 
582
 
 
583
        rebuildToolbarKeys();
 
584
        updateArrows();
 
585
}
 
586
 
 
587
void OptionsTabToolbars::toolbarActionDown()
 
588
{
 
589
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
590
        QListWidgetItem *item = d->lw_selectedActions->currentItem();
 
591
        if ( !item )
 
592
                return;
 
593
 
 
594
        int row = d->lw_selectedActions->row(item);
 
595
        if ( row < d->lw_selectedActions->count() ) {
 
596
                d->lw_selectedActions->takeItem(row);
 
597
                d->lw_selectedActions->insertItem(row + 1, item);
 
598
                d->lw_selectedActions->setCurrentItem(item);
 
599
        }
 
600
 
 
601
        rebuildToolbarKeys();
 
602
        updateArrows();
 
603
}
 
604
 
 
605
void OptionsTabToolbars::toolbarAddAction()
 
606
{
 
607
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
608
        QTreeWidgetItem *item = d->tw_availActions->currentItem();
 
609
        if ( !item || item->data(0, Qt::UserRole).toString().isEmpty() )
 
610
                return;
 
611
 
 
612
        addToolbarAction(d->lw_selectedActions, item->data(0, Qt::UserRole).toString(), p->class2id( p->toolbars[d->cb_toolbars->currentIndex()].group ) );
 
613
        rebuildToolbarKeys();
 
614
        updateArrows();
 
615
}
 
616
 
 
617
void OptionsTabToolbars::toolbarRemoveAction()
 
618
{
 
619
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
620
        QListWidgetItem *item = d->lw_selectedActions->currentItem();
 
621
        if ( !item )
 
622
                return;
 
623
 
 
624
        delete item;
 
625
 
 
626
        rebuildToolbarKeys();
 
627
        updateArrows();
 
628
}
 
629
 
 
630
void OptionsTabToolbars::toolbarDataChanged()
 
631
{
 
632
        if ( noDirty )
 
633
                return;
 
634
 
 
635
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
636
        if ( !d->cb_toolbars->count() )
 
637
                return;
 
638
        int n = d->cb_toolbars->currentIndex();
 
639
 
 
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();
 
645
 
 
646
        emit dataChanged();
 
647
}
 
648
 
 
649
QString OptionsTabToolbars::actionName(const QAction *a)
 
650
{
 
651
        QString n = a->menuText(), n2;
 
652
        for (int i = 0; i < (int)n.length(); i++) {
 
653
                if ( n[i] == '&' && n[i+1] != '&' )
 
654
                        continue;
 
655
                else if ( n[i] == '&' && n[i+1] == '&' )
 
656
                        n2 += '&';
 
657
                else
 
658
                        n2 += n[i];
 
659
        }
 
660
 
 
661
        return n2;
 
662
}
 
663
 
 
664
void OptionsTabToolbars::toolbarPosition()
 
665
{
 
666
        LookFeelToolbarsUI *d = (LookFeelToolbarsUI *)w;
 
667
        if ( !d->cb_toolbars->count() )
 
668
                return;
 
669
        int n = d->cb_toolbars->currentIndex();
 
670
 
 
671
        PositionOptionsTabToolbars *posTbDlg = new PositionOptionsTabToolbars(w, &opt->toolbars["mainWin"][n], n);
 
672
        connect(posTbDlg, SIGNAL(applyPressed()), SLOT(toolbarPositionApply()));
 
673
 
 
674
        posTbDlg->exec();
 
675
        delete posTbDlg;
 
676
}
 
677
 
 
678
void OptionsTabToolbars::toolbarPositionApply()
 
679
{
 
680
        emit dataChanged();
 
681
 
 
682
        option.toolbars = opt->toolbars;
 
683
        psi->buildToolbars();
 
684
}
 
685
 
 
686
void OptionsTabToolbars::doApply()
 
687
{
 
688
        option.toolbars = opt->toolbars;
 
689
        psi->buildToolbars();
 
690
}
 
691
 
 
692
void OptionsTabToolbars::selAct_selectionChanged(QListWidgetItem *)
 
693
{
 
694
        updateArrows();
 
695
}
 
696
 
 
697
void OptionsTabToolbars::avaAct_selectionChanged(QTreeWidgetItem *)
 
698
{
 
699
        updateArrows();
 
700
}
 
701
 
 
702
#include "opt_toolbars.moc"