← Back to branch summary

~ubuntu-branches/ubuntu/trusty/kvirc/trusty-proposed

« back to all changes in this revision

Viewing changes to src/kvirc/ui/kvi_selectors.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Kai Wasserbäch, Kai Wasserbäch, Raúl Sánchez Siles
  • Date: 2011-02-12 10:40:21 UTC
  • mfrom: (14.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20110212104021-5mh4f75jlku20mnt
The combined "Twisted Experiment" and "Nocturnal Raid" release.

[ Kai Wasserbäch ]
* Synced to upstream's SVN revision 5467.
* debian/rules:
  - Added .PHONY line.
  - Resurrect -DMANUAL_REVISION, got lost somewhere and we build SVN
    revisions again.
  - Replace "-DWITH_NO_EMBEDDED_CODE=YES" with "-DWANT_CRYPTOPP=YES".
  - Change the remaining -DWITH/-DWITHOUT to the new -DWANT syntax.
* debian/control:
  - Removed DMUA, I'm a DD now.
  - Changed my e-mail address.
  - Removed unneeded relationships (no upgrades over two releases are
    supported).
  - Fix Suggests for kvirc-dbg.
  - kvirc-data: Make the "Suggests: kvirc" a Recommends, doesn't make much
    sense to install the -data package without the program.
* debian/source/local-options: Added with "unapply-patches".
* debian/kvirc.lintian-overrides: Updated to work for 4.1.1.
* debian/patches/21_make_shared-mime-info_B-D_superfluous.patch: Updated.
* debian/kvirc-data.install: Added .notifyrc.

[ Raúl Sánchez Siles ]
* Stating the right version where kvirc-data break and replace should happen.
* Fixing link to license file.
* Added French and Portuguese man pages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kvirc/ui/kvi_selectors.cpp
1
 
//=============================================================================
2
 
//
3
 
//   File : kvi_selectors.cpp
4
 
//   Creation date : Mon Nov 13 2000 15:22:12 CEST by Szymon Stefanek
5
 
//
6
 
//   This file is part of the KVirc irc client distribution
7
 
//   Copyright (C) 2000-2008 Szymon Stefanek (pragma at kvirc dot net)
8
 
//
9
 
//   This program is FREE software. You can redistribute it and/or
10
 
//   modify it under the terms of the GNU General Public License
11
 
//   as published by the Free Software Foundation; either version 2
12
 
//   of the License, or (at your opinion) any later version.
13
 
//
14
 
//   This program is distributed in the HOPE that it will be USEFUL,
15
 
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17
 
//   See the GNU General Public License for more details.
18
 
//
19
 
//   You should have received a copy of the GNU General Public License
20
 
//   along with this program. If not, write to the Free Software Foundation,
21
 
//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22
 
//
23
 
//=============================================================================
24
 
 
25
 
 
26
 
#define _KVI_SELECTORS_CPP_
27
 
 
28
 
#include "kvi_selectors.h"
29
 
#include "kvi_locale.h"
30
 
#include "kvi_options.h"
31
 
#include "kvi_mirccntrl.h"
32
 
#include "kvi_filedialog.h"
33
 
#include "kvi_kvs_script.h"
34
 
#include "kvi_tal_popupmenu.h"
35
 
 
36
 
#include <QLabel>
37
 
#include <QPainter>
38
 
#include <QLayout>
39
 
#include <QColorDialog>
40
 
#include <QPalette>
41
 
#include <QFontDialog>
42
 
#include <QAbstractItemView>
43
 
 
44
 
KviBoolSelector::KviBoolSelector(QWidget * par,const QString & txt,bool *pOption,bool bEnabled)
45
 
: QCheckBox(txt,par), KviSelectorInterface()
46
 
{
47
 
        setEnabled(bEnabled);
48
 
        setChecked(*pOption);
49
 
        m_pOption = pOption;
50
 
}
51
 
 
52
 
void KviBoolSelector::setEnabled(bool bEnabled)
53
 
{
54
 
        QCheckBox::setEnabled(bEnabled);
55
 
}
56
 
 
57
 
void KviBoolSelector::setNotEnabled(bool bNotEnabled)
58
 
{
59
 
        setEnabled(!bNotEnabled);
60
 
}
61
 
 
62
 
void KviBoolSelector::commit()
63
 
{
64
 
        *m_pOption = isChecked();
65
 
}
66
 
 
67
 
KviUIntSelector::KviUIntSelector(QWidget * par,const QString & txt,unsigned int *pOption,
68
 
        unsigned int uLowBound,unsigned int uHighBound,unsigned int uDefault,bool bEnabled,bool bShortInt)
69
 
: KviTalHBox(par) , KviSelectorInterface()
70
 
{
71
 
        m_pLabel = new QLabel(txt,this);
72
 
        //m_pLineEdit = new QLineEdit(this);
73
 
        //m_pLineEdit->setMaximumWidth(150);
74
 
        m_pSpinBox = new QSpinBox(this);
75
 
 
76
 
        m_bIsShortInt = bShortInt;
77
 
 
78
 
        setEnabled(bEnabled);
79
 
 
80
 
        m_pOption = pOption;
81
 
 
82
 
        m_uLowBound = uLowBound;
83
 
        m_uHighBound = uHighBound;
84
 
        m_uDefault = uDefault;
85
 
 
86
 
        m_pSpinBox->setMinimum(m_uLowBound);
87
 
        m_pSpinBox->setMaximum(m_uHighBound);
88
 
 
89
 
        //KviStr tmp(KviStr::Format,"%u",bShortInt ? (unsigned int) *((unsigned short int *)pOption) : *pOption);
90
 
        //m_pLineEdit->setText(tmp.ptr());
91
 
        m_pSpinBox->setValue(bShortInt ? (unsigned int) *((unsigned short int *)pOption) : *pOption);
92
 
 
93
 
        setSpacing(4);
94
 
        setStretchFactor(m_pLabel,1);
95
 
}
96
 
 
97
 
void KviUIntSelector::setPrefix(const QString & txt)
98
 
{
99
 
        m_pSpinBox->setPrefix(txt);
100
 
}
101
 
 
102
 
void KviUIntSelector::setSuffix(const QString & txt)
103
 
{
104
 
        m_pSpinBox->setSuffix(txt);
105
 
}
106
 
 
107
 
void KviUIntSelector::commit()
108
 
{
109
 
        KviStr tmp = m_pSpinBox->cleanText();
110
 
        bool bOk;
111
 
        unsigned int val = tmp.toUInt(&bOk);
112
 
        if(!bOk)val = m_uDefault;
113
 
        if(m_uHighBound > m_uLowBound)
114
 
        {
115
 
                if(val < m_uLowBound)val = m_uLowBound;
116
 
                else if(val > m_uHighBound)val = m_uHighBound;
117
 
        }
118
 
 
119
 
        if(m_bIsShortInt)*((unsigned short int *)m_pOption) = (unsigned short int)val;
120
 
        else *m_pOption = val;
121
 
}
122
 
 
123
 
void KviUIntSelector::setEnabled(bool bEnabled)
124
 
{
125
 
        KviTalHBox::setEnabled(bEnabled);
126
 
        m_pLabel->setEnabled(bEnabled);
127
 
        m_pSpinBox->setEnabled(bEnabled);
128
 
}
129
 
 
130
 
 
131
 
KviStringSelector::KviStringSelector(QWidget * par,const QString & txt,QString * pOption,bool bEnabled)
132
 
: KviTalHBox(par) , KviSelectorInterface()
133
 
{
134
 
        m_pLabel = new QLabel(txt,this);
135
 
        m_pLineEdit = new QLineEdit(this);
136
 
        //m_pLineEdit->setMinimumWidth(200);
137
 
        QString tmp = *pOption;
138
 
        m_pLineEdit->setText(tmp);
139
 
 
140
 
        setSpacing(4);
141
 
        setStretchFactor(m_pLineEdit,1);
142
 
 
143
 
        m_pOption = pOption;
144
 
 
145
 
        setEnabled(bEnabled);
146
 
}
147
 
 
148
 
KviStringSelector::~KviStringSelector()
149
 
{
150
 
}
151
 
 
152
 
void KviStringSelector::commit()
153
 
{
154
 
        QString tmp = m_pLineEdit->text();
155
 
        *m_pOption = tmp;
156
 
}
157
 
 
158
 
void KviStringSelector::setEnabled(bool bEnabled)
159
 
{
160
 
        KviTalHBox::setEnabled(bEnabled);
161
 
        m_pLineEdit->setEnabled(bEnabled);
162
 
        m_pLabel->setEnabled(bEnabled);
163
 
}
164
 
 
165
 
void KviStringSelector::setText(const QString& text){
166
 
        m_pLineEdit->setText(text);
167
 
}
168
 
 
169
 
KviPasswordSelector::KviPasswordSelector(QWidget * par,const QString & txt,QString *pOption,bool bEnabled)
170
 
: KviTalHBox(par) , KviSelectorInterface()
171
 
{
172
 
        setSpacing(0);
173
 
        setMargin(0);
174
 
 
175
 
        m_pLabel = new QLabel(txt,this);
176
 
        m_pLineEdit = new QLineEdit(this);
177
 
        addSpacing(4);
178
 
        m_pCheckBox = new QCheckBox(this);
179
 
        m_pLineEdit->setEchoMode(QLineEdit::Password);
180
 
        m_pCheckBox->setCheckState(Qt::Checked);
181
 
        connect(m_pCheckBox,SIGNAL(stateChanged(int)), this, SLOT(checkToggled(int)));
182
 
        //m_pLineEdit->setMinimumWidth(200);
183
 
        QString tmp = *pOption;
184
 
        m_pLineEdit->setText(tmp);
185
 
 
186
 
        setStretchFactor(m_pLineEdit,1);
187
 
 
188
 
        m_pOption = pOption;
189
 
 
190
 
        setEnabled(bEnabled);
191
 
}
192
 
 
193
 
void KviPasswordSelector::checkToggled(int state)
194
 
{
195
 
        if(state == Qt::Checked)
196
 
        {
197
 
                m_pLineEdit->setEchoMode(QLineEdit::Password);
198
 
        } else {
199
 
                m_pLineEdit->setEchoMode(QLineEdit::Normal);
200
 
        }
201
 
}
202
 
 
203
 
KviPasswordSelector::~KviPasswordSelector()
204
 
{
205
 
}
206
 
 
207
 
void KviPasswordSelector::commit()
208
 
{
209
 
        QString tmp = m_pLineEdit->text();
210
 
        *m_pOption = tmp;
211
 
}
212
 
 
213
 
void KviPasswordSelector::setEnabled(bool bEnabled)
214
 
{
215
 
        KviTalHBox::setEnabled(bEnabled);
216
 
        m_pLineEdit->setEnabled(bEnabled);
217
 
        m_pLabel->setEnabled(bEnabled);
218
 
        m_pCheckBox->setEnabled(bEnabled);
219
 
}
220
 
 
221
 
void KviPasswordSelector::setText(const QString& text){
222
 
        m_pLineEdit->setText(text);
223
 
}
224
 
 
225
 
KviPasswordLineEdit::KviPasswordLineEdit(QWidget * par)
226
 
: KviTalHBox(par)
227
 
{
228
 
        setSpacing(0);
229
 
        setMargin(0);
230
 
 
231
 
        m_pLineEdit = new QLineEdit(this);
232
 
        addSpacing(4);
233
 
        m_pCheckBox = new QCheckBox(this);
234
 
        m_pLineEdit->setEchoMode(QLineEdit::Password);
235
 
        m_pCheckBox->setCheckState(Qt::Checked);
236
 
        connect(m_pCheckBox,SIGNAL(stateChanged(int)), this, SLOT(checkToggled(int)));
237
 
        //m_pLineEdit->setMinimumWidth(200);
238
 
        setStretchFactor(m_pLineEdit,1);
239
 
}
240
 
 
241
 
void KviPasswordLineEdit::checkToggled(int state)
242
 
{
243
 
        if(state == Qt::Checked)
244
 
        {
245
 
                m_pLineEdit->setEchoMode(QLineEdit::Password);
246
 
        } else {
247
 
                m_pLineEdit->setEchoMode(QLineEdit::Normal);
248
 
        }
249
 
}
250
 
 
251
 
KviPasswordLineEdit::~KviPasswordLineEdit()
252
 
{
253
 
}
254
 
 
255
 
QString KviPasswordLineEdit::text()
256
 
{
257
 
        return m_pLineEdit->text();
258
 
}
259
 
 
260
 
void KviPasswordLineEdit::setEnabled(bool bEnabled)
261
 
{
262
 
        KviTalHBox::setEnabled(bEnabled);
263
 
        m_pLineEdit->setEnabled(bEnabled);
264
 
        m_pCheckBox->setEnabled(bEnabled);
265
 
}
266
 
 
267
 
void KviPasswordLineEdit::setText(const QString& text){
268
 
        m_pLineEdit->setText(text);
269
 
}
270
 
 
271
 
KviPixmapPreview::KviPixmapPreview(QWidget * par)
272
 
: QScrollArea(par)
273
 
{
274
 
        m_pLabPixmap = new QLabel(this);
275
 
        setWidget(m_pLabPixmap);
276
 
        setBackgroundRole(QPalette::Dark);
277
 
}
278
 
 
279
 
KviPixmapPreview::~KviPixmapPreview()
280
 
{
281
 
        //delete m_pLabPixmap;
282
 
}
283
 
 
284
 
void KviPixmapPreview::setPixmap(KviPixmap * pix)
285
 
{
286
 
        if(!pix->isNull())
287
 
        {
288
 
                m_pLabPixmap->resize(pix->pixmap()->size());
289
 
                m_pLabPixmap->setPixmap(*pix->pixmap());
290
 
                //setWidget(m_pLabPixmap);
291
 
        }
292
 
}
293
 
 
294
 
KviPixmapSelector::KviPixmapSelector(QWidget * par,const QString & txt,KviPixmap * pOption,bool bEnabled)
295
 
: QWidget(par), KviSelectorInterface()
296
 
{
297
 
        QGridLayout * g = new QGridLayout(this);
298
 
        m_pOption = pOption;
299
 
 
300
 
        m_localPixmap = *pOption;
301
 
 
302
 
        m_pCheckBox = new QCheckBox(txt,this);
303
 
        m_pCheckBox->setChecked(m_localPixmap.pixmap());
304
 
        connect(m_pCheckBox,SIGNAL(toggled(bool)),this,SLOT(checkBoxToggled(bool)));
305
 
 
306
 
        g->addWidget(m_pCheckBox,0,0,1,2);
307
 
//      g->addMultiCellWidget(m_pCheckBox,0,0,0,1);
308
 
 
309
 
        m_pPreview = new KviPixmapPreview(this);
310
 
        m_pPreview->setPixmap(&m_localPixmap);
311
 
        g->addWidget(m_pPreview,1,0,1,2);
312
 
//      g->addMultiCellWidget(m_pPreview,1,1,0,1);
313
 
 
314
 
        m_pFileNameLabel = new QLabel(this);
315
 
        m_pFileNameLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
316
 
        if(m_localPixmap.pixmap())m_pFileNameLabel->setText(m_localPixmap.path());
317
 
        g->addWidget(m_pFileNameLabel,2,0);
318
 
 
319
 
        m_pChooseButton = new QPushButton("...",this);
320
 
        g->addWidget(m_pChooseButton,2,1);
321
 
        connect(m_pChooseButton,SIGNAL(clicked()),this,SLOT(choosePixmap()));
322
 
 
323
 
        g->setRowStretch(1,1);
324
 
        g->setColumnStretch(0,1);
325
 
 
326
 
        setEnabled(bEnabled);
327
 
}
328
 
 
329
 
KviPixmapSelector::~KviPixmapSelector()
330
 
{
331
 
}
332
 
 
333
 
 
334
 
void KviPixmapSelector::checkBoxToggled(bool)
335
 
{
336
 
        setEnabled(isEnabled());
337
 
}
338
 
 
339
 
void KviPixmapSelector::commit()
340
 
{
341
 
        if(m_pCheckBox->isChecked())
342
 
        {
343
 
                *m_pOption = m_localPixmap;
344
 
        } else {
345
 
                *m_pOption = KviPixmap(); // null pixmap
346
 
        }
347
 
}
348
 
 
349
 
void KviPixmapSelector::choosePixmap()
350
 
{
351
 
        QString tmp;
352
 
        if(KviFileDialog::askForOpenFileName(tmp,__tr("Choose an Image File - KVIrc")))
353
 
        {
354
 
                setImagePath(tmp);
355
 
        }
356
 
}
357
 
 
358
 
void KviPixmapSelector::setImagePath(const QString &path)
359
 
{
360
 
        m_localPixmap.load(path);
361
 
        m_pPreview->setPixmap(&m_localPixmap);
362
 
 
363
 
        if(m_localPixmap.isNull())
364
 
        {
365
 
                QString tmp = __tr2qs("Unloadable");
366
 
                tmp += ": ";
367
 
                tmp += path;
368
 
                m_pFileNameLabel->setText(tmp);
369
 
                m_pCheckBox->setChecked(false);
370
 
        } else {
371
 
                m_pCheckBox->setChecked(true);
372
 
                m_pFileNameLabel->setText(path);
373
 
        }
374
 
 
375
 
        setEnabled(isEnabled());
376
 
}
377
 
 
378
 
void KviPixmapSelector::setEnabled(bool bEnabled)
379
 
{
380
 
        QWidget::setEnabled(bEnabled);
381
 
        m_pCheckBox->setEnabled(bEnabled);
382
 
        m_pPreview->setEnabled(bEnabled && m_pCheckBox->isChecked());
383
 
        m_pFileNameLabel->setEnabled(bEnabled && m_pCheckBox->isChecked());
384
 
        m_pChooseButton->setEnabled(bEnabled && m_pCheckBox->isChecked());
385
 
}
386
 
 
387
 
 
388
 
// FIXME: #warning "Option for DIR_MUST_EXISTS...(this widget could be turned into a file selector too)"
389
 
KviFileSelector::KviFileSelector(QWidget * par,const QString & txt,QString * pOption,bool bEnabled,unsigned int uFlags,const QString &szFilter)
390
 
: QWidget(par), KviSelectorInterface()
391
 
{
392
 
        m_Layout = new QGridLayout(this);
393
 
 
394
 
        m_uFlags = uFlags;
395
 
        m_szFilter = szFilter;
396
 
        m_pLabel = new QLabel(txt,this);
397
 
        
398
 
        if(uFlags & VerticalLayout)
399
 
                m_Layout->addWidget(m_pLabel,0,0,1,2);
400
 
        else
401
 
                m_Layout->addWidget(m_pLabel,0,0);
402
 
        
403
 
        m_pLineEdit = new QLineEdit(this);
404
 
        
405
 
        if(uFlags & VerticalLayout)
406
 
                m_Layout->addWidget(m_pLineEdit,1,0);
407
 
        else
408
 
                m_Layout->addWidget(m_pLineEdit,0,1);
409
 
        
410
 
        //m_pLineEdit->setMinimumWidth(200);
411
 
        m_pLineEdit->setText(*pOption);
412
 
        
413
 
        m_pButton = new QPushButton(__tr2qs("&Browse..."),this);
414
 
        connect(m_pButton,SIGNAL(clicked()),this,SLOT(browseClicked()));
415
 
 
416
 
        if(uFlags & VerticalLayout)
417
 
                m_Layout->addWidget(m_pButton,1,1);
418
 
        else
419
 
                m_Layout->addWidget(m_pButton,0,2);
420
 
 
421
 
        m_Layout->setSpacing(4);
422
 
 
423
 
        if(uFlags & VerticalLayout)
424
 
                m_Layout->setColumnStretch(0,1);
425
 
        else
426
 
                m_Layout->setColumnStretch(1,1);
427
 
 
428
 
        m_pOption = pOption;
429
 
 
430
 
        setEnabled(bEnabled);
431
 
}
432
 
 
433
 
void KviFileSelector::commit()
434
 
{
435
 
        *m_pOption = m_pLineEdit->text();
436
 
}
437
 
 
438
 
void KviFileSelector::setEnabled(bool bEnabled)
439
 
{
440
 
        QWidget::setEnabled(bEnabled);
441
 
        m_pLineEdit->setEnabled(bEnabled);
442
 
        m_pLabel->setEnabled(bEnabled);
443
 
        m_pButton->setEnabled(bEnabled);
444
 
}
445
 
 
446
 
void KviFileSelector::browseClicked()
447
 
{
448
 
        select();
449
 
}
450
 
 
451
 
void KviFileSelector::setSelection(const QString &szSelection)
452
 
{
453
 
        m_pLineEdit->setText(szSelection);
454
 
}
455
 
 
456
 
void KviFileSelector::select()
457
 
{
458
 
        //KviStr tmp;
459
 
        QString tmp = *m_pOption;
460
 
        if(m_uFlags & ChooseSaveFileName)
461
 
        {
462
 
                if(KviFileDialog::askForSaveFileName(tmp,__tr2qs("Choose a File - KVIrc"),tmp,m_szFilter,true,!(m_uFlags & DontConfirmOverwrite)))
463
 
                {
464
 
                        m_pLineEdit->setText(tmp);
465
 
                        emit selectionChanged(tmp);
466
 
                }
467
 
        } else {
468
 
                if(KviFileDialog::askForOpenFileName(tmp,__tr2qs("Choose a File - KVIrc"),tmp,m_szFilter,true))
469
 
                {
470
 
                        m_pLineEdit->setText(tmp);
471
 
                        emit selectionChanged(tmp);
472
 
                }
473
 
        }
474
 
}
475
 
 
476
 
 
477
 
KviDirectorySelector::KviDirectorySelector(QWidget * par,const QString & txt,QString * pOption,bool bEnabled,unsigned int uFlags)
478
 
: KviFileSelector(par,txt,pOption,bEnabled,uFlags)
479
 
{
480
 
}
481
 
 
482
 
void KviDirectorySelector::select()
483
 
{
484
 
        QString szTmp;
485
 
        if(KviFileDialog::askForDirectoryName(szTmp,__tr2qs("Choose a Directory - KVIrc"),""))
486
 
        {
487
 
                m_pLineEdit->setText(szTmp);
488
 
                emit selectionChanged(szTmp);
489
 
        }
490
 
}
491
 
 
492
 
 
493
 
KviStringListSelector::KviStringListSelector(QWidget * par,const QString & txt,QStringList * pOption,bool bEnabled)
494
 
: KviTalVBox(par), KviSelectorInterface()
495
 
{
496
 
        m_pLabel = new QLabel(txt,this);
497
 
        m_pListWidget = new KviTalListWidget(this);
498
 
        m_pLineEdit = new QLineEdit(this);
499
 
        connect(m_pLineEdit,SIGNAL(textChanged(const QString &)),this,SLOT(textChanged(const QString &)));
500
 
        connect(m_pLineEdit,SIGNAL(returnPressed()),this,SLOT(addClicked()));
501
 
        KviTalHBox * hBox = new KviTalHBox(this);
502
 
        m_pAddButton = new QPushButton(__tr2qs("A&dd"),hBox);
503
 
        connect(m_pAddButton,SIGNAL(clicked()),this,SLOT(addClicked()));
504
 
        m_pRemoveButton = new QPushButton(__tr2qs("Re&move"),hBox);
505
 
        connect(m_pRemoveButton,SIGNAL(clicked()),this,SLOT(removeClicked()));
506
 
        m_pOption = pOption;
507
 
        m_pListWidget->addItems(*pOption);
508
 
        m_pListWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
509
 
        connect(m_pListWidget,SIGNAL(itemSelectionChanged()),this,SLOT(itemSelectionChanged()));
510
 
        setSpacing(4);
511
 
        setStretchFactor(m_pListWidget,1);
512
 
        setEnabled(bEnabled);
513
 
}
514
 
 
515
 
KviStringListSelector::~KviStringListSelector()
516
 
{
517
 
}
518
 
 
519
 
void KviStringListSelector::itemSelectionChanged()
520
 
{
521
 
        bool bSomeSelected ;
522
 
        if (m_pListWidget->selectedItems().count())  bSomeSelected = true;
523
 
        else bSomeSelected = false;
524
 
 
525
 
        m_pRemoveButton->setEnabled(isEnabled() && bSomeSelected);
526
 
}
527
 
 
528
 
void KviStringListSelector::textChanged(const QString &str)
529
 
{
530
 
        str.trimmed();
531
 
        m_pAddButton->setEnabled((str.length() > 0) && isEnabled());
532
 
}
533
 
 
534
 
void KviStringListSelector::setEnabled(bool bEnabled)
535
 
{
536
 
        KviTalVBox::setEnabled(bEnabled);
537
 
        m_pLineEdit->setEnabled(bEnabled);
538
 
        m_pLabel->setEnabled(bEnabled);
539
 
        QString txt = m_pLineEdit->text();
540
 
        txt.trimmed();
541
 
        m_pAddButton->setEnabled(bEnabled && (txt.length() > 0));
542
 
 
543
 
        bool bSomeSelected;
544
 
        if (m_pListWidget->selectedItems().count())  bSomeSelected = true;
545
 
        else bSomeSelected = false;
546
 
 
547
 
        m_pRemoveButton->setEnabled(bEnabled && bSomeSelected);
548
 
        m_pListWidget->setEnabled(bEnabled);
549
 
}
550
 
 
551
 
void KviStringListSelector::commit()
552
 
{
553
 
        unsigned int uCount = m_pListWidget->count();
554
 
        m_pOption->clear();
555
 
        for(unsigned int u=0;u<uCount;u++)
556
 
        {
557
 
                QString str = m_pListWidget->item(u)->text();
558
 
                str.trimmed();
559
 
                if(str.length() > 0)m_pOption->append(str);
560
 
        }
561
 
}
562
 
 
563
 
void KviStringListSelector::addClicked()
564
 
{
565
 
        QString str = m_pLineEdit->text();
566
 
        str.trimmed();
567
 
        if(str.length() > 0)m_pListWidget->insertItem(m_pListWidget->count(),str);
568
 
        m_pLineEdit->setText("");
569
 
}
570
 
 
571
 
void KviStringListSelector::removeClicked()
572
 
{
573
 
        int u=0;
574
 
        while(u<m_pListWidget->count())
575
 
        {
576
 
                if(m_pListWidget->item(u)->isSelected())
577
 
                {
578
 
                        m_pListWidget->takeItem(u);
579
 
                        continue;
580
 
                }
581
 
                u++;
582
 
        }
583
 
}
584
 
 
585
 
 
586
 
KviColorSelector::KviColorSelector(QWidget * par,const QString & txt,QColor * pOption,bool bEnabled)
587
 
: KviTalHBox(par), KviSelectorInterface()
588
 
{
589
 
        m_pLabel = new QLabel(txt,this);
590
 
 
591
 
        m_pButton = new QPushButton(" ",this);
592
 
        // m_pButton->setMinimumWidth(150);
593
 
        connect(m_pButton,SIGNAL(clicked()),this,SLOT(changeClicked()));
594
 
 
595
 
        setSpacing(4);
596
 
        setStretchFactor(m_pLabel,1);
597
 
 
598
 
        setButtonPalette(pOption);
599
 
 
600
 
        m_pOption = pOption;
601
 
 
602
 
        setEnabled(bEnabled);
603
 
}
604
 
 
605
 
void KviColorSelector::setButtonPalette(QColor * pOption)
606
 
{
607
 
        QPalette pal(*pOption,palette().background().color());
608
 
        m_memColor = *pOption;
609
 
        m_pButton->setPalette(pal);
610
 
 
611
 
        QPixmap pix(16,16);
612
 
        pix.fill(*pOption);
613
 
        m_pButton->setIcon(pix);
614
 
}
615
 
 
616
 
void KviColorSelector::forceColor(QColor clr)
617
 
{
618
 
        setButtonPalette(&clr);
619
 
}
620
 
 
621
 
void KviColorSelector::changeClicked()
622
 
{
623
 
        QColor tmp = QColorDialog::getColor(m_memColor);
624
 
        if(tmp.isValid())setButtonPalette(&tmp);
625
 
}
626
 
 
627
 
void KviColorSelector::commit()
628
 
{
629
 
        *m_pOption = m_memColor;
630
 
}
631
 
 
632
 
void KviColorSelector::setEnabled(bool bEnabled)
633
 
{
634
 
        KviTalHBox::setEnabled(bEnabled);
635
 
        m_pLabel->setEnabled(bEnabled);
636
 
        m_pButton->setEnabled(bEnabled);
637
 
}
638
 
 
639
 
 
640
 
KviFontSelector::KviFontSelector(QWidget * par,const QString & txt,QFont * pOption,bool bEnabled)
641
 
: KviTalHBox(par), KviSelectorInterface()
642
 
{
643
 
        m_pLabel = new QLabel(txt,this);
644
 
 
645
 
        m_pButton = new QPushButton("",this);
646
 
        // m_pButton->setMinimumWidth(150);
647
 
        connect(m_pButton,SIGNAL(clicked()),this,SLOT(changeClicked()));
648
 
 
649
 
        setSpacing(4);
650
 
        setStretchFactor(m_pLabel,1);
651
 
 
652
 
        setButtonFont(pOption);
653
 
 
654
 
        m_pOption = pOption;
655
 
 
656
 
        setEnabled(bEnabled);
657
 
}
658
 
 
659
 
void KviFontSelector::setButtonFont(QFont * pOption)
660
 
{
661
 
        m_pButton->setText(pOption->family());
662
 
        m_pButton->setFont(*pOption);
663
 
}
664
 
 
665
 
void KviFontSelector::changeClicked()
666
 
{
667
 
        bool bOk;
668
 
        QFont tmp = QFontDialog::getFont(&bOk,m_pButton->font());
669
 
        if(bOk)
670
 
                setButtonFont(&tmp);
671
 
}
672
 
 
673
 
void KviFontSelector::commit()
674
 
{
675
 
        *m_pOption = m_pButton->font();
676
 
}
677
 
 
678
 
void KviFontSelector::setEnabled(bool bEnabled)
679
 
{
680
 
        KviTalHBox::setEnabled(bEnabled);
681
 
        m_pLabel->setEnabled(bEnabled);
682
 
        m_pButton->setEnabled(bEnabled);
683
 
}
684
 
 
685
 
 
686
 
KviMircTextColorSelector::KviMircTextColorSelector(QWidget * par,const QString &txt,unsigned int * uFore,unsigned int * uBack,bool bEnabled)
687
 
: KviTalHBox(par), KviSelectorInterface()
688
 
{
689
 
        m_pLabel = new QLabel(txt,this);
690
 
 
691
 
        m_pButton = new QPushButton(__tr2qs("Sample Text"),this);
692
 
        // m_pButton->setMinimumWidth(150);
693
 
        connect(m_pButton,SIGNAL(clicked()),this,SLOT(buttonClicked()));
694
 
 
695
 
        setSpacing(4);
696
 
        setStretchFactor(m_pLabel,1);
697
 
 
698
 
        m_pUFore = uFore;
699
 
        m_pUBack = uBack;
700
 
 
701
 
        m_uBack = *uBack;
702
 
        m_uFore = *uFore;
703
 
 
704
 
        setButtonPalette();
705
 
 
706
 
        setEnabled(bEnabled);
707
 
 
708
 
        m_pContextPopup = new KviTalPopupMenu(this);
709
 
 
710
 
        m_pForePopup = new KviTalPopupMenu(this);
711
 
        connect(m_pForePopup,SIGNAL(activated(int)),this,SLOT(foreSelected(int)));
712
 
        int i;
713
 
        for(i=0;i<KVI_MIRCCOLOR_MAX_FOREGROUND;i++)
714
 
        {
715
 
                QPixmap tmp(120,16);
716
 
                tmp.fill(KVI_OPTION_MIRCCOLOR(i));
717
 
                int id = m_pForePopup->insertItem(tmp,QString("x"));
718
 
                m_pForePopup->setItemParameter(id,i);
719
 
        }
720
 
        m_pContextPopup->insertItem(__tr2qs("Foreground"),m_pForePopup);
721
 
 
722
 
        m_pBackPopup = new KviTalPopupMenu(this);
723
 
        connect(m_pBackPopup,SIGNAL(activated(int)),this,SLOT(backSelected(int)));
724
 
        i = m_pBackPopup->insertItem(__tr2qs("Transparent"));
725
 
        m_pBackPopup->setItemParameter(i,KVI_TRANSPARENT);
726
 
        for(i=0;i<KVI_MIRCCOLOR_MAX_BACKGROUND;i++)
727
 
        {
728
 
                QPixmap tmp(120,16);
729
 
                tmp.fill(KVI_OPTION_MIRCCOLOR(i));
730
 
                int id = m_pBackPopup->insertItem(tmp,QString("x"));
731
 
                m_pBackPopup->setItemParameter(id,i);
732
 
        }
733
 
        m_pContextPopup->insertItem(__tr2qs("Background"),m_pBackPopup);
734
 
}
735
 
 
736
 
KviMircTextColorSelector::~KviMircTextColorSelector()
737
 
{
738
 
}
739
 
 
740
 
void KviMircTextColorSelector::commit()
741
 
{
742
 
        *m_pUFore = m_uFore;
743
 
        *m_pUBack = m_uBack;
744
 
}
745
 
 
746
 
void KviMircTextColorSelector::setEnabled(bool bEnabled)
747
 
{
748
 
        KviTalHBox::setEnabled(bEnabled);
749
 
        m_pLabel->setEnabled(bEnabled);
750
 
        m_pButton->setEnabled(bEnabled);
751
 
}
752
 
 
753
 
void KviMircTextColorSelector::setButtonPalette()
754
 
{
755
 
        QPalette pal;
756
 
 
757
 
        if(m_uBack > KVI_MIRCCOLOR_MAX_BACKGROUND)
758
 
        {
759
 
                if(m_uBack != KVI_TRANSPARENT)m_uBack = KVI_TRANSPARENT;
760
 
                pal = palette();
761
 
        } else {
762
 
                pal = QPalette(KVI_OPTION_MIRCCOLOR(m_uBack));
763
 
        }
764
 
 
765
 
        if(m_uFore > KVI_MIRCCOLOR_MAX_FOREGROUND)m_uFore = KVI_MIRCCOLOR_MAX_FOREGROUND;
766
 
 
767
 
        pal.setColor(QPalette::ButtonText,KVI_OPTION_MIRCCOLOR(m_uFore));
768
 
        pal.setColor(QPalette::Text,KVI_OPTION_MIRCCOLOR(m_uFore));
769
 
 
770
 
        m_pButton->setPalette(pal);
771
 
}
772
 
 
773
 
void KviMircTextColorSelector::buttonClicked()
774
 
{
775
 
        QPoint p = m_pButton->mapToGlobal(QPoint(0,m_pButton->height()));
776
 
        m_pContextPopup->popup(p);
777
 
}
778
 
 
779
 
void KviMircTextColorSelector::foreSelected(int id)
780
 
{
781
 
        if(m_pForePopup)
782
 
                m_uFore = m_pForePopup->itemParameter(id);
783
 
        setButtonPalette();
784
 
}
785
 
 
786
 
void KviMircTextColorSelector::backSelected(int id)
787
 
{
788
 
        if(m_pBackPopup)
789
 
                m_uBack = m_pBackPopup->itemParameter(id);
790
 
        setButtonPalette();
791
 
}
792
 
 
793
 
KviSoundSelector::KviSoundSelector(QWidget * par,const QString & txt,QString * pOption,bool bEnabled)
794
 
:KviFileSelector(par,txt,pOption,bEnabled)
795
 
{
796
 
        m_pPlayButton =  new QPushButton(__tr2qs("Play"),this);
797
 
        connect(m_pPlayButton,SIGNAL(clicked()),this,SLOT(playSound()));
798
 
        
799
 
        //parent layout
800
 
        if(m_uFlags & VerticalLayout)
801
 
                m_Layout->addWidget(m_pPlayButton,2,1);
802
 
        else
803
 
                m_Layout->addWidget(m_pPlayButton,0,3);
804
 
}
805
 
 
806
 
KviSoundSelector::~KviSoundSelector()
807
 
{
808
 
}
809
 
 
810
 
void KviSoundSelector::playSound()
811
 
{
812
 
        KviKvsScript::run("snd.play $0",0,new KviKvsVariantList(new KviKvsVariant(m_pLineEdit->text())));
813
 
}
814
 
 
815
 
void KviSoundSelector::setEnabled(bool bEnabled)
816
 
{
817
 
        KviFileSelector::setEnabled(bEnabled);
818
 
        m_pPlayButton->setEnabled(bEnabled);
819
 
}
820
 
 
821
 
KviChanTreeViewItem::KviChanTreeViewItem(QTreeWidget* pList,QString szChan,QString szPass)
822
 
:QTreeWidgetItem(pList)
823
 
{
824
 
        m_szPass=szPass;
825
 
        QString mask;
826
 
        mask.fill('*',szPass.length());
827
 
        setText(0,szChan);
828
 
        setText(1,mask);
829
 
}
830
 
 
831
 
KviChannelListSelector::KviChannelListSelector(QWidget * par,const QString & txt,QStringList * pOption,bool bEnabled)
832
 
: KviTalVBox(par), KviSelectorInterface()
833
 
{
834
 
        m_pLabel = new QLabel(txt,this);
835
 
        m_pTreeWidget = new QTreeWidget(this);
836
 
        m_pTreeWidget->setRootIsDecorated(false);
837
 
        m_pTreeWidget->setColumnCount(2);
838
 
        QStringList columnLabels;
839
 
        columnLabels.append(__tr2qs("Channel name"));
840
 
        columnLabels.append(__tr2qs("Channel password"));
841
 
        m_pTreeWidget->setHeaderLabels(columnLabels);
842
 
        KviTalHBox* pEditsHBox = new KviTalHBox(this);
843
 
 
844
 
        m_pChanLineEdit = new QLineEdit(pEditsHBox);
845
 
        connect(m_pChanLineEdit,SIGNAL(textChanged(const QString &)),this,SLOT(textChanged(const QString &)));
846
 
        connect(m_pChanLineEdit,SIGNAL(returnPressed()),this,SLOT(addClicked()));
847
 
 
848
 
        m_pPassLineEdit = new QLineEdit(pEditsHBox);
849
 
        m_pPassLineEdit->setEchoMode(QLineEdit::Password);
850
 
        connect(m_pPassLineEdit,SIGNAL(textChanged(const QString &)),this,SLOT(textChanged(const QString &)));
851
 
        connect(m_pPassLineEdit,SIGNAL(returnPressed()),this,SLOT(addClicked()));
852
 
 
853
 
 
854
 
        KviTalHBox * hBox = new KviTalHBox(this);
855
 
        m_pAddButton = new QPushButton(__tr2qs("A&dd"),hBox);
856
 
        connect(m_pAddButton,SIGNAL(clicked()),this,SLOT(addClicked()));
857
 
        m_pRemoveButton = new QPushButton(__tr2qs("Re&move"),hBox);
858
 
        connect(m_pRemoveButton,SIGNAL(clicked()),this,SLOT(removeClicked()));
859
 
        m_pOption = pOption;
860
 
 
861
 
        for ( QStringList::Iterator it = pOption->begin(); it != pOption->end(); ++it ) {
862
 
                new KviChanTreeViewItem(m_pTreeWidget,(*it).section(':',0,0),(*it).section(':',1));
863
 
        }
864
 
 
865
 
        m_pTreeWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
866
 
        m_pTreeWidget->setAllColumnsShowFocus(TRUE);
867
 
        connect(m_pTreeWidget,SIGNAL(itemSelectionChanged()),this,SLOT(itemSelectionChanged()));
868
 
        setSpacing(4);
869
 
        setStretchFactor(m_pTreeWidget,1);
870
 
        setEnabled(bEnabled);
871
 
}
872
 
 
873
 
KviChannelListSelector::~KviChannelListSelector()
874
 
{
875
 
}
876
 
 
877
 
void KviChannelListSelector::commit()
878
 
{
879
 
        m_pOption->clear();
880
 
        register KviChanTreeViewItem* pItem;
881
 
        for (int i=0;i<m_pTreeWidget->topLevelItemCount();i++)
882
 
        {
883
 
                pItem=(KviChanTreeViewItem*)m_pTreeWidget->topLevelItem(i);
884
 
                m_pOption->append(pItem->text(0)+":"+pItem->pass());
885
 
        }
886
 
}
887
 
 
888
 
void KviChannelListSelector::setEnabled(bool bEnabled)
889
 
{
890
 
        m_pLabel->setEnabled(bEnabled);
891
 
        m_pTreeWidget->setEnabled(bEnabled);
892
 
        m_pChanLineEdit->setEnabled(bEnabled);
893
 
        m_pPassLineEdit->setEnabled(bEnabled);
894
 
        m_pAddButton->setEnabled(bEnabled);
895
 
        m_pRemoveButton->setEnabled(bEnabled);
896
 
}
897
 
 
898
 
void KviChannelListSelector::textChanged(const QString &)
899
 
{
900
 
        m_pAddButton->setEnabled(!m_pChanLineEdit->text().isEmpty());
901
 
}
902
 
 
903
 
void KviChannelListSelector::itemSelectionChanged()
904
 
{
905
 
}
906
 
 
907
 
void KviChannelListSelector::addClicked()
908
 
{
909
 
        if(!m_pChanLineEdit->text().isEmpty())
910
 
        {
911
 
                new KviChanTreeViewItem(m_pTreeWidget,m_pChanLineEdit->text().trimmed(),m_pPassLineEdit->text().trimmed());
912
 
                m_pChanLineEdit->clear();
913
 
                m_pPassLineEdit->clear();
914
 
        }
915
 
}
916
 
 
917
 
void KviChannelListSelector::removeClicked()
918
 
{
919
 
        KviPointerList<QTreeWidgetItem> lst;
920
 
        QList<QTreeWidgetItem *> items=m_pTreeWidget->selectedItems () ;
921
 
        for (int i=0;i<items.count();i++)
922
 
        {
923
 
                lst.append((QTreeWidgetItem *)items.at(i));
924
 
        }
925
 
        lst.setAutoDelete(TRUE);
926
 
        lst.clear();
927
 
}
928
 
 
929
 
#ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
930
 
#include "kvi_selectors.moc"
931
 
#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES