← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/kvilib/tal/KviTalWizard.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/kvilib/tal/KviTalWizard.cpp
 
1
//=============================================================================
 
2
//
 
3
//   File : KviTalWizard.cpp
 
4
//   Creation date : Tue Feb 06 2007 14:35:08 by Szymon Stefanek
 
5
//
 
6
//   This file is part of the KVIrc irc client distribution
 
7
//   Copyright (C) 2007-2010 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
#include "KviTalWizard.h"
 
26
#include "KviTalHBox.h"
 
27
#include "KviPointerList.h"
 
28
#include "KviLocale.h"
 
29
 
 
30
#include <QShowEvent>
 
31
#include <QLabel>
 
32
#include <QPushButton>
 
33
#include <QGridLayout>
 
34
#include <QFrame>
 
35
#include <QStackedWidget>
 
36
#include <QPalette>
 
37
 
 
38
 
 
39
class KviTalWizardPageData
 
40
{
 
41
public:
 
42
        enum EnableFlags
 
43
        {
 
44
                EnableNext = 1,
 
45
                EnableBack = 2,
 
46
                EnableHelp = 4,
 
47
                EnableCancel = 8,
 
48
                EnableFinish = 16
 
49
        };
 
50
public:
 
51
        QWidget * pWidget;
 
52
        QString   szTitle;
 
53
        bool      bEnabled;
 
54
        int       iEnableFlags;
 
55
        int       iVisibleIndex;
 
56
};
 
57
 
 
58
class KviTalWizardPrivate
 
59
{
 
60
public:
 
61
        KviPointerList<KviTalWizardPageData> * pPageList;
 
62
        int                                iEnabledPageCount;
 
63
        KviTalWizardPageData             * pCurrentPage;
 
64
        QGridLayout                      * pLayout;
 
65
        QLabel                           * pTitleLabel;
 
66
        QLabel                           * pStepsLabel;
 
67
        QPushButton                      * pBackButton;
 
68
        QPushButton                      * pCancelButton;
 
69
        QPushButton                      * pHelpButton;
 
70
        QPushButton                      * pNextButton;
 
71
        QWidget                          * pNextSpacer;
 
72
        QPushButton                      * pFinishButton;
 
73
        QWidget                          * pFinishSpacer;
 
74
        QStackedWidget                   * pWidgetStack;
 
75
public:
 
76
        KviTalWizardPageData * findPage(QWidget * pWidget)
 
77
        {
 
78
                for(KviTalWizardPageData * pData = pPageList->first();pData;pData = pPageList->next())
 
79
                {
 
80
                        if(pData->pWidget == pWidget) return pData;
 
81
                }
 
82
                return NULL;
 
83
        }
 
84
 
 
85
        KviTalWizardPageData * findFirstEnabledPage()
 
86
        {
 
87
                KviTalWizardPageData * pData;
 
88
                for(pData = pPageList->first();pData;pData = pPageList->next())
 
89
                {
 
90
                        if(pData->bEnabled) return pData;
 
91
                }
 
92
                return NULL;
 
93
        }
 
94
 
 
95
        KviTalWizardPageData * findLastEnabledPage()
 
96
        {
 
97
                KviTalWizardPageData * pData;
 
98
                for(pData = pPageList->last();pData;pData = pPageList->prev())
 
99
                {
 
100
                        if(pData->bEnabled) return pData;
 
101
                }
 
102
                return NULL;
 
103
        }
 
104
 
 
105
        KviTalWizardPageData * findNextEnabledPage(QWidget * pReference)
 
106
        {
 
107
                if(!pReference) return findFirstEnabledPage();
 
108
                KviTalWizardPageData * pData = findPage(pReference);
 
109
                if(!pData) return NULL;
 
110
                for(pData = pPageList->next();pData;pData = pPageList->next())
 
111
                {
 
112
                        if(pData->bEnabled) return pData;
 
113
                }
 
114
                return NULL;
 
115
        }
 
116
 
 
117
        KviTalWizardPageData * findPrevEnabledPage(QWidget * pReference)
 
118
        {
 
119
                if(!pReference) return findLastEnabledPage();
 
120
                KviTalWizardPageData * pData = findPage(pReference);
 
121
                if(!pData) return NULL;
 
122
                for(pData = pPageList->prev();pData;pData = pPageList->prev())
 
123
                {
 
124
                        if(pData->bEnabled) return pData;
 
125
                }
 
126
                return NULL;
 
127
        }
 
128
 
 
129
        int reindexPages()
 
130
        {
 
131
                int iEnabledCount = 0;
 
132
                for(KviTalWizardPageData * pData = pPageList->first();pData;pData = pPageList->next())
 
133
                {
 
134
                        if(pData->bEnabled)
 
135
                        {
 
136
                                iEnabledCount++;
 
137
                                pData->iVisibleIndex = iEnabledCount;
 
138
                        }
 
139
                }
 
140
                return iEnabledCount;
 
141
        }
 
142
};
 
143
 
 
144
 
 
145
KviTalWizard::KviTalWizard(QWidget * pParent)
 
146
: QDialog(pParent)
 
147
{
 
148
        m_p = new KviTalWizardPrivate;
 
149
        m_p->pPageList = new KviPointerList<KviTalWizardPageData>;
 
150
        m_p->pPageList->setAutoDelete(true);
 
151
        m_p->pCurrentPage = NULL;
 
152
        m_p->iEnabledPageCount = 0;
 
153
        m_p->pLayout = new QGridLayout(this);
 
154
 
 
155
        m_p->pTitleLabel = new QLabel(this);
 
156
        m_p->pLayout->addWidget(m_p->pTitleLabel,0,0,1,3);
 
157
 
 
158
        m_p->pStepsLabel = new QLabel(this);
 
159
        m_p->pStepsLabel->setMinimumWidth(80);
 
160
        m_p->pStepsLabel->setAlignment(Qt::AlignRight);
 
161
        m_p->pLayout->addWidget(m_p->pStepsLabel,0,4,1,3);
 
162
 
 
163
        QFrame * f1 = new QFrame(this);
 
164
        f1->setFrameStyle(QFrame::Sunken | QFrame::HLine);
 
165
        m_p->pLayout->addWidget(f1,1,0,1,7);
 
166
 
 
167
        m_p->pWidgetStack = new QStackedWidget(this);
 
168
        m_p->pLayout->addWidget(m_p->pWidgetStack,2,0,1,7);
 
169
 
 
170
        QFrame * f2 = new QFrame(this);
 
171
        f2->setFrameStyle(QFrame::Sunken | QFrame::HLine);
 
172
        m_p->pLayout->addWidget(f2,3,0,1,7);
 
173
 
 
174
        KviTalHBox * pButtonBox = new KviTalHBox(this);
 
175
        m_p->pLayout->addWidget(pButtonBox,4,0,1,7);
 
176
 
 
177
        pButtonBox->setMargin(0);
 
178
        pButtonBox->setSpacing(0);
 
179
 
 
180
 
 
181
        m_p->pCancelButton = new QPushButton(__tr("Cancel"),pButtonBox);
 
182
        m_p->pCancelButton->setMinimumWidth(80);
 
183
        QObject::connect(
 
184
                        m_p->pCancelButton,
 
185
                        SIGNAL(clicked()),
 
186
                        this,
 
187
                        SLOT(cancelButtonClicked())
 
188
                );
 
189
 
 
190
        QWidget * pSpacer = new QWidget(pButtonBox);
 
191
        pSpacer->setFixedWidth(4);
 
192
 
 
193
        m_p->pHelpButton = new QPushButton(__tr("Help"),pButtonBox);
 
194
        m_p->pHelpButton->setMinimumWidth(80);
 
195
        QObject::connect(
 
196
                        m_p->pHelpButton,
 
197
                        SIGNAL(clicked()),
 
198
                        this,
 
199
                        SLOT(helpButtonClicked())
 
200
                );
 
201
 
 
202
        QWidget * pLargeSpacer = new QWidget(pButtonBox);
 
203
        pLargeSpacer->setMinimumWidth(50);
 
204
        pButtonBox->setStretchFactor(pLargeSpacer,100);
 
205
 
 
206
        QString szText = "< ";
 
207
        szText += __tr("Back");
 
208
        m_p->pBackButton = new QPushButton(szText,pButtonBox);
 
209
        m_p->pBackButton->setMinimumWidth(80);
 
210
        QObject::connect(
 
211
                        m_p->pBackButton,
 
212
                        SIGNAL(clicked()),
 
213
                        this,
 
214
                        SLOT(backButtonClicked())
 
215
                );
 
216
 
 
217
        m_p->pNextSpacer = new QWidget(pButtonBox);
 
218
        m_p->pNextSpacer->setFixedWidth(4);
 
219
 
 
220
        szText = __tr("Next");
 
221
        szText += " >";
 
222
        m_p->pNextButton = new QPushButton(szText,pButtonBox);
 
223
        m_p->pNextButton->setMinimumWidth(80);
 
224
        QObject::connect(
 
225
                        m_p->pNextButton,
 
226
                        SIGNAL(clicked()),
 
227
                        this,
 
228
                        SLOT(nextButtonClicked())
 
229
                );
 
230
 
 
231
        m_p->pFinishSpacer = new QWidget(pButtonBox);
 
232
        m_p->pFinishSpacer->setFixedWidth(4);
 
233
 
 
234
        m_p->pFinishButton = new QPushButton(__tr("Finish"),pButtonBox);
 
235
        m_p->pFinishButton->setMinimumWidth(80);
 
236
        QObject::connect(
 
237
                        m_p->pFinishButton,
 
238
                        SIGNAL(clicked()),
 
239
                        this,
 
240
                        SLOT(finishButtonClicked())
 
241
                );
 
242
 
 
243
        m_p->pLayout->setMargin(8);
 
244
        m_p->pLayout->setSpacing(4);
 
245
        m_p->pLayout->setRowStretch(2,1);
 
246
        m_p->pLayout->setColumnStretch(0,1);
 
247
}
 
248
 
 
249
KviTalWizard::~KviTalWizard()
 
250
{
 
251
        delete m_p->pPageList;
 
252
        delete m_p;
 
253
}
 
254
 
 
255
void KviTalWizard::insertPage(QWidget * pWidget,const QString &szTitle,int iIndex)
 
256
{
 
257
        KviTalWizardPageData * pPageData = m_p->findPage(pWidget);
 
258
        if(!pPageData)
 
259
        {
 
260
                pPageData = new KviTalWizardPageData;
 
261
                pPageData->pWidget = pWidget;
 
262
                pPageData->iEnableFlags = \
 
263
                        KviTalWizardPageData::EnableNext | \
 
264
                        KviTalWizardPageData::EnableCancel | \
 
265
                        KviTalWizardPageData::EnableBack;
 
266
                if(iIndex < 0)
 
267
                {
 
268
                        m_p->pPageList->append(pPageData);
 
269
                        m_p->iEnabledPageCount++;
 
270
                        pPageData->iVisibleIndex = m_p->iEnabledPageCount;
 
271
                } else {
 
272
                        m_p->pPageList->insert(iIndex,pPageData);
 
273
                        m_p->iEnabledPageCount = m_p->reindexPages();
 
274
                }
 
275
                m_p->pWidgetStack->addWidget(pWidget);
 
276
        }
 
277
        pPageData->szTitle = szTitle;
 
278
        pPageData->bEnabled = true;
 
279
 
 
280
}
 
281
 
 
282
void KviTalWizard::addPage(QWidget * pWidget,const QString &szTitle)
 
283
{
 
284
        insertPage(pWidget,szTitle,-1);
 
285
}
 
286
 
 
287
bool KviTalWizard::setPageEnabled(QWidget * pWidget,bool bEnabled)
 
288
{
 
289
        KviTalWizardPageData * pData = m_p->findPage(pWidget);
 
290
        if(!pData)
 
291
                return false;
 
292
        pData->bEnabled = bEnabled;
 
293
        m_p->iEnabledPageCount = m_p->reindexPages();
 
294
        setCurrentPage(m_p->pCurrentPage);
 
295
        return true;
 
296
}
 
297
 
 
298
bool KviTalWizard::setPageTitle(QWidget * pWidget,const QString &szTitle)
 
299
{
 
300
        KviTalWizardPageData * pData = m_p->findPage(pWidget);
 
301
        if(!pData)
 
302
                return false;
 
303
        pData->szTitle = szTitle;
 
304
        return true;
 
305
}
 
306
 
 
307
bool KviTalWizard::setCurrentPage(QWidget * pWidget)
 
308
{
 
309
        KviTalWizardPageData * pData = m_p->findPage(pWidget);
 
310
        if(!pData)
 
311
                return false;
 
312
        setCurrentPage(pData);
 
313
        return true;
 
314
}
 
315
 
 
316
QWidget * KviTalWizard::currentPage()
 
317
{
 
318
        if(!m_p->pCurrentPage)
 
319
                return NULL;
 
320
        return m_p->pCurrentPage->pWidget;
 
321
}
 
322
 
 
323
void KviTalWizard::setCurrentPage(KviTalWizardPageData * pData)
 
324
{
 
325
        m_p->pCurrentPage = pData;
 
326
 
 
327
        bool bCancelEnabled = true;
 
328
        bool bNextEnabled = false;
 
329
        bool bBackEnabled = false;
 
330
        bool bHelpEnabled = false;
 
331
        bool bFinishEnabled = false;
 
332
 
 
333
        QString szTitle;
 
334
        QString szSteps;
 
335
 
 
336
        if(pData)
 
337
        {
 
338
                bNextEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableNext) && m_p->findNextEnabledPage(pData->pWidget);
 
339
                bBackEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableBack) && m_p->findPrevEnabledPage(pData->pWidget);
 
340
                bCancelEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableCancel);
 
341
                bFinishEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableFinish);
 
342
                bHelpEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableHelp);
 
343
                m_p->pWidgetStack->setCurrentWidget(pData->pWidget);
 
344
 
 
345
                szTitle = "<b>";
 
346
                szTitle += pData->szTitle;
 
347
                szTitle += "</b>";
 
348
                QPalette pal = m_p->pStepsLabel->palette();
 
349
                QColor clrWin = pal.color(QPalette::Normal,QPalette::Window);
 
350
                QColor clrTxt = pal.color(QPalette::Normal,QPalette::WindowText);
 
351
                QColor clrMid = qRgb(
 
352
                                (clrWin.red() + clrTxt.red()) / 2,
 
353
                                (clrWin.green() + clrTxt.green()) / 2,
 
354
                                (clrWin.blue() + clrTxt.blue()) / 2
 
355
                        );
 
356
 
 
357
                szSteps = "<nobr><font color=\"";
 
358
                szSteps += clrMid.name();
 
359
                szSteps += "\"><b>[";
 
360
                szSteps += QString("Step %1 of %2").arg(pData->iVisibleIndex).arg(m_p->iEnabledPageCount);
 
361
                szSteps += "]</b></font></nobr>";
 
362
        }
 
363
 
 
364
        m_p->pTitleLabel->setText(szTitle);
 
365
        m_p->pStepsLabel->setText(szSteps);
 
366
 
 
367
        m_p->pNextButton->setEnabled(bNextEnabled);
 
368
        if(bNextEnabled)
 
369
        {
 
370
                m_p->pNextButton->show();
 
371
                m_p->pNextSpacer->show();
 
372
                m_p->pNextButton->setDefault(true);
 
373
        } else {
 
374
                m_p->pNextButton->hide();
 
375
                m_p->pNextSpacer->hide();
 
376
                m_p->pNextButton->setDefault(false);
 
377
        }
 
378
        m_p->pBackButton->setEnabled(bBackEnabled);
 
379
        m_p->pHelpButton->setEnabled(bHelpEnabled);
 
380
        if(bHelpEnabled)
 
381
                m_p->pHelpButton->show();
 
382
        else
 
383
                m_p->pHelpButton->hide();
 
384
        m_p->pCancelButton->setEnabled(bCancelEnabled);
 
385
        m_p->pFinishButton->setEnabled(bFinishEnabled);
 
386
        if(bFinishEnabled)
 
387
        {
 
388
                m_p->pFinishButton->show();
 
389
                m_p->pFinishSpacer->show();
 
390
                m_p->pFinishButton->setDefault(true);
 
391
        } else {
 
392
                m_p->pFinishButton->hide();
 
393
                m_p->pFinishSpacer->hide();
 
394
                m_p->pFinishButton->setDefault(false);
 
395
        }
 
396
}
 
397
 
 
398
void KviTalWizard::showEvent(QShowEvent * e)
 
399
{
 
400
        if(!(m_p->pCurrentPage))
 
401
        {
 
402
                // display the first page
 
403
                KviTalWizardPageData * pData = m_p->findFirstEnabledPage();
 
404
                if(pData)
 
405
                        setCurrentPage(pData->pWidget);
 
406
        }
 
407
        QDialog::showEvent(e);
 
408
        emit pageChanged(m_p->pCurrentPage->szTitle);
 
409
}
 
410
 
 
411
void KviTalWizard::closeEvent(QCloseEvent * e)
 
412
{
 
413
        e->ignore();
 
414
        cancelButtonClicked();
 
415
}
 
416
 
 
417
void KviTalWizard::backButtonClicked()
 
418
{
 
419
        if(!m_p->pCurrentPage)
 
420
                return;
 
421
        setCurrentPage(m_p->findPrevEnabledPage(m_p->pCurrentPage->pWidget));
 
422
        emit pageChanged(m_p->pCurrentPage->szTitle);
 
423
}
 
424
 
 
425
void KviTalWizard::nextButtonClicked()
 
426
{
 
427
        setCurrentPage(m_p->findNextEnabledPage(m_p->pCurrentPage->pWidget));
 
428
        emit pageChanged(m_p->pCurrentPage->szTitle);
 
429
}
 
430
 
 
431
void KviTalWizard::helpButtonClicked()
 
432
{
 
433
        emit helpClicked();
 
434
}
 
435
 
 
436
void KviTalWizard::cancelButtonClicked()
 
437
{
 
438
        reject();
 
439
}
 
440
 
 
441
void KviTalWizard::finishButtonClicked()
 
442
{
 
443
        accept();
 
444
}
 
445
 
 
446
void KviTalWizard::setHelpEnabled(QWidget * pWidget,bool bEnabled)
 
447
{
 
448
        KviTalWizardPageData * pData = m_p->findPage(pWidget);
 
449
        if(!pData)
 
450
                return;
 
451
        if(bEnabled)
 
452
                pData->iEnableFlags |= KviTalWizardPageData::EnableHelp;
 
453
        else
 
454
                pData->iEnableFlags &= ~KviTalWizardPageData::EnableHelp;
 
455
        if(pData == m_p->pCurrentPage)
 
456
                setCurrentPage(pData);
 
457
}
 
458
 
 
459
void KviTalWizard::setCancelEnabled(QWidget * pWidget,bool bEnabled)
 
460
{
 
461
        KviTalWizardPageData * pData = m_p->findPage(pWidget);
 
462
        if(!pData)
 
463
                return;
 
464
        if(bEnabled)
 
465
                pData->iEnableFlags |= KviTalWizardPageData::EnableCancel;
 
466
        else
 
467
                pData->iEnableFlags &= ~KviTalWizardPageData::EnableCancel;
 
468
        if(pData == m_p->pCurrentPage)
 
469
                setCurrentPage(pData);
 
470
}
 
471
 
 
472
void KviTalWizard::setFinishEnabled(QWidget * pWidget,bool bEnabled)
 
473
{
 
474
        KviTalWizardPageData * pData = m_p->findPage(pWidget);
 
475
        if(!pData)
 
476
                return;
 
477
        if(bEnabled)
 
478
                pData->iEnableFlags |= KviTalWizardPageData::EnableFinish;
 
479
        else
 
480
                pData->iEnableFlags &= ~KviTalWizardPageData::EnableFinish;
 
481
        if(pData == m_p->pCurrentPage)
 
482
                setCurrentPage(pData);
 
483
}
 
484
 
 
485
void KviTalWizard::setNextEnabled(QWidget * pWidget,bool bEnabled)
 
486
{
 
487
        KviTalWizardPageData * pData = m_p->findPage(pWidget);
 
488
        if(!pData)
 
489
                return;
 
490
        if(bEnabled)
 
491
                pData->iEnableFlags |= KviTalWizardPageData::EnableNext;
 
492
        else
 
493
                pData->iEnableFlags &= ~KviTalWizardPageData::EnableNext;
 
494
        if(pData == m_p->pCurrentPage)
 
495
                setCurrentPage(pData);
 
496
}
 
497
 
 
498
void KviTalWizard::setBackEnabled(QWidget * pWidget,bool bEnabled)
 
499
{
 
500
        KviTalWizardPageData * pData = m_p->findPage(pWidget);
 
501
        if(!pData)
 
502
                return;
 
503
        if(bEnabled)
 
504
                pData->iEnableFlags |= KviTalWizardPageData::EnableBack;
 
505
        else
 
506
                pData->iEnableFlags &= ~KviTalWizardPageData::EnableBack;
 
507
        if(pData == m_p->pCurrentPage)
 
508
                setCurrentPage(pData);
 
509
}
 
510
 
 
511
QPushButton * KviTalWizard::cancelButton()
 
512
{
 
513
        return m_p->pCancelButton;
 
514
}
 
515
 
 
516
QPushButton * KviTalWizard::helpButton()
 
517
{
 
518
        return m_p->pHelpButton;
 
519
}
 
520
 
 
521
QPushButton * KviTalWizard::finishButton()
 
522
{
 
523
        return m_p->pFinishButton;
 
524
}
 
525
 
 
526
QPushButton * KviTalWizard::nextButton()
 
527
{
 
528
        return m_p->pNextButton;
 
529
}
 
530
 
 
531
QPushButton * KviTalWizard::backButton()
 
532
{
 
533
        return m_p->pBackButton;
 
534
}
 
535
 
 
536
#ifdef COMPILE_ON_WINDOWS
 
537
        #ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
 
538
                #include "KviTalWizard.moc"
 
539
        #endif //!COMPILE_USE_STANDALONE_MOC_SOURCES
 
540
#endif