diff options
Diffstat (limited to 'src/modules/options')
| -rw-r--r-- | src/modules/options/dialog.cpp | 650 | ||||
| -rw-r--r-- | src/modules/options/instances.cpp | 3589 | ||||
| -rw-r--r-- | src/modules/options/optw_messages.cpp | 663 | ||||
| -rw-r--r-- | src/modules/options/optw_texticons.cpp | 244 |
4 files changed, 5146 insertions, 0 deletions
diff --git a/src/modules/options/dialog.cpp b/src/modules/options/dialog.cpp new file mode 100644 index 000000000..26505f633 --- /dev/null +++ b/src/modules/options/dialog.cpp @@ -0,0 +1,650 @@ +//============================================================================= +// +// File : dialog.cpp +// Created on Fri 10 Feb 2006 18:52:18 by Szymon Stefanek +// Based on dlg_options.cpp: Tue Jun 11 2000 02:39:12 by Szymon Stefanek +// +// This file is part of the KVIrc IRC Client distribution +// Copyright (C) 2000-2006 Szymon Stefanek <pragma at kvirc dot net> +// +// This program is FREE software. You can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your opinion) any later version. +// +// This program is distributed in the HOPE that it will be USEFUL, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, write to the Free Software Foundation, +// Inc. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +//============================================================================= + +#include "dialog.h" + +#include "kvi_app.h" +#include "kvi_options.h" +#include "kvi_locale.h" +#include "kvi_iconmanager.h" +#include "kvi_module.h" +#include "kvi_styled_controls.h" +#include "kvi_pointerhashtable.h" +#include "kvi_accel.h" +#include "kvi_tal_vbox.h" +#include "kvi_tal_widgetstack.h" +#include "kvi_tal_tooltip.h" +#include "kvi_tal_popupmenu.h" +#include <kvi_tal_groupbox.h> + +#include <QLayout> +#include <QLabel> +#include <QSplitter> +#include <QPushButton> +#include <QToolButton> +#include <QCheckBox> +#include <QPainter> +#include <QFont> +#include <QEvent> +#include <QCloseEvent> +#include <QShortcut> +#include <QHeaderView> +//FIXME: some headers must be hidden +//#include <q3header.h> + + +//extern KviModule * g_pOptionsModule; +extern KviPointerHashTable<QString,KviOptionsDialog> * g_pOptionsDialogDict; + +extern KVIRC_API KviApp * g_pApp; +extern KviOptionsInstanceManager * g_pOptionsInstanceManager; + +KviGeneralOptionsFrontWidget::KviGeneralOptionsFrontWidget(QWidget *parent,const QString &szText) +:KviOptionsWidget(parent,"general_options_front_widget") +{ + createLayout(1,1); + QLabel * l = new QLabel(szText,this); + l->setWordWrap(true); + l->setAlignment(Qt::AlignTop); + layout()->addWidget(l,0,0); +} + +KviGeneralOptionsFrontWidget::~KviGeneralOptionsFrontWidget() +{ +} + + +KviOptionsListViewItem::KviOptionsListViewItem(KviTalListView *parent,KviOptionsWidgetInstanceEntry * e) +:KviTalListViewItem(parent,e->szName) +{ + m_pInstanceEntry = e; + m_pOptionsWidget = 0; + m_bHighlighted = false; + setPixmap(0,*(g_pIconManager->getSmallIcon(e->iIcon))); +} + +KviOptionsListViewItem::KviOptionsListViewItem(KviTalListViewItem *parent,KviOptionsWidgetInstanceEntry * e) +:KviTalListViewItem(parent,e->szName) +{ + m_pInstanceEntry = e; + m_pOptionsWidget = 0; + m_bHighlighted = false; + setPixmap(0,*(g_pIconManager->getSmallIcon(e->iIcon))); +} + +KviOptionsListViewItem::~KviOptionsListViewItem() +{ +} + +void KviOptionsListViewItem::paintCell(QPainter * p,const QColorGroup & cg,int column,int width,int align) +{ + if(m_bHighlighted) + { + QColorGroup tmp(cg); + tmp.setColor(QColorGroup::Base,Qt::red); + tmp.setColor(QColorGroup::Background,Qt::red); + tmp.setColor(QColorGroup::Text,Qt::yellow); + KviTalListViewItem::paintCell(p,tmp,column,width,align); + } else { + KviTalListViewItem::paintCell(p,cg,column,width,align); + } +} + + +KviOptionsDialog::KviOptionsDialog(QWidget * par,const QString &szGroup) +: QDialog(par,"general_options_dialog") +{ + setIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_KVIRC))); + + m_szGroup = szGroup; + + QString szDialogTitle; + + if(szGroup.isEmpty() || KviQString::equalCI(szGroup,"general")) + { + szDialogTitle = __tr2qs_ctx("General Preferences","options"); + } else if(KviQString::equalCI(szGroup,"theme")) + { + szDialogTitle = __tr2qs_ctx("Theme Preferences","options"); + } else { + szDialogTitle = __tr2qs_ctx("KVIrc Preferences","options"); + } + + QString szDialog = __tr2qs_ctx("This dialog contains a set of KVIrc settings.<br> Use the icons " \ + "on the left to navigate through the option pages. The text box in the " \ + "bottom left corner is a small search engine. It will highlight the " \ + "pages that contain options related to the search term you have entered.","options"); + + + QString szInfoTips; +#ifdef COMPILE_INFO_TIPS + szInfoTips = __tr2qs_ctx("Many settings have tooltips that can be shown by holding " \ + "the cursor over their label for a few seconds.","options"); +#else + szInfoTips = ""; +#endif + QString szOkCancelButtons = __tr2qs_ctx("When you have finished, click \"<b>OK</b>\" to accept your changes " \ + "or \"<b>Cancel</b>\" to discard them. Clicking \"<b>Apply</b>\" will commit your " \ + "changes without closing the window.","options"); + + + QString szFrontText = QString( + "<table width=\"100%\" height=\"100%\" valign=\"top\" align=\"center\" cellpadding=\"4\">" \ + "<tr>" \ + "<td bgcolor=\"#303030\" valign=\"top\">" \ + "<center><h1><font color=\"#FFFFFF\">%1</font></h1></center>" \ + "</td>" \ + "</tr>" \ + "<tr>" \ + "<td valign=\"bottom\">" \ + "<br>" \ + "<br>" \ + "<p>" \ + "%2" \ + "</p>" \ + "<br>" \ + "<p>" \ + "%3" \ + "</p>" \ + "<br>" \ + "<p>" \ + "%4" \ + "</p>" \ + "</td>" \ + "</tr>" \ + "</table>" + ).arg(szDialogTitle).arg(szDialog).arg(szInfoTips).arg(szOkCancelButtons); + + QString szCaption = szDialogTitle + " - KVIrc"; + setCaption(szCaption); + + QGridLayout * g1 = new QGridLayout(this,2,5,8,8); + QSplitter * spl = new QSplitter(Qt::Horizontal,this); + + g1->addMultiCellWidget(spl,0,0,0,4); + + KviTalVBox * vbox = new KviTalVBox(spl); + vbox->setSpacing(2); + vbox->setMargin(0); + + // Controlling list view + m_pListView = new KviTalListView(vbox); + m_pListView->addColumn(""); + // This does not work in Qt4 + //m_pListView->header()->hide(); + m_pListView->setRootIsDecorated(true); + m_pListView->setSorting(-1); + connect(m_pListView,SIGNAL(selectionChanged(KviTalListViewItem *)),this,SLOT(listViewItemSelectionChanged(KviTalListViewItem *))); + + KviTalHBox * hbox = new KviTalHBox(vbox); + vbox->setSpacing(2); + vbox->setMargin(0); + + m_pSearchLineEdit = new QLineEdit(hbox); + connect(m_pSearchLineEdit,SIGNAL(returnPressed()),this,SLOT(searchClicked())); + m_pSearchButton = new KviStyledToolButton(hbox); + m_pSearchButton->setUsesBigPixmap(false); + m_pSearchButton->setIconSet(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SEARCH))); + connect(m_pSearchButton,SIGNAL(clicked()),this,SLOT(searchClicked())); + connect(m_pSearchLineEdit,SIGNAL(textChanged(const QString &)),this,SLOT(searchLineEditTextChanged(const QString &))); + +#ifdef COMPILE_INFO_TIPS + QString szTip = __tr2qs_ctx("<p>This is the search tool for this options dialog.</p>" \ + "<p>You can enter a search term either in your native " \ + "language or in english and press the button on the right. " \ + "The pages that contain some options related to the " \ + "search term will be highlighted and you will be able " \ + "to quickly find them.</p><p>Try \"nickname\" for example.</p>","options"); + KviTalToolTip::add(m_pSearchLineEdit,szTip); + KviTalToolTip::add(m_pSearchButton,szTip); +#endif + + vbox = new KviTalVBox(spl); + vbox->setSpacing(2); + vbox->setMargin(0); + + m_pCategoryLabel = new QLabel("<b> </b>",vbox,"labgeneraloptions"); + //m_pCategoryLabel->setMargin(3); + + QFrame * f = new QFrame(vbox); + f->setFrameStyle(QFrame::HLine | QFrame::Sunken); + + // Widget stack + m_pWidgetStack = new KviTalWidgetStack(vbox); + vbox->setStretchFactor(m_pWidgetStack,1); + + // First widget visible + m_pFrontWidget = new KviGeneralOptionsFrontWidget(m_pWidgetStack,szFrontText); + m_pWidgetStack->addWidget(m_pFrontWidget); + + int idx = m_pWidgetStack->indexOf(m_pFrontWidget); + m_pWidgetStack->widget(idx)->raise(); + +// Ok,Cancel,Help + + QPushButton * b = new QPushButton(__tr2qs_ctx("&OK","options"),this,"btnok"); + KviTalToolTip::add(b,__tr2qs_ctx("Close this dialog, accepting all changes.","options")); + connect(b,SIGNAL(clicked()),this,SLOT(okClicked())); + //b->setMinimumWidth(whatIsThisWidth); + b->setIconSet(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ACCEPT))); + g1->addWidget(b,1,2); + + b = new QPushButton(__tr2qs_ctx("&Apply","options"),this,"btnapply"); + KviTalToolTip::add(b,__tr2qs_ctx("Commit all changes immediately.","options")); + connect(b,SIGNAL(clicked()),this,SLOT(applyClicked())); + b->setIconSet(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ACCEPT))); + g1->addWidget(b,1,3); + + b = new QPushButton(__tr2qs_ctx("Cancel","options"),this,"btncancel"); + KviTalToolTip::add(b,__tr2qs_ctx("Close this dialog, discarding all changes.","options")); + b->setDefault(true); + //b->setMinimumWidth(whatIsThisWidth); + connect(b,SIGNAL(clicked()),this,SLOT(cancelClicked())); + b->setIconSet(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_DISCARD))); + g1->addWidget(b,1,4); + + g1->setRowStretch(0,1); + g1->setColStretch(1,1); + + + fillListView(0,g_pOptionsInstanceManager->instanceEntryTree(),szGroup); + + if(!parent()) + { + if(KVI_OPTION_RECT(KviOption_rectGeneralOptionsDialogGeometry).y() < 5) + { + KVI_OPTION_RECT(KviOption_rectGeneralOptionsDialogGeometry).setY(5); + } + //setGeometry(KVI_OPTION_RECT(KviOption_rectGeneralOptionsDialogGeometry)); + resize(KVI_OPTION_RECT(KviOption_rectGeneralOptionsDialogGeometry).width(), + KVI_OPTION_RECT(KviOption_rectGeneralOptionsDialogGeometry).height()); + move(KVI_OPTION_RECT(KviOption_rectGeneralOptionsDialogGeometry).x(), + KVI_OPTION_RECT(KviOption_rectGeneralOptionsDialogGeometry).y()); + } + + new QShortcut(Qt::Key_Escape,this,SLOT(close())); +} + +KviOptionsDialog::~KviOptionsDialog() +{ + if(!parent())KVI_OPTION_RECT(KviOption_rectGeneralOptionsDialogGeometry) = QRect(pos().x(),pos().y(), + size().width(),size().height()); + if(g_pOptionsDialogDict) + g_pOptionsDialogDict->remove(m_szGroup); +} + + +void KviOptionsDialog::searchLineEditTextChanged(const QString &) +{ + QString txt = m_pSearchLineEdit->text().stripWhiteSpace(); + m_pSearchButton->setEnabled(txt.length() > 0); +} + +bool KviOptionsDialog::recursiveSearch(KviOptionsListViewItem * pItem,const QStringList &lKeywords) +{ + //qDebug("recursive search:"); + if(!pItem)return false; + + if(!pItem->m_pOptionsWidget) + { + pItem->m_pOptionsWidget = g_pOptionsInstanceManager->getInstance(pItem->m_pInstanceEntry,m_pWidgetStack); + m_pWidgetStack->addWidget(pItem->m_pOptionsWidget); + } + + bool bFoundSomethingHere = false; + KviPointerHashTable<void *,bool> lOptionWidgetsToMark; + lOptionWidgetsToMark.setAutoDelete(true); + QTabWidget * pTabWidgetToMark = 0; + + QObject * o; + QObjectList ol = pItem->m_pOptionsWidget->queryList(); + if(ol.count() > 0) + { + for(QObjectList::Iterator it = ol.begin();it != ol.end();++it) + { + o = *it; + QString szText; + if(o->inherits("QLabel"))szText = ((QLabel *)o)->text(); + else if(o->inherits("QCheckBox"))szText = ((QCheckBox *)o)->text(); + else if(o->inherits("KviTalGroupBox"))szText = ((KviTalGroupBox *)o)->title(); +#ifdef COMPILE_INFO_TIPS + if(o->inherits("QWidget")) + szText.append(((QWidget *)o)->toolTip()); +#endif + if(!szText.isEmpty()) + { + bool bOk = true; + for(int j=0;j<lKeywords.count();j++) + { + if(szText.find(lKeywords.at(j),0,false) == -1) + { + bOk = false; + break; + } + } + if(bOk) + { + bFoundSomethingHere = true; + } + + if(o->inherits("QWidget")) + { + QWidget* pWidget=(QWidget*)o; + QFont font = pWidget->font(); + font.setBold(bOk); + font.setUnderline(bOk); + pWidget->setFont(font); + + // if there is a QTabWidget in the parent chain, signal it in the tab text + QObject * pParent = pWidget->parent(); + while(pParent) + { + if(pParent->inherits("QTabWidget")) + { + pTabWidgetToMark = (QTabWidget *)pParent; + break; + } + pParent = pParent->parent(); + } + + if(pTabWidgetToMark) + { + // lookup the KviOptionsWidget parent + pParent = pWidget->parent(); + while(pParent) + { + if(pParent->inherits("KviOptionsWidget")) + { + bool * pExistingBool = lOptionWidgetsToMark.find(pParent); + if(pExistingBool) + { + if(bOk) + *pExistingBool = true; + } else { + lOptionWidgetsToMark.insert(pParent,new bool(bOk)); + } + break; + } + pParent = pParent->parent(); + } + } + } + } + } + } + + if(pTabWidgetToMark) + { + KviPointerHashTableIterator<void *,bool> it(lOptionWidgetsToMark); + while(bool * pBool = it.current()) + { + KviOptionsWidget * pOptionsWidget = (KviOptionsWidget *)it.currentKey(); + QString szTxt = pTabWidgetToMark->tabLabel(pOptionsWidget); + if(KviQString::equalCIN(szTxt,">>> ",4)) + { + szTxt.replace(">>> ",""); + szTxt.replace(" <<<",""); + } + if(*pBool) + { + szTxt.insert(0,">>> "); + szTxt += QString(" <<<"); + } + pTabWidgetToMark->setTabLabel(pOptionsWidget,szTxt); + ++it; + } + } + + pItem->setHighlighted(bFoundSomethingHere); + + KviOptionsListViewItem * pChild = (KviOptionsListViewItem *)pItem->firstChild(); + bool bFoundSomethingInside = false; + while(pChild) + { + bool bRet = recursiveSearch(pChild,lKeywords); + if(bRet)bFoundSomethingInside = true; + pChild = (KviOptionsListViewItem *)(pChild->nextSibling()); + } + pItem->setSelected(false); + m_pListView->setOpen(pItem,bFoundSomethingInside); + return (bFoundSomethingInside || bFoundSomethingHere); +} + +void KviOptionsDialog::search(const QStringList &lKeywords) +{ + m_pListView->setUpdatesEnabled(false); + + KviOptionsListViewItem * pChild = (KviOptionsListViewItem *)(m_pListView->firstChild()); + bool bFoundSomethingInside = false; + while(pChild) + { + bFoundSomethingInside = recursiveSearch(pChild,lKeywords); + pChild = (KviOptionsListViewItem *)(pChild->nextSibling()); + } + m_pListView->setUpdatesEnabled(true); + m_pListView->triggerUpdate(); +} + +void KviOptionsDialog::search(const QString &szKeywords) +{ + QStringList lKeywords = QStringList::split(" ",szKeywords,false); + search(lKeywords); +} + +void KviOptionsDialog::searchClicked() +{ + QString szTxt = m_pSearchLineEdit->text().stripWhiteSpace(); + if(!szTxt.isEmpty()) + search(szTxt); +} + +void KviOptionsDialog::fillListView(KviTalListViewItem * p,KviPointerList<KviOptionsWidgetInstanceEntry> * l,const QString &szGroup,bool bNotContainedOnly) +{ + if(!l)return; + + KviOptionsListViewItem * it; + KviOptionsWidgetInstanceEntry * e; + + KviPointerList<KviOptionsWidgetInstanceEntry> tmp; + tmp.setAutoDelete(false); + + + for(e = l->first();e;e = l->next()) + { + // must be in the correct group + // if we want only containers then well.. must be one + e->bDoInsert = KviQString::equalCI(szGroup,e->szGroup) && ((!bNotContainedOnly) || e->bIsContainer || e->bIsNotContained); + KviOptionsWidgetInstanceEntry * ee = tmp.first(); + int idx = 0; + while(ee) + { + if(ee->iPriority >= e->iPriority)break; + idx++; + ee = tmp.next(); + } + tmp.insert(idx,e); + } + + for(e = tmp.first();e;e = tmp.next()) + { + if(e->bDoInsert) + { + if(p)it = new KviOptionsListViewItem(p,e); + else it = new KviOptionsListViewItem(m_pListView,e); + if(!it->m_pOptionsWidget) + { + it->m_pOptionsWidget = g_pOptionsInstanceManager->getInstance(it->m_pInstanceEntry,m_pWidgetStack); + m_pWidgetStack->addWidget(it->m_pOptionsWidget); + } + } else { + it = (KviOptionsListViewItem *)p; + } + + if(e->pChildList) + { + if(e->bIsContainer) + { + // it's a container: add only eventual not contained children (containers or explicitly marked as not contained) + fillListView(it,e->pChildList,szGroup,true); + } else { + // it's not a container, add any children + fillListView(it,e->pChildList,szGroup,false); + } + } + } +} + +void KviOptionsDialog::listViewItemSelectionChanged(KviTalListViewItem *it) +{ + if(it) + { + QString str = it->text(0); + KviTalListViewItem * par = it->parent(); + + while(par) + { + str.prepend(" :: "); + str.prepend(par->text(0)); + par = par->parent(); + } + str.prepend("<b>"); + str += "</b>"; + + KviOptionsListViewItem *i = (KviOptionsListViewItem *)it; + if(!i->m_pOptionsWidget) + { + i->m_pOptionsWidget = g_pOptionsInstanceManager->getInstance(i->m_pInstanceEntry,m_pWidgetStack); + m_pWidgetStack->addWidget(i->m_pOptionsWidget); + } + + int idx = m_pWidgetStack->indexOf(i->m_pOptionsWidget); + m_pWidgetStack->setCurrentWidget(m_pWidgetStack->widget(idx)); + m_pCategoryLabel->setText(str); + } +} + +KviOptionsListViewItem * KviOptionsDialog::findItemByPage(KviOptionsListViewItem *it,KviOptionsWidget * pPage) +{ + if(!it)return 0; + if(it->m_pOptionsWidget == pPage)return it; + + KviOptionsListViewItem *i; + // run through the children + i = (KviOptionsListViewItem *)(it->firstChild()); + if(i) + { + i = findItemByPage(i,pPage); + if(i)return i; + } + + // not found in the children tree.. look in the next sibling + i = (KviOptionsListViewItem *)(it->nextSibling()); + if(i) + { + i = findItemByPage(i,pPage); + if(i)return i; + } + return 0; +} + + +void KviOptionsDialog::pageWantsToSwitchToAdvancedPage(KviOptionsWidget * pPage) +{ + // unused +} + +void KviOptionsDialog::applyClicked() +{ + apply(false); +} + +void KviOptionsDialog::apply(bool bDialogAboutToClose) +{ + + KviOptionsListViewItem *it = (KviOptionsListViewItem *)m_pListView->firstChild(); + while(it) + { + recursiveCommit(it); + it = (KviOptionsListViewItem *)it->nextSibling(); + } + + if(!bDialogAboutToClose) + { + // bring up the current widget again! + it = (KviOptionsListViewItem *)m_pListView->currentItem(); + if(it)listViewItemSelectionChanged(it); + } + + g_pApp->saveConfiguration(); + +} + +void KviOptionsDialog::okClicked() +{ + apply(true); + delete this; +} + +void KviOptionsDialog::cancelClicked() +{ + delete this; +} + +void KviOptionsDialog::closeEvent(QCloseEvent *e) +{ + e->ignore(); + delete this; +} + +void KviOptionsDialog::recursiveCommit(KviOptionsListViewItem *it) +{ + // First commit the children + if(!it) return; + KviOptionsListViewItem *it2 = (KviOptionsListViewItem *)it->firstChild(); + while(it2) + { + recursiveCommit(it2); + it2 = (KviOptionsListViewItem *)it2->nextSibling(); + } + // then the parents + if(it->m_pOptionsWidget) + { + it->m_pOptionsWidget->commit(); + delete it->m_pOptionsWidget; + it->m_pOptionsWidget = 0; + } + //refreshListView(); // <-- this tends to jump into infinite recursion +} +void KviOptionsDialog::keyPressEvent( QKeyEvent * e ) +{ + if(e->key()==Qt::Key_Return) + e->accept(); + else + e->ignore(); +} + +#ifndef COMPILE_USE_STANDALONE_MOC_SOURCES +#include "m_dialog.moc" +#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES diff --git a/src/modules/options/instances.cpp b/src/modules/options/instances.cpp new file mode 100644 index 000000000..ed5359513 --- /dev/null +++ b/src/modules/options/instances.cpp @@ -0,0 +1,3589 @@ + + +// +// File : instances.cpp +// +// This file is part of the KVirc irc client distribution +// Copyright (C) 2001 Szymon Stefanek (stefanek@tin.it) +// +// This program is FREE software. You can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your opinion) any later version. +// +// This program is distributed in the HOPE that it will be USEFUL, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, write to the Free Software Foundation, +// Inc. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// + +// +// Instance creation routines for the KVIrc options module +// DO NOT EDIT THIS FILE!! ALL CHANGES WILL BE LOST!! +// This file is automatically generated by mkcreateinstanceproc.sh +// so any change should go in that script +// + +#include "instances.h" + +#include "optw_antispam.h" +#include "optw_avatar.h" +#include "optw_away.h" +#include "optw_connection.h" +#include "optw_ctcp.h" +#include "optw_ctcpfloodprotection.h" +#include "optw_dcc.h" +#include "optw_generalopt.h" +#include "optw_highlighting.h" +#include "optw_identity.h" +#include "optw_ignore.h" +#include "optw_input.h" +#include "optw_interfacefeatures.h" +#include "optw_interfacelookglobal.h" +#include "optw_irc.h" +#include "optw_ircoutput.h" +#include "optw_ircview.h" +#include "optw_lag.h" +#include "optw_logging.h" +#include "optw_mediatypes.h" +#include "optw_messages.h" +#include "optw_nickserv.h" +#include "optw_notify.h" +#include "optw_protection.h" +#include "optw_proxy.h" +#include "optw_query.h" +#include "optw_servers.h" +#include "optw_sound.h" +#include "optw_taskbar.h" +#include "optw_textencoding.h" +#include "optw_texticons.h" +#include "optw_tools.h" +#include "optw_topiclabel.h" +#include "optw_tray.h" +#include "optw_uparser.h" +#include "optw_urlhandlers.h" +#include "optw_userlist.h" + +#include "kvi_locale.h" +#include "kvi_iconmanager.h" + +int g_iOptionWidgetInstances = 0; + +KviOptionsWidget * classKviAntispamOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviAntispamOptionsWidget(parent); +} + +KviOptionsWidget * classKviAvatarAdvancedOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviAvatarAdvancedOptionsWidget(parent); +} + +KviOptionsWidget * classKviAwayOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviAwayOptionsWidget(parent); +} + +KviOptionsWidget * classKviConnectionOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviConnectionOptionsWidget(parent); +} + +KviOptionsWidget * classKviConnectionAdvancedOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviConnectionAdvancedOptionsWidget(parent); +} + +KviOptionsWidget * classKviSSLOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviSSLOptionsWidget(parent); +} + +KviOptionsWidget * classKviTransportOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTransportOptionsWidget(parent); +} + +KviOptionsWidget * classKviIdentOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIdentOptionsWidget(parent); +} + +KviOptionsWidget * classKviCtcpOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviCtcpOptionsWidget(parent); +} + +KviOptionsWidget * classKviCtcpFloodProtectionOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviCtcpFloodProtectionOptionsWidget(parent); +} + +KviOptionsWidget * classKviDccOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviDccOptionsWidget(parent); +} + +KviOptionsWidget * classKviDccGeneralOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviDccGeneralOptionsWidget(parent); +} + +KviOptionsWidget * classKviDccAdvancedOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviDccAdvancedOptionsWidget(parent); +} + +KviOptionsWidget * classKviDccSendOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviDccSendOptionsWidget(parent); +} + +KviOptionsWidget * classKviDccSendGeneralOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviDccSendGeneralOptionsWidget(parent); +} + +KviOptionsWidget * classKviDccSendAdvancedOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviDccSendAdvancedOptionsWidget(parent); +} + +KviOptionsWidget * classKviDccChatOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviDccChatOptionsWidget(parent); +} + +KviOptionsWidget * classKviDccVoiceOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviDccVoiceOptionsWidget(parent); +} + +KviOptionsWidget * classKviGeneralOptOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviGeneralOptOptionsWidget(parent); +} + +KviOptionsWidget * classKviAlertHighlightingOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviAlertHighlightingOptionsWidget(parent); +} + +KviOptionsWidget * classKviHighlightingOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviHighlightingOptionsWidget(parent); +} + +KviOptionsWidget * classKviAlertOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviAlertOptionsWidget(parent); +} + +KviOptionsWidget * classKviIdentityOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIdentityOptionsWidget(parent); +} + +KviOptionsWidget * classKviIdentityGeneralOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIdentityGeneralOptionsWidget(parent); +} + +KviOptionsWidget * classKviIdentityAvatarOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIdentityAvatarOptionsWidget(parent); +} + +KviOptionsWidget * classKviIdentityAdvancedOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIdentityAdvancedOptionsWidget(parent); +} + +KviOptionsWidget * classKviIgnoreOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIgnoreOptionsWidget(parent); +} + +KviOptionsWidget * classKviInputLookOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviInputLookOptionsWidget(parent); +} + +KviOptionsWidget * classKviInputFeaturesOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviInputFeaturesOptionsWidget(parent); +} + +KviOptionsWidget * classKviInterfaceFeaturesOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviInterfaceFeaturesOptionsWidget(parent); +} + +KviOptionsWidget * classKviThemeGeneralOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviThemeGeneralOptionsWidget(parent); +} + +KviOptionsWidget * classKviThemeTransparencyOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviThemeTransparencyOptionsWidget(parent); +} + +KviOptionsWidget * classKviThemeMdiCaptionsOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviThemeMdiCaptionsOptionsWidget(parent); +} + +KviOptionsWidget * classKviThemeMdiAreaOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviThemeMdiAreaOptionsWidget(parent); +} + +KviOptionsWidget * classKviThemeToolBarAppletsOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviThemeToolBarAppletsOptionsWidget(parent); +} + +KviOptionsWidget * classKviIrcOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIrcOptionsWidget(parent); +} + +KviOptionsWidget * classKviIrcGeneralOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIrcGeneralOptionsWidget(parent); +} + +KviOptionsWidget * classKviIrcAdvancedOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIrcAdvancedOptionsWidget(parent); +} + +KviOptionsWidget * classKviChannelOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviChannelOptionsWidget(parent); +} + +KviOptionsWidget * classKviChannelGeneralOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviChannelGeneralOptionsWidget(parent); +} + +KviOptionsWidget * classKviChannelAdvancedOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviChannelAdvancedOptionsWidget(parent); +} + +KviOptionsWidget * classKviIrcOutputOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIrcOutputOptionsWidget(parent); +} + +KviOptionsWidget * classKviIrcViewThemeOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIrcViewThemeOptionsWidget(parent); +} + +KviOptionsWidget * classKviIrcViewLookOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIrcViewLookOptionsWidget(parent); +} + +KviOptionsWidget * classKviIrcViewFeaturesOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviIrcViewFeaturesOptionsWidget(parent); +} + +KviOptionsWidget * classKviLagOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviLagOptionsWidget(parent); +} + +KviOptionsWidget * classKviLoggingOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviLoggingOptionsWidget(parent); +} + +KviOptionsWidget * classKviMediaTypesOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviMediaTypesOptionsWidget(parent); +} + +KviOptionsWidget * classKviMessageOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviMessageOptionsWidget(parent); +} + +KviOptionsWidget * classKviPrivmsgOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviPrivmsgOptionsWidget(parent); +} + +KviOptionsWidget * classKviTimestampOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTimestampOptionsWidget(parent); +} + +KviOptionsWidget * classKviMessageColorsOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviMessageColorsOptionsWidget(parent); +} + +KviOptionsWidget * classKviStandardColorsOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviStandardColorsOptionsWidget(parent); +} + +KviOptionsWidget * classKviNickServOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviNickServOptionsWidget(parent); +} + +KviOptionsWidget * classKviNotifyOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviNotifyOptionsWidget(parent); +} + +KviOptionsWidget * classKviNotifierOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviNotifierOptionsWidget(parent); +} + +KviOptionsWidget * classKviProtectionOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviProtectionOptionsWidget(parent); +} + +KviOptionsWidget * classKviProxyOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviProxyOptionsWidget(parent); +} + +KviOptionsWidget * classKviQueryOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviQueryOptionsWidget(parent); +} + +KviOptionsWidget * classKviServerOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviServerOptionsWidget(parent); +} + +KviOptionsWidget * classKviSoundOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviSoundOptionsWidget(parent); +} + +KviOptionsWidget * classKviSoundGeneralOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviSoundGeneralOptionsWidget(parent); +} + +KviOptionsWidget * classKviSoundsOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviSoundsOptionsWidget(parent); +} + +KviOptionsWidget * classKviTaskBarOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTaskBarOptionsWidget(parent); +} + +KviOptionsWidget * classKviTreeTaskBarOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTreeTaskBarOptionsWidget(parent); +} + +KviOptionsWidget * classKviTreeTaskBarForegroundOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTreeTaskBarForegroundOptionsWidget(parent); +} + +KviOptionsWidget * classKviTreeTaskBarBackgroundOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTreeTaskBarBackgroundOptionsWidget(parent); +} + +KviOptionsWidget * classKviTreeTaskBarFeaturesOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTreeTaskBarFeaturesOptionsWidget(parent); +} + +KviOptionsWidget * classKviClassicTaskBarOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviClassicTaskBarOptionsWidget(parent); +} + +KviOptionsWidget * classKviTextEncodingOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTextEncodingOptionsWidget(parent); +} + +KviOptionsWidget * classKviTextIconsOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTextIconsOptionsWidget(parent); +} + +KviOptionsWidget * classKviToolsOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviToolsOptionsWidget(parent); +} + +KviOptionsWidget * classKviTopicLabelLookOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTopicLabelLookOptionsWidget(parent); +} + +KviOptionsWidget * classKviTrayOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviTrayOptionsWidget(parent); +} + +KviOptionsWidget * classKviUParserOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviUParserOptionsWidget(parent); +} + +KviOptionsWidget * classKviUrlHandlersOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviUrlHandlersOptionsWidget(parent); +} + +KviOptionsWidget * classKviUserListLookOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviUserListLookOptionsWidget(parent); +} + +KviOptionsWidget * classKviUserListLookBackgroundOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviUserListLookBackgroundOptionsWidget(parent); +} + +KviOptionsWidget * classKviUserListLookForegroundOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviUserListLookForegroundOptionsWidget(parent); +} + +KviOptionsWidget * classKviUserListGridOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviUserListGridOptionsWidget(parent); +} + +KviOptionsWidget * classKviUserListFeaturesOptionsWidget_createInstanceProc(QWidget * parent) +{ + return new KviUserListFeaturesOptionsWidget(parent); +} + + + +static const char * g_szName_KviAntispamOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviAntispamOptionsWidget; +static const char * g_szClassName_KviAntispamOptionsWidget = "KviAntispamOptionsWidget"; +static const char * g_szName_KviAvatarAdvancedOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviAvatarAdvancedOptionsWidget; +static const char * g_szClassName_KviAvatarAdvancedOptionsWidget = "KviAvatarAdvancedOptionsWidget"; +static const char * g_szName_KviAwayOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviAwayOptionsWidget; +static const char * g_szClassName_KviAwayOptionsWidget = "KviAwayOptionsWidget"; +static const char * g_szName_KviConnectionOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviConnectionOptionsWidget; +static const char * g_szClassName_KviConnectionOptionsWidget = "KviConnectionOptionsWidget"; +static const char * g_szName_KviConnectionAdvancedOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviConnectionAdvancedOptionsWidget; +static const char * g_szClassName_KviConnectionAdvancedOptionsWidget = "KviConnectionAdvancedOptionsWidget"; +static const char * g_szName_KviSSLOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviSSLOptionsWidget; +static const char * g_szClassName_KviSSLOptionsWidget = "KviSSLOptionsWidget"; +static const char * g_szName_KviTransportOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTransportOptionsWidget; +static const char * g_szClassName_KviTransportOptionsWidget = "KviTransportOptionsWidget"; +static const char * g_szName_KviIdentOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIdentOptionsWidget; +static const char * g_szClassName_KviIdentOptionsWidget = "KviIdentOptionsWidget"; +static const char * g_szName_KviCtcpOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviCtcpOptionsWidget; +static const char * g_szClassName_KviCtcpOptionsWidget = "KviCtcpOptionsWidget"; +static const char * g_szName_KviCtcpFloodProtectionOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviCtcpFloodProtectionOptionsWidget; +static const char * g_szClassName_KviCtcpFloodProtectionOptionsWidget = "KviCtcpFloodProtectionOptionsWidget"; +static const char * g_szName_KviDccOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviDccOptionsWidget; +static const char * g_szClassName_KviDccOptionsWidget = "KviDccOptionsWidget"; +static const char * g_szName_KviDccGeneralOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviDccGeneralOptionsWidget; +static const char * g_szClassName_KviDccGeneralOptionsWidget = "KviDccGeneralOptionsWidget"; +static const char * g_szName_KviDccAdvancedOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviDccAdvancedOptionsWidget; +static const char * g_szClassName_KviDccAdvancedOptionsWidget = "KviDccAdvancedOptionsWidget"; +static const char * g_szName_KviDccSendOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviDccSendOptionsWidget; +static const char * g_szClassName_KviDccSendOptionsWidget = "KviDccSendOptionsWidget"; +static const char * g_szName_KviDccSendGeneralOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviDccSendGeneralOptionsWidget; +static const char * g_szClassName_KviDccSendGeneralOptionsWidget = "KviDccSendGeneralOptionsWidget"; +static const char * g_szName_KviDccSendAdvancedOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviDccSendAdvancedOptionsWidget; +static const char * g_szClassName_KviDccSendAdvancedOptionsWidget = "KviDccSendAdvancedOptionsWidget"; +static const char * g_szName_KviDccChatOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviDccChatOptionsWidget; +static const char * g_szClassName_KviDccChatOptionsWidget = "KviDccChatOptionsWidget"; +static const char * g_szName_KviDccVoiceOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviDccVoiceOptionsWidget; +static const char * g_szClassName_KviDccVoiceOptionsWidget = "KviDccVoiceOptionsWidget"; +static const char * g_szName_KviGeneralOptOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviGeneralOptOptionsWidget; +static const char * g_szClassName_KviGeneralOptOptionsWidget = "KviGeneralOptOptionsWidget"; +static const char * g_szName_KviAlertHighlightingOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviAlertHighlightingOptionsWidget; +static const char * g_szClassName_KviAlertHighlightingOptionsWidget = "KviAlertHighlightingOptionsWidget"; +static const char * g_szName_KviHighlightingOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviHighlightingOptionsWidget; +static const char * g_szClassName_KviHighlightingOptionsWidget = "KviHighlightingOptionsWidget"; +static const char * g_szName_KviAlertOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviAlertOptionsWidget; +static const char * g_szClassName_KviAlertOptionsWidget = "KviAlertOptionsWidget"; +static const char * g_szName_KviIdentityOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIdentityOptionsWidget; +static const char * g_szClassName_KviIdentityOptionsWidget = "KviIdentityOptionsWidget"; +static const char * g_szName_KviIdentityGeneralOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIdentityGeneralOptionsWidget; +static const char * g_szClassName_KviIdentityGeneralOptionsWidget = "KviIdentityGeneralOptionsWidget"; +static const char * g_szName_KviIdentityAvatarOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIdentityAvatarOptionsWidget; +static const char * g_szClassName_KviIdentityAvatarOptionsWidget = "KviIdentityAvatarOptionsWidget"; +static const char * g_szName_KviIdentityAdvancedOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIdentityAdvancedOptionsWidget; +static const char * g_szClassName_KviIdentityAdvancedOptionsWidget = "KviIdentityAdvancedOptionsWidget"; +static const char * g_szName_KviIgnoreOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIgnoreOptionsWidget; +static const char * g_szClassName_KviIgnoreOptionsWidget = "KviIgnoreOptionsWidget"; +static const char * g_szName_KviInputLookOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviInputLookOptionsWidget; +static const char * g_szClassName_KviInputLookOptionsWidget = "KviInputLookOptionsWidget"; +static const char * g_szName_KviInputFeaturesOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviInputFeaturesOptionsWidget; +static const char * g_szClassName_KviInputFeaturesOptionsWidget = "KviInputFeaturesOptionsWidget"; +static const char * g_szName_KviInterfaceFeaturesOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviInterfaceFeaturesOptionsWidget; +static const char * g_szClassName_KviInterfaceFeaturesOptionsWidget = "KviInterfaceFeaturesOptionsWidget"; +static const char * g_szName_KviThemeGeneralOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviThemeGeneralOptionsWidget; +static const char * g_szClassName_KviThemeGeneralOptionsWidget = "KviThemeGeneralOptionsWidget"; +static const char * g_szName_KviThemeTransparencyOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviThemeTransparencyOptionsWidget; +static const char * g_szClassName_KviThemeTransparencyOptionsWidget = "KviThemeTransparencyOptionsWidget"; +static const char * g_szName_KviThemeMdiCaptionsOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviThemeMdiCaptionsOptionsWidget; +static const char * g_szClassName_KviThemeMdiCaptionsOptionsWidget = "KviThemeMdiCaptionsOptionsWidget"; +static const char * g_szName_KviThemeMdiAreaOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviThemeMdiAreaOptionsWidget; +static const char * g_szClassName_KviThemeMdiAreaOptionsWidget = "KviThemeMdiAreaOptionsWidget"; +static const char * g_szName_KviThemeToolBarAppletsOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviThemeToolBarAppletsOptionsWidget; +static const char * g_szClassName_KviThemeToolBarAppletsOptionsWidget = "KviThemeToolBarAppletsOptionsWidget"; +static const char * g_szName_KviIrcOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIrcOptionsWidget; +static const char * g_szClassName_KviIrcOptionsWidget = "KviIrcOptionsWidget"; +static const char * g_szName_KviIrcGeneralOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIrcGeneralOptionsWidget; +static const char * g_szClassName_KviIrcGeneralOptionsWidget = "KviIrcGeneralOptionsWidget"; +static const char * g_szName_KviIrcAdvancedOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIrcAdvancedOptionsWidget; +static const char * g_szClassName_KviIrcAdvancedOptionsWidget = "KviIrcAdvancedOptionsWidget"; +static const char * g_szName_KviChannelOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviChannelOptionsWidget; +static const char * g_szClassName_KviChannelOptionsWidget = "KviChannelOptionsWidget"; +static const char * g_szName_KviChannelGeneralOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviChannelGeneralOptionsWidget; +static const char * g_szClassName_KviChannelGeneralOptionsWidget = "KviChannelGeneralOptionsWidget"; +static const char * g_szName_KviChannelAdvancedOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviChannelAdvancedOptionsWidget; +static const char * g_szClassName_KviChannelAdvancedOptionsWidget = "KviChannelAdvancedOptionsWidget"; +static const char * g_szName_KviIrcOutputOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIrcOutputOptionsWidget; +static const char * g_szClassName_KviIrcOutputOptionsWidget = "KviIrcOutputOptionsWidget"; +static const char * g_szName_KviIrcViewThemeOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIrcViewThemeOptionsWidget; +static const char * g_szClassName_KviIrcViewThemeOptionsWidget = "KviIrcViewThemeOptionsWidget"; +static const char * g_szName_KviIrcViewLookOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIrcViewLookOptionsWidget; +static const char * g_szClassName_KviIrcViewLookOptionsWidget = "KviIrcViewLookOptionsWidget"; +static const char * g_szName_KviIrcViewFeaturesOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviIrcViewFeaturesOptionsWidget; +static const char * g_szClassName_KviIrcViewFeaturesOptionsWidget = "KviIrcViewFeaturesOptionsWidget"; +static const char * g_szName_KviLagOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviLagOptionsWidget; +static const char * g_szClassName_KviLagOptionsWidget = "KviLagOptionsWidget"; +static const char * g_szName_KviLoggingOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviLoggingOptionsWidget; +static const char * g_szClassName_KviLoggingOptionsWidget = "KviLoggingOptionsWidget"; +static const char * g_szName_KviMediaTypesOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviMediaTypesOptionsWidget; +static const char * g_szClassName_KviMediaTypesOptionsWidget = "KviMediaTypesOptionsWidget"; +static const char * g_szName_KviMessageOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviMessageOptionsWidget; +static const char * g_szClassName_KviMessageOptionsWidget = "KviMessageOptionsWidget"; +static const char * g_szName_KviPrivmsgOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviPrivmsgOptionsWidget; +static const char * g_szClassName_KviPrivmsgOptionsWidget = "KviPrivmsgOptionsWidget"; +static const char * g_szName_KviTimestampOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTimestampOptionsWidget; +static const char * g_szClassName_KviTimestampOptionsWidget = "KviTimestampOptionsWidget"; +static const char * g_szName_KviMessageColorsOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviMessageColorsOptionsWidget; +static const char * g_szClassName_KviMessageColorsOptionsWidget = "KviMessageColorsOptionsWidget"; +static const char * g_szName_KviStandardColorsOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviStandardColorsOptionsWidget; +static const char * g_szClassName_KviStandardColorsOptionsWidget = "KviStandardColorsOptionsWidget"; +static const char * g_szName_KviNickServOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviNickServOptionsWidget; +static const char * g_szClassName_KviNickServOptionsWidget = "KviNickServOptionsWidget"; +static const char * g_szName_KviNotifyOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviNotifyOptionsWidget; +static const char * g_szClassName_KviNotifyOptionsWidget = "KviNotifyOptionsWidget"; +static const char * g_szName_KviNotifierOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviNotifierOptionsWidget; +static const char * g_szClassName_KviNotifierOptionsWidget = "KviNotifierOptionsWidget"; +static const char * g_szName_KviProtectionOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviProtectionOptionsWidget; +static const char * g_szClassName_KviProtectionOptionsWidget = "KviProtectionOptionsWidget"; +static const char * g_szName_KviProxyOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviProxyOptionsWidget; +static const char * g_szClassName_KviProxyOptionsWidget = "KviProxyOptionsWidget"; +static const char * g_szName_KviQueryOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviQueryOptionsWidget; +static const char * g_szClassName_KviQueryOptionsWidget = "KviQueryOptionsWidget"; +static const char * g_szName_KviServerOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviServerOptionsWidget; +static const char * g_szClassName_KviServerOptionsWidget = "KviServerOptionsWidget"; +static const char * g_szName_KviSoundOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviSoundOptionsWidget; +static const char * g_szClassName_KviSoundOptionsWidget = "KviSoundOptionsWidget"; +static const char * g_szName_KviSoundGeneralOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviSoundGeneralOptionsWidget; +static const char * g_szClassName_KviSoundGeneralOptionsWidget = "KviSoundGeneralOptionsWidget"; +static const char * g_szName_KviSoundsOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviSoundsOptionsWidget; +static const char * g_szClassName_KviSoundsOptionsWidget = "KviSoundsOptionsWidget"; +static const char * g_szName_KviTaskBarOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTaskBarOptionsWidget; +static const char * g_szClassName_KviTaskBarOptionsWidget = "KviTaskBarOptionsWidget"; +static const char * g_szName_KviTreeTaskBarOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTreeTaskBarOptionsWidget; +static const char * g_szClassName_KviTreeTaskBarOptionsWidget = "KviTreeTaskBarOptionsWidget"; +static const char * g_szName_KviTreeTaskBarForegroundOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTreeTaskBarForegroundOptionsWidget; +static const char * g_szClassName_KviTreeTaskBarForegroundOptionsWidget = "KviTreeTaskBarForegroundOptionsWidget"; +static const char * g_szName_KviTreeTaskBarBackgroundOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTreeTaskBarBackgroundOptionsWidget; +static const char * g_szClassName_KviTreeTaskBarBackgroundOptionsWidget = "KviTreeTaskBarBackgroundOptionsWidget"; +static const char * g_szName_KviTreeTaskBarFeaturesOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTreeTaskBarFeaturesOptionsWidget; +static const char * g_szClassName_KviTreeTaskBarFeaturesOptionsWidget = "KviTreeTaskBarFeaturesOptionsWidget"; +static const char * g_szName_KviClassicTaskBarOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviClassicTaskBarOptionsWidget; +static const char * g_szClassName_KviClassicTaskBarOptionsWidget = "KviClassicTaskBarOptionsWidget"; +static const char * g_szName_KviTextEncodingOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTextEncodingOptionsWidget; +static const char * g_szClassName_KviTextEncodingOptionsWidget = "KviTextEncodingOptionsWidget"; +static const char * g_szName_KviTextIconsOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTextIconsOptionsWidget; +static const char * g_szClassName_KviTextIconsOptionsWidget = "KviTextIconsOptionsWidget"; +static const char * g_szName_KviToolsOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviToolsOptionsWidget; +static const char * g_szClassName_KviToolsOptionsWidget = "KviToolsOptionsWidget"; +static const char * g_szName_KviTopicLabelLookOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTopicLabelLookOptionsWidget; +static const char * g_szClassName_KviTopicLabelLookOptionsWidget = "KviTopicLabelLookOptionsWidget"; +static const char * g_szName_KviTrayOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviTrayOptionsWidget; +static const char * g_szClassName_KviTrayOptionsWidget = "KviTrayOptionsWidget"; +static const char * g_szName_KviUParserOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviUParserOptionsWidget; +static const char * g_szClassName_KviUParserOptionsWidget = "KviUParserOptionsWidget"; +static const char * g_szName_KviUrlHandlersOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviUrlHandlersOptionsWidget; +static const char * g_szClassName_KviUrlHandlersOptionsWidget = "KviUrlHandlersOptionsWidget"; +static const char * g_szName_KviUserListLookOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviUserListLookOptionsWidget; +static const char * g_szClassName_KviUserListLookOptionsWidget = "KviUserListLookOptionsWidget"; +static const char * g_szName_KviUserListLookBackgroundOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviUserListLookBackgroundOptionsWidget; +static const char * g_szClassName_KviUserListLookBackgroundOptionsWidget = "KviUserListLookBackgroundOptionsWidget"; +static const char * g_szName_KviUserListLookForegroundOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviUserListLookForegroundOptionsWidget; +static const char * g_szClassName_KviUserListLookForegroundOptionsWidget = "KviUserListLookForegroundOptionsWidget"; +static const char * g_szName_KviUserListGridOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviUserListGridOptionsWidget; +static const char * g_szClassName_KviUserListGridOptionsWidget = "KviUserListGridOptionsWidget"; +static const char * g_szName_KviUserListFeaturesOptionsWidget = KVI_OPTIONS_WIDGET_NAME_KviUserListFeaturesOptionsWidget; +static const char * g_szClassName_KviUserListFeaturesOptionsWidget = "KviUserListFeaturesOptionsWidget"; + +KviOptionsInstanceManager::KviOptionsInstanceManager() +: QObject(0) +{ + + //qDebug("Instantiating"); + // Create the global widget dict : case sensitive , do not copy keys + m_pInstanceTree = new KviPointerList<KviOptionsWidgetInstanceEntry>; + m_pInstanceTree->setAutoDelete(true); + + + KviOptionsWidgetInstanceEntry * e0; + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviConnectionOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviConnectionOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviConnectionOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviConnectionOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviConnectionOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviConnectionOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviConnectionOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviConnectionOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviConnectionOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviConnectionOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviConnectionOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviConnectionOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviConnectionOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviConnectionOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviConnectionOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + KviOptionsWidgetInstanceEntry * e1; + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviConnectionAdvancedOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviConnectionAdvancedOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviConnectionAdvancedOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviConnectionAdvancedOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviConnectionAdvancedOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviConnectionAdvancedOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviConnectionAdvancedOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviConnectionAdvancedOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviConnectionAdvancedOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviConnectionAdvancedOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviConnectionAdvancedOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviConnectionAdvancedOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviConnectionAdvancedOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviConnectionAdvancedOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviConnectionAdvancedOptionsWidget,"options"); + e0->pChildList->append(e1); + + e1->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e1->pChildList->setAutoDelete(true); + + KviOptionsWidgetInstanceEntry * e2; + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviSSLOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviSSLOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviSSLOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviSSLOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviSSLOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviSSLOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviSSLOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviSSLOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviSSLOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviSSLOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviSSLOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviSSLOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviSSLOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviSSLOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviSSLOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviTransportOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviTransportOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTransportOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTransportOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTransportOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTransportOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTransportOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTransportOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTransportOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTransportOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTransportOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTransportOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTransportOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviTransportOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTransportOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviIdentOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviIdentOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIdentOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIdentOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIdentOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIdentOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIdentOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIdentOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIdentOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviIdentOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIdentOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviProxyOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviProxyOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviProxyOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviProxyOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviProxyOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviProxyOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviProxyOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviProxyOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviProxyOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviProxyOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviProxyOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviProxyOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviProxyOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviProxyOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviProxyOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviDccOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviDccOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviDccOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviDccOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviDccOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviDccOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviDccOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviDccOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviDccOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviDccOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviDccOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviDccOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviDccOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviDccGeneralOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviDccGeneralOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviDccGeneralOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviDccGeneralOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviDccGeneralOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviDccGeneralOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviDccGeneralOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviDccGeneralOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviDccGeneralOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviDccGeneralOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviDccGeneralOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccGeneralOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccGeneralOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviDccGeneralOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviDccGeneralOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviDccAdvancedOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviDccAdvancedOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviDccAdvancedOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviDccAdvancedOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviDccAdvancedOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviDccAdvancedOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviDccAdvancedOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviDccAdvancedOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviDccAdvancedOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviDccAdvancedOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviDccAdvancedOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccAdvancedOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccAdvancedOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviDccAdvancedOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviDccAdvancedOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviDccSendOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviDccSendOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviDccSendOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviDccSendOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviDccSendOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviDccSendOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviDccSendOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviDccSendOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviDccSendOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviDccSendOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviDccSendOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccSendOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccSendOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviDccSendOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviDccSendOptionsWidget,"options"); + e0->pChildList->append(e1); + + e1->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e1->pChildList->setAutoDelete(true); + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviDccSendGeneralOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviDccSendGeneralOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviDccSendGeneralOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviDccSendGeneralOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviDccSendGeneralOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviDccSendGeneralOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviDccSendGeneralOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviDccSendGeneralOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviDccSendGeneralOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviDccSendGeneralOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviDccSendGeneralOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccSendGeneralOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccSendGeneralOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviDccSendGeneralOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviDccSendGeneralOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviDccSendAdvancedOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviDccSendAdvancedOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviDccSendAdvancedOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviDccSendAdvancedOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviDccSendAdvancedOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviDccSendAdvancedOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviDccSendAdvancedOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviDccSendAdvancedOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviDccSendAdvancedOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviDccSendAdvancedOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviDccSendAdvancedOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccSendAdvancedOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccSendAdvancedOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviDccSendAdvancedOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviDccSendAdvancedOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviDccChatOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviDccChatOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviDccChatOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviDccChatOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviDccChatOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviDccChatOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviDccChatOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviDccChatOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviDccChatOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviDccChatOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviDccChatOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccChatOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccChatOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviDccChatOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviDccChatOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviDccVoiceOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviDccVoiceOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviDccVoiceOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviDccVoiceOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviDccVoiceOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviDccVoiceOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviDccVoiceOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviDccVoiceOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviDccVoiceOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviDccVoiceOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviDccVoiceOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccVoiceOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviDccVoiceOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviDccVoiceOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviDccVoiceOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviGeneralOptOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviGeneralOptOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviGeneralOptOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviGeneralOptOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviGeneralOptOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviGeneralOptOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviGeneralOptOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviGeneralOptOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviGeneralOptOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviGeneralOptOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviGeneralOptOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviGeneralOptOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviGeneralOptOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviGeneralOptOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviGeneralOptOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviMediaTypesOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviMediaTypesOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviMediaTypesOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviMediaTypesOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviMediaTypesOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviMediaTypesOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviMediaTypesOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviMediaTypesOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviMediaTypesOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviMediaTypesOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviMediaTypesOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviMediaTypesOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviMediaTypesOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviMediaTypesOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviMediaTypesOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviSoundOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviSoundOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviSoundOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviSoundOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviSoundOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviSoundOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviSoundOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviSoundOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviSoundOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviSoundOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviSoundOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviSoundOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviSoundOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviSoundOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviSoundOptionsWidget,"options"); + e0->pChildList->append(e1); + + e1->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e1->pChildList->setAutoDelete(true); + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviSoundGeneralOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviSoundGeneralOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviSoundGeneralOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviSoundGeneralOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviSoundGeneralOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviSoundGeneralOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviSoundGeneralOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviSoundGeneralOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviSoundGeneralOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviSoundGeneralOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviSoundGeneralOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviSoundGeneralOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviSoundGeneralOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviSoundGeneralOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviSoundGeneralOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviSoundsOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviSoundsOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviSoundsOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviSoundsOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviSoundsOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviSoundsOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviSoundsOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviSoundsOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviSoundsOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviSoundsOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviSoundsOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviSoundsOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviSoundsOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviSoundsOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviSoundsOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviTextEncodingOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviTextEncodingOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTextEncodingOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTextEncodingOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTextEncodingOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTextEncodingOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTextEncodingOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTextEncodingOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTextEncodingOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTextEncodingOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTextEncodingOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTextEncodingOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTextEncodingOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviTextEncodingOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTextEncodingOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviUParserOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviUParserOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviUParserOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviUParserOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviUParserOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviUParserOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviUParserOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviUParserOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviUParserOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviUParserOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviUParserOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUParserOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUParserOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviUParserOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviUParserOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviUrlHandlersOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviUrlHandlersOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviUrlHandlersOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviUrlHandlersOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviUrlHandlersOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviUrlHandlersOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviUrlHandlersOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviUrlHandlersOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviUrlHandlersOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviUrlHandlersOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviUrlHandlersOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUrlHandlersOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUrlHandlersOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviUrlHandlersOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviUrlHandlersOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviIdentityOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviIdentityOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIdentityOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIdentityOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIdentityOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentityOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentityOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIdentityOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIdentityOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIdentityOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIdentityOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentityOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentityOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviIdentityOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIdentityOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviIdentityGeneralOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviIdentityGeneralOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIdentityGeneralOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIdentityGeneralOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIdentityGeneralOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentityGeneralOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentityGeneralOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIdentityGeneralOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIdentityGeneralOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIdentityGeneralOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIdentityGeneralOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentityGeneralOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentityGeneralOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviIdentityGeneralOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIdentityGeneralOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviIdentityAvatarOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviIdentityAvatarOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIdentityAvatarOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIdentityAvatarOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIdentityAvatarOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentityAvatarOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentityAvatarOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIdentityAvatarOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIdentityAvatarOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIdentityAvatarOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIdentityAvatarOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentityAvatarOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentityAvatarOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviIdentityAvatarOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIdentityAvatarOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviIdentityAdvancedOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviIdentityAdvancedOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIdentityAdvancedOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIdentityAdvancedOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIdentityAdvancedOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentityAdvancedOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIdentityAdvancedOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIdentityAdvancedOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIdentityAdvancedOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIdentityAdvancedOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIdentityAdvancedOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentityAdvancedOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIdentityAdvancedOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviIdentityAdvancedOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIdentityAdvancedOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviInputLookOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviInputLookOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviInputLookOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviInputLookOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviInputLookOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviInputLookOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviInputLookOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviInputLookOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviInputLookOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviInputLookOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviInputLookOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviInputLookOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviInputLookOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviInputLookOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviInputLookOptionsWidget,"options"); + m_pInstanceTree->append(e0); + e0->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviInterfaceFeaturesOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviInterfaceFeaturesOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviInterfaceFeaturesOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviInterfaceFeaturesOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviInterfaceFeaturesOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviInterfaceFeaturesOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviInterfaceFeaturesOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviInterfaceFeaturesOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviInterfaceFeaturesOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviInterfaceFeaturesOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviInterfaceFeaturesOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviInterfaceFeaturesOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviInterfaceFeaturesOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviInterfaceFeaturesOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviInterfaceFeaturesOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviInputFeaturesOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviInputFeaturesOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviInputFeaturesOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviInputFeaturesOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviInputFeaturesOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviInputFeaturesOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviInputFeaturesOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviInputFeaturesOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviInputFeaturesOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviInputFeaturesOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviInputFeaturesOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviInputFeaturesOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviInputFeaturesOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviInputFeaturesOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviInputFeaturesOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviNotifierOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviNotifierOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviNotifierOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviNotifierOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviNotifierOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviNotifierOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviNotifierOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviNotifierOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviNotifierOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviNotifierOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviNotifierOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviNotifierOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviNotifierOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviNotifierOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviNotifierOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviTrayOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviTrayOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTrayOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTrayOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTrayOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTrayOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTrayOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTrayOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTrayOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTrayOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTrayOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTrayOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTrayOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviTrayOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTrayOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviThemeGeneralOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviThemeGeneralOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviThemeGeneralOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviThemeGeneralOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviThemeGeneralOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeGeneralOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeGeneralOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviThemeGeneralOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviThemeGeneralOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviThemeGeneralOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviThemeGeneralOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeGeneralOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeGeneralOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviThemeGeneralOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviThemeGeneralOptionsWidget,"options"); + m_pInstanceTree->append(e0); + e0->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviThemeTransparencyOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviThemeTransparencyOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviThemeTransparencyOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviThemeTransparencyOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviThemeTransparencyOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeTransparencyOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeTransparencyOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviThemeTransparencyOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviThemeTransparencyOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviThemeTransparencyOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviThemeTransparencyOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeTransparencyOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeTransparencyOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviThemeTransparencyOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviThemeTransparencyOptionsWidget,"options"); + m_pInstanceTree->append(e0); + e0->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviThemeMdiCaptionsOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviThemeMdiCaptionsOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviThemeMdiCaptionsOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviThemeMdiCaptionsOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviThemeMdiCaptionsOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeMdiCaptionsOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeMdiCaptionsOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviThemeMdiCaptionsOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviThemeMdiCaptionsOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviThemeMdiCaptionsOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviThemeMdiCaptionsOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeMdiCaptionsOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeMdiCaptionsOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviThemeMdiCaptionsOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviThemeMdiCaptionsOptionsWidget,"options"); + m_pInstanceTree->append(e0); + e0->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviThemeMdiAreaOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviThemeMdiAreaOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviThemeMdiAreaOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviThemeMdiAreaOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviThemeMdiAreaOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeMdiAreaOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeMdiAreaOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviThemeMdiAreaOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviThemeMdiAreaOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviThemeMdiAreaOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviThemeMdiAreaOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeMdiAreaOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeMdiAreaOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviThemeMdiAreaOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviThemeMdiAreaOptionsWidget,"options"); + m_pInstanceTree->append(e0); + e0->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviThemeToolBarAppletsOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviThemeToolBarAppletsOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviThemeToolBarAppletsOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviThemeToolBarAppletsOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviThemeToolBarAppletsOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeToolBarAppletsOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviThemeToolBarAppletsOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviThemeToolBarAppletsOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviThemeToolBarAppletsOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviThemeToolBarAppletsOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviThemeToolBarAppletsOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeToolBarAppletsOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviThemeToolBarAppletsOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviThemeToolBarAppletsOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviThemeToolBarAppletsOptionsWidget,"options"); + m_pInstanceTree->append(e0); + e0->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviIrcOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviIrcOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIrcOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIrcOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIrcOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIrcOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIrcOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIrcOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIrcOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviIrcOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIrcOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviIrcGeneralOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviIrcGeneralOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIrcGeneralOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIrcGeneralOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIrcGeneralOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcGeneralOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcGeneralOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIrcGeneralOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIrcGeneralOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIrcGeneralOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIrcGeneralOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcGeneralOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcGeneralOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviIrcGeneralOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIrcGeneralOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviIrcAdvancedOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviIrcAdvancedOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIrcAdvancedOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIrcAdvancedOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIrcAdvancedOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcAdvancedOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcAdvancedOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIrcAdvancedOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIrcAdvancedOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIrcAdvancedOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIrcAdvancedOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcAdvancedOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcAdvancedOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviIrcAdvancedOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIrcAdvancedOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviChannelOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviChannelOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviChannelOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviChannelOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviChannelOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviChannelOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviChannelOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviChannelOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviChannelOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviChannelOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviChannelOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviChannelOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviChannelOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviChannelOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviChannelOptionsWidget,"options"); + e0->pChildList->append(e1); + + e1->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e1->pChildList->setAutoDelete(true); + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviChannelGeneralOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviChannelGeneralOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviChannelGeneralOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviChannelGeneralOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviChannelGeneralOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviChannelGeneralOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviChannelGeneralOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviChannelGeneralOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviChannelGeneralOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviChannelGeneralOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviChannelGeneralOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviChannelGeneralOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviChannelGeneralOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviChannelGeneralOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviChannelGeneralOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviChannelAdvancedOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviChannelAdvancedOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviChannelAdvancedOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviChannelAdvancedOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviChannelAdvancedOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviChannelAdvancedOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviChannelAdvancedOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviChannelAdvancedOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviChannelAdvancedOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviChannelAdvancedOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviChannelAdvancedOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviChannelAdvancedOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviChannelAdvancedOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviChannelAdvancedOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviChannelAdvancedOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviIrcOutputOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviIrcOutputOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIrcOutputOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIrcOutputOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIrcOutputOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcOutputOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcOutputOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIrcOutputOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIrcOutputOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIrcOutputOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIrcOutputOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcOutputOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcOutputOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviIrcOutputOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIrcOutputOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviProtectionOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviProtectionOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviProtectionOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviProtectionOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviProtectionOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviProtectionOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviProtectionOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviProtectionOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviProtectionOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviProtectionOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviProtectionOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviProtectionOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviProtectionOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviProtectionOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviProtectionOptionsWidget,"options"); + e0->pChildList->append(e1); + + e1->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e1->pChildList->setAutoDelete(true); + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviAntispamOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviAntispamOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviAntispamOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviAntispamOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviAntispamOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviAntispamOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviAntispamOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviAntispamOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviAntispamOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviAntispamOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviAntispamOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAntispamOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAntispamOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviAntispamOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviAntispamOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviCtcpFloodProtectionOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviCtcpFloodProtectionOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviCtcpFloodProtectionOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviCtcpFloodProtectionOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviCtcpFloodProtectionOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviCtcpFloodProtectionOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviCtcpFloodProtectionOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviCtcpFloodProtectionOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviCtcpFloodProtectionOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviCtcpFloodProtectionOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviCtcpFloodProtectionOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviCtcpFloodProtectionOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviCtcpFloodProtectionOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviCtcpFloodProtectionOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviCtcpFloodProtectionOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviIgnoreOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviIgnoreOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIgnoreOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIgnoreOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIgnoreOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIgnoreOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIgnoreOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIgnoreOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIgnoreOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIgnoreOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIgnoreOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIgnoreOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIgnoreOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviIgnoreOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIgnoreOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviQueryOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviQueryOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviQueryOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviQueryOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviQueryOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviQueryOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviQueryOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviQueryOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviQueryOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviQueryOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviQueryOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviQueryOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviQueryOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviQueryOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviQueryOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviToolsOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviToolsOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviToolsOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviToolsOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviToolsOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviToolsOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviToolsOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviToolsOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviToolsOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviToolsOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviToolsOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviToolsOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviToolsOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviToolsOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviToolsOptionsWidget,"options"); + e0->pChildList->append(e1); + + e1->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e1->pChildList->setAutoDelete(true); + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviAvatarAdvancedOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviAvatarAdvancedOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviAvatarAdvancedOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviAvatarAdvancedOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviAvatarAdvancedOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviAvatarAdvancedOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviAvatarAdvancedOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviAvatarAdvancedOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviAvatarAdvancedOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviAvatarAdvancedOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviAvatarAdvancedOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAvatarAdvancedOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAvatarAdvancedOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviAvatarAdvancedOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviAvatarAdvancedOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviAwayOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviAwayOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviAwayOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviAwayOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviAwayOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviAwayOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviAwayOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviAwayOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviAwayOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviAwayOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviAwayOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAwayOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAwayOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviAwayOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviAwayOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviCtcpOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviCtcpOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviCtcpOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviCtcpOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviCtcpOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviCtcpOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviCtcpOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviCtcpOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviCtcpOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviCtcpOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviCtcpOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviCtcpOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviCtcpOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviCtcpOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviCtcpOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviAlertHighlightingOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviAlertHighlightingOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviAlertHighlightingOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviAlertHighlightingOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviAlertHighlightingOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviAlertHighlightingOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviAlertHighlightingOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviAlertHighlightingOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviAlertHighlightingOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviAlertHighlightingOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviAlertHighlightingOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAlertHighlightingOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAlertHighlightingOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviAlertHighlightingOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviAlertHighlightingOptionsWidget,"options"); + e1->pChildList->append(e2); + + e2->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e2->pChildList->setAutoDelete(true); + + KviOptionsWidgetInstanceEntry * e3; + e3 = new KviOptionsWidgetInstanceEntry; + e3->createProc = &classKviHighlightingOptionsWidget_createInstanceProc; + e3->pWidget = 0; + e3->szClassName = g_szClassName_KviHighlightingOptionsWidget; + e3->iIcon = KVI_OPTIONS_WIDGET_ICON_KviHighlightingOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviHighlightingOptionsWidget + e3->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviHighlightingOptionsWidget; + #else + e3->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviHighlightingOptionsWidget + e3->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviHighlightingOptionsWidget; + e3->szKeywords = __tr2qs_ctx_no_xgettext(e3->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviHighlightingOptionsWidget + e3->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviHighlightingOptionsWidget; + #else + e3->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviHighlightingOptionsWidget + e3->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviHighlightingOptionsWidget; + #else + e3->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviHighlightingOptionsWidget + e3->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviHighlightingOptionsWidget; + #else + e3->bIsNotContained = false; + #endif + e3->szNameNoLocale = g_szName_KviHighlightingOptionsWidget; + e3->szName = __tr2qs_ctx_no_xgettext(g_szName_KviHighlightingOptionsWidget,"options"); + e2->pChildList->append(e3); + e3->pChildList = 0; + + e3 = new KviOptionsWidgetInstanceEntry; + e3->createProc = &classKviAlertOptionsWidget_createInstanceProc; + e3->pWidget = 0; + e3->szClassName = g_szClassName_KviAlertOptionsWidget; + e3->iIcon = KVI_OPTIONS_WIDGET_ICON_KviAlertOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviAlertOptionsWidget + e3->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviAlertOptionsWidget; + #else + e3->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviAlertOptionsWidget + e3->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviAlertOptionsWidget; + e3->szKeywords = __tr2qs_ctx_no_xgettext(e3->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviAlertOptionsWidget + e3->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviAlertOptionsWidget; + #else + e3->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviAlertOptionsWidget + e3->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviAlertOptionsWidget; + #else + e3->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAlertOptionsWidget + e3->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviAlertOptionsWidget; + #else + e3->bIsNotContained = false; + #endif + e3->szNameNoLocale = g_szName_KviAlertOptionsWidget; + e3->szName = __tr2qs_ctx_no_xgettext(g_szName_KviAlertOptionsWidget,"options"); + e2->pChildList->append(e3); + e3->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviLagOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviLagOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviLagOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviLagOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviLagOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviLagOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviLagOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviLagOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviLagOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviLagOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviLagOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviLagOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviLagOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviLagOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviLagOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviLoggingOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviLoggingOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviLoggingOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviLoggingOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviLoggingOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviLoggingOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviLoggingOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviLoggingOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviLoggingOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviLoggingOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviLoggingOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviLoggingOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviLoggingOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviLoggingOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviLoggingOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviNickServOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviNickServOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviNickServOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviNickServOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviNickServOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviNickServOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviNickServOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviNickServOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviNickServOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviNickServOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviNickServOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviNickServOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviNickServOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviNickServOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviNickServOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviNotifyOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviNotifyOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviNotifyOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviNotifyOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviNotifyOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviNotifyOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviNotifyOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviNotifyOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviNotifyOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviNotifyOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviNotifyOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviNotifyOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviNotifyOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviNotifyOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviNotifyOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviTextIconsOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviTextIconsOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTextIconsOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTextIconsOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTextIconsOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTextIconsOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTextIconsOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTextIconsOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTextIconsOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTextIconsOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTextIconsOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTextIconsOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTextIconsOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviTextIconsOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTextIconsOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviIrcViewThemeOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviIrcViewThemeOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIrcViewThemeOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIrcViewThemeOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIrcViewThemeOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcViewThemeOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcViewThemeOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIrcViewThemeOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIrcViewThemeOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIrcViewThemeOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIrcViewThemeOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcViewThemeOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcViewThemeOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviIrcViewThemeOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIrcViewThemeOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviIrcViewLookOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviIrcViewLookOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIrcViewLookOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIrcViewLookOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIrcViewLookOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcViewLookOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcViewLookOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIrcViewLookOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIrcViewLookOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIrcViewLookOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIrcViewLookOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcViewLookOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcViewLookOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviIrcViewLookOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIrcViewLookOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviIrcViewFeaturesOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviIrcViewFeaturesOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviIrcViewFeaturesOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviIrcViewFeaturesOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviIrcViewFeaturesOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcViewFeaturesOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviIrcViewFeaturesOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviIrcViewFeaturesOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviIrcViewFeaturesOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviIrcViewFeaturesOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviIrcViewFeaturesOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcViewFeaturesOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviIrcViewFeaturesOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviIrcViewFeaturesOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviIrcViewFeaturesOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviMessageOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviMessageOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviMessageOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviMessageOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviMessageOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviMessageOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviMessageOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviMessageOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviMessageOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviMessageOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviMessageOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviMessageOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviMessageOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviMessageOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviMessageOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviPrivmsgOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviPrivmsgOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviPrivmsgOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviPrivmsgOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviPrivmsgOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviPrivmsgOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviPrivmsgOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviPrivmsgOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviPrivmsgOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviPrivmsgOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviPrivmsgOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviPrivmsgOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviPrivmsgOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviPrivmsgOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviPrivmsgOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviTimestampOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviTimestampOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTimestampOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTimestampOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTimestampOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTimestampOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTimestampOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTimestampOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTimestampOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTimestampOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTimestampOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTimestampOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTimestampOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviTimestampOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTimestampOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviMessageColorsOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviMessageColorsOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviMessageColorsOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviMessageColorsOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviMessageColorsOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviMessageColorsOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviMessageColorsOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviMessageColorsOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviMessageColorsOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviMessageColorsOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviMessageColorsOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviMessageColorsOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviMessageColorsOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviMessageColorsOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviMessageColorsOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviStandardColorsOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviStandardColorsOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviStandardColorsOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviStandardColorsOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviStandardColorsOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviStandardColorsOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviStandardColorsOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviStandardColorsOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviStandardColorsOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviStandardColorsOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviStandardColorsOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviStandardColorsOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviStandardColorsOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviStandardColorsOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviStandardColorsOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviServerOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviServerOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviServerOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviServerOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviServerOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviServerOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviServerOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviServerOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviServerOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviServerOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviServerOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviServerOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviServerOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviServerOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviServerOptionsWidget,"options"); + m_pInstanceTree->append(e0); + e0->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviTaskBarOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviTaskBarOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTaskBarOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTaskBarOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTaskBarOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTaskBarOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTaskBarOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTaskBarOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTaskBarOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTaskBarOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTaskBarOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTaskBarOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTaskBarOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviTaskBarOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTaskBarOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviTreeTaskBarOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviTreeTaskBarOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTreeTaskBarOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTreeTaskBarOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTreeTaskBarOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTreeTaskBarOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTreeTaskBarOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTreeTaskBarOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTreeTaskBarOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTreeTaskBarOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTreeTaskBarOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTreeTaskBarOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTreeTaskBarOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviTreeTaskBarOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTreeTaskBarOptionsWidget,"options"); + e0->pChildList->append(e1); + + e1->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e1->pChildList->setAutoDelete(true); + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviTreeTaskBarForegroundOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviTreeTaskBarForegroundOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTreeTaskBarForegroundOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTreeTaskBarForegroundOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTreeTaskBarForegroundOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTreeTaskBarForegroundOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTreeTaskBarForegroundOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTreeTaskBarForegroundOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTreeTaskBarForegroundOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTreeTaskBarForegroundOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTreeTaskBarForegroundOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTreeTaskBarForegroundOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTreeTaskBarForegroundOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviTreeTaskBarForegroundOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTreeTaskBarForegroundOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviTreeTaskBarBackgroundOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviTreeTaskBarBackgroundOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTreeTaskBarBackgroundOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTreeTaskBarBackgroundOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTreeTaskBarBackgroundOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTreeTaskBarBackgroundOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTreeTaskBarBackgroundOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTreeTaskBarBackgroundOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTreeTaskBarBackgroundOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTreeTaskBarBackgroundOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTreeTaskBarBackgroundOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTreeTaskBarBackgroundOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTreeTaskBarBackgroundOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviTreeTaskBarBackgroundOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTreeTaskBarBackgroundOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e2 = new KviOptionsWidgetInstanceEntry; + e2->createProc = &classKviTreeTaskBarFeaturesOptionsWidget_createInstanceProc; + e2->pWidget = 0; + e2->szClassName = g_szClassName_KviTreeTaskBarFeaturesOptionsWidget; + e2->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTreeTaskBarFeaturesOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTreeTaskBarFeaturesOptionsWidget + e2->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTreeTaskBarFeaturesOptionsWidget; + #else + e2->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTreeTaskBarFeaturesOptionsWidget + e2->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTreeTaskBarFeaturesOptionsWidget; + e2->szKeywords = __tr2qs_ctx_no_xgettext(e2->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTreeTaskBarFeaturesOptionsWidget + e2->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTreeTaskBarFeaturesOptionsWidget; + #else + e2->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTreeTaskBarFeaturesOptionsWidget + e2->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTreeTaskBarFeaturesOptionsWidget; + #else + e2->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTreeTaskBarFeaturesOptionsWidget + e2->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTreeTaskBarFeaturesOptionsWidget; + #else + e2->bIsNotContained = false; + #endif + e2->szNameNoLocale = g_szName_KviTreeTaskBarFeaturesOptionsWidget; + e2->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTreeTaskBarFeaturesOptionsWidget,"options"); + e1->pChildList->append(e2); + e2->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviClassicTaskBarOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviClassicTaskBarOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviClassicTaskBarOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviClassicTaskBarOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviClassicTaskBarOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviClassicTaskBarOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviClassicTaskBarOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviClassicTaskBarOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviClassicTaskBarOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviClassicTaskBarOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviClassicTaskBarOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviClassicTaskBarOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviClassicTaskBarOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviClassicTaskBarOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviClassicTaskBarOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviTopicLabelLookOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviTopicLabelLookOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviTopicLabelLookOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviTopicLabelLookOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviTopicLabelLookOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviTopicLabelLookOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviTopicLabelLookOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviTopicLabelLookOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviTopicLabelLookOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviTopicLabelLookOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviTopicLabelLookOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTopicLabelLookOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviTopicLabelLookOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviTopicLabelLookOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviTopicLabelLookOptionsWidget,"options"); + m_pInstanceTree->append(e0); + e0->pChildList = 0; + + e0 = new KviOptionsWidgetInstanceEntry; + e0->createProc = &classKviUserListLookOptionsWidget_createInstanceProc; + e0->pWidget = 0; + e0->szClassName = g_szClassName_KviUserListLookOptionsWidget; + e0->iIcon = KVI_OPTIONS_WIDGET_ICON_KviUserListLookOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviUserListLookOptionsWidget + e0->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviUserListLookOptionsWidget; + #else + e0->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListLookOptionsWidget + e0->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListLookOptionsWidget; + e0->szKeywords = __tr2qs_ctx_no_xgettext(e0->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviUserListLookOptionsWidget + e0->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviUserListLookOptionsWidget; + #else + e0->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviUserListLookOptionsWidget + e0->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviUserListLookOptionsWidget; + #else + e0->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListLookOptionsWidget + e0->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListLookOptionsWidget; + #else + e0->bIsNotContained = false; + #endif + e0->szNameNoLocale = g_szName_KviUserListLookOptionsWidget; + e0->szName = __tr2qs_ctx_no_xgettext(g_szName_KviUserListLookOptionsWidget,"options"); + m_pInstanceTree->append(e0); + + e0->pChildList = new KviPointerList<KviOptionsWidgetInstanceEntry>; + e0->pChildList->setAutoDelete(true); + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviUserListLookBackgroundOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviUserListLookBackgroundOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviUserListLookBackgroundOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviUserListLookBackgroundOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviUserListLookBackgroundOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListLookBackgroundOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListLookBackgroundOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviUserListLookBackgroundOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviUserListLookBackgroundOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviUserListLookBackgroundOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviUserListLookBackgroundOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListLookBackgroundOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListLookBackgroundOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviUserListLookBackgroundOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviUserListLookBackgroundOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviUserListLookForegroundOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviUserListLookForegroundOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviUserListLookForegroundOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviUserListLookForegroundOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviUserListLookForegroundOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListLookForegroundOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListLookForegroundOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviUserListLookForegroundOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviUserListLookForegroundOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviUserListLookForegroundOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviUserListLookForegroundOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListLookForegroundOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListLookForegroundOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviUserListLookForegroundOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviUserListLookForegroundOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviUserListGridOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviUserListGridOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviUserListGridOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviUserListGridOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviUserListGridOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListGridOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListGridOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviUserListGridOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviUserListGridOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviUserListGridOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviUserListGridOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListGridOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListGridOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviUserListGridOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviUserListGridOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + + e1 = new KviOptionsWidgetInstanceEntry; + e1->createProc = &classKviUserListFeaturesOptionsWidget_createInstanceProc; + e1->pWidget = 0; + e1->szClassName = g_szClassName_KviUserListFeaturesOptionsWidget; + e1->iIcon = KVI_OPTIONS_WIDGET_ICON_KviUserListFeaturesOptionsWidget; + #ifdef KVI_OPTIONS_WIDGET_PRIORITY_KviUserListFeaturesOptionsWidget + e1->iPriority = KVI_OPTIONS_WIDGET_PRIORITY_KviUserListFeaturesOptionsWidget; + #else + e1->iPriority = 0; + #endif + #ifdef KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListFeaturesOptionsWidget + e1->szKeywordsNoLocale = KVI_OPTIONS_WIDGET_KEYWORDS_KviUserListFeaturesOptionsWidget; + e1->szKeywords = __tr2qs_ctx_no_xgettext(e1->szKeywordsNoLocale,"options");; + #endif + #ifdef KVI_OPTIONS_WIDGET_GROUP_KviUserListFeaturesOptionsWidget + e1->szGroup = KVI_OPTIONS_WIDGET_GROUP_KviUserListFeaturesOptionsWidget; + #else + e1->szGroup = "general"; + #endif + #ifdef KVI_OPTIONS_WIDGET_CONTAINER_KviUserListFeaturesOptionsWidget + e1->bIsContainer = KVI_OPTIONS_WIDGET_CONTAINER_KviUserListFeaturesOptionsWidget; + #else + e1->bIsContainer = false; + #endif + #ifdef KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListFeaturesOptionsWidget + e1->bIsNotContained = KVI_OPTIONS_WIDGET_NOTCONTAINED_KviUserListFeaturesOptionsWidget; + #else + e1->bIsNotContained = false; + #endif + e1->szNameNoLocale = g_szName_KviUserListFeaturesOptionsWidget; + e1->szName = __tr2qs_ctx_no_xgettext(g_szName_KviUserListFeaturesOptionsWidget,"options"); + e0->pChildList->append(e1); + e1->pChildList = 0; + +} + +void KviOptionsInstanceManager::deleteInstanceTree(KviPointerList<KviOptionsWidgetInstanceEntry> * l) +{ + if(l) + { + for(KviOptionsWidgetInstanceEntry * e = l->first();e;e = l->next()) + { + if(e->pWidget) + { + if(e->pWidget->parent()->inherits("KviOptionsWidgetContainer")) + { + disconnect(e->pWidget,SIGNAL(destroyed()),this,SLOT(widgetDestroyed())); + delete e->pWidget->parent(); + e->pWidget = 0; + } else { + qDebug("Ops...i have deleted the options dialog ?"); + } + } //else qDebug("Clas %s has no widget",e->szName); + if(e->pChildList)deleteInstanceTree(e->pChildList); + } + delete l; + } +} + + +KviOptionsInstanceManager::~KviOptionsInstanceManager() +{ + if(m_pInstanceTree) qDebug("Ops...KviOptionsInstanceManager::cleanup() not called ?"); +} + +void KviOptionsInstanceManager::cleanup(KviModule * m) +{ + deleteInstanceTree(m_pInstanceTree); + m_pInstanceTree = 0; +} + +void KviOptionsInstanceManager::widgetDestroyed() +{ + KviOptionsWidgetInstanceEntry * e = findInstanceEntry(sender(),m_pInstanceTree); + if(e)e->pWidget = 0; + if(g_iOptionWidgetInstances > 0)g_iOptionWidgetInstances--; + +} + +KviOptionsWidget * KviOptionsInstanceManager::getInstance(KviOptionsWidgetInstanceEntry * e,QWidget * par) +{ + if(!e)return 0; + if(!(e->pWidget)) + { + e->pWidget = e->createProc(par); + g_iOptionWidgetInstances++; + connect(e->pWidget,SIGNAL(destroyed()),this,SLOT(widgetDestroyed())); + } + if(e->pWidget->parent() != par) + { + QWidget * oldPar = (QWidget *)e->pWidget->parent(); + e->pWidget->reparent(par,QPoint(0,0)); + delete oldPar; + } + if(e->bIsContainer) + { + // need to create the container structure! + e->pWidget->createTabbedPage(); + if(e->pChildList) + { + KviPointerList<KviOptionsWidgetInstanceEntry> tmp; + tmp.setAutoDelete(false); + + for(KviOptionsWidgetInstanceEntry * e2 = e->pChildList->first();e2;e2 = e->pChildList->next()) + { + // add only non containers and widgets not explicitly marked as noncontained + if((!e2->bIsContainer) && (!e2->bIsNotContained)) + { + KviOptionsWidgetInstanceEntry * ee = tmp.first(); + int idx = 0; + while(ee) + { + if(ee->iPriority >= e2->iPriority)break; + idx++; + ee = tmp.next(); + } + tmp.insert(idx,e2); + } + } + + for(KviOptionsWidgetInstanceEntry * e3 = tmp.last();e3;e3 = tmp.prev()) + { + KviOptionsWidget * ow = getInstance(e3,e->pWidget->tabWidget()); + e->pWidget->addOptionsWidget(e3->szName,*(g_pIconManager->getSmallIcon(e3->iIcon)),ow); + } + } + } + return e->pWidget; +} + +KviOptionsWidgetInstanceEntry * KviOptionsInstanceManager::findInstanceEntry(const QObject * ptr,KviPointerList<KviOptionsWidgetInstanceEntry> * l) +{ + if(l) + { + for(KviOptionsWidgetInstanceEntry * e = l->first();e;e = l->next()) + { + if(ptr == e->pWidget)return e; + if(e->pChildList) + { + KviOptionsWidgetInstanceEntry * e2 = findInstanceEntry(ptr,e->pChildList); + if(e2)return e2; + } + } + } + return 0; +} + +KviOptionsWidgetInstanceEntry * KviOptionsInstanceManager::findInstanceEntry(const char * clName,KviPointerList<KviOptionsWidgetInstanceEntry> * l) +{ + if(l) + { + for(KviOptionsWidgetInstanceEntry * e = l->first();e;e = l->next()) + { + if(kvi_strEqualCI(e->szClassName,clName))return e; + if(e->pChildList) + { + KviOptionsWidgetInstanceEntry * e2 = findInstanceEntry(clName,e->pChildList); + if(e2)return e2; + } + } + } + return 0; +} + +KviOptionsWidgetInstanceEntry * KviOptionsInstanceManager::findInstanceEntry(const char * clName) +{ + return findInstanceEntry(clName,m_pInstanceTree); +} + + +#ifndef COMPILE_USE_STANDALONE_MOC_SOURCES +#include "m_instances.moc" +#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES + diff --git a/src/modules/options/optw_messages.cpp b/src/modules/options/optw_messages.cpp new file mode 100644 index 000000000..d31e98d2c --- /dev/null +++ b/src/modules/options/optw_messages.cpp @@ -0,0 +1,663 @@ +//============================================================================= +// +// File : optw_messages.cpp +// Creation date : Sat Aug 11 2001 18:12:00 CEST by Szymon Stefanek +// +// This file is part of the KVirc irc client distribution +// Copyright (C) 2001-2004 Szymon Stefanek (pragma at kvirc dot net) +// +// This program is FREE software. You can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your opinion) any later version. +// +// This program is distributed in the HOPE that it will be USEFUL, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, write to the Free Software Foundation, +// Inc. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +//============================================================================= + +#define _WANT_OPTION_FLAGS_ + +#include "optw_messages.h" + +#include "kvi_settings.h" +#include "kvi_options.h" +#include "kvi_app.h" +#include "kvi_locale.h" +#include "kvi_iconmanager.h" +#include "kvi_mirccntrl.h" +#include "kvi_config.h" +#include "kvi_filedialog.h" +#include "kvi_styled_controls.h" +#include "kvi_tal_vbox.h" + +#include <QLayout> +#include <QPushButton> +#include <QCursor> +#include <QPainter> + +#ifndef COMPILE_ON_WINDOWS + #include <unistd.h> // symlink() +#endif + + +#ifdef COMPILE_PSEUDO_TRANSPARENCY + extern KVIRC_API QPixmap * g_pShadedChildGlobalDesktopBackground; +#endif + + +KviMessageOptionsWidget::KviMessageOptionsWidget(QWidget * pParent) +: KviOptionsWidget(pParent) +{ +} + +KviMessageOptionsWidget::~KviMessageOptionsWidget() +{ +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +KviPrivmsgOptionsWidget::KviPrivmsgOptionsWidget(QWidget * parent) +: KviOptionsWidget(parent,"privmsg_options_widget") +{ + createLayout(4,1); + + KviBoolSelector * b1; + KviBoolSelector * b2; + + KviTalGroupBox * g = addGroupBox(0,0,0,0,1,Qt::Horizontal,__tr2qs_ctx("General","options")); + + addBoolSelector(g,__tr2qs_ctx("Show message icons","options"),KviOption_boolIrcViewShowImages); + addBoolSelector(g,__tr2qs_ctx("Draw some emoticons (smileys) as pictures","options"),KviOption_boolDrawEmoticons); + addBoolSelector(g,__tr2qs_ctx("Don't show colors in user messages","options"),KviOption_boolStripMircColorsInUserMessages); + + g = addGroupBox(0,1,0,1,1,Qt::Horizontal,__tr2qs_ctx("Nicknames","options")); + + b1 = addBoolSelector(g,__tr2qs_ctx("\"Smart\" nickname colors","options"),KviOption_boolColorNicks); + b2 = addBoolSelector(g,__tr2qs_ctx("Use same colors as in the userlist","options"),KviOption_boolUseUserListColorsAsNickColors,!KVI_OPTION_BOOL(KviOption_boolColorNicks)); + connect(b1,SIGNAL(toggled(bool)),b2,SLOT(setNotEnabled(bool))); + addBoolSelector(g,__tr2qs_ctx("Show nicknames in bold","options"),KviOption_boolBoldedNicks); + addBoolSelector(g,__tr2qs_ctx("Show user and host","options"),KviOption_boolShowUserAndHostInPrivmsgView); + addBoolSelector(g,__tr2qs_ctx("Show channel mode prefix","options"),KviOption_boolShowChannelUserFlagInPrivmsgView); + KviBoolSelector * b = addBoolSelector(g,__tr2qs_ctx("User-defined prefix and postfix","options"),KviOption_boolUseExtendedPrivmsgView); + + QLabel * l = addLabel(g,__tr2qs_ctx("[PREFIX]nickname[!user@host][POSTFIX] message","options")); + + l->setEnabled(KVI_OPTION_BOOL(KviOption_boolUseExtendedPrivmsgView)); + connect(b, + SIGNAL(toggled(bool)), + l, + SLOT(setEnabled(bool))); + + KviTalVBox * vb = new KviTalVBox(g); + vb->setSpacing(5); + + connect( + b, + SIGNAL(toggled(bool)), + addStringSelector(vb,__tr2qs_ctx("Prefix:","options"),KviOption_stringExtendedPrivmsgPrefix,KVI_OPTION_BOOL(KviOption_boolUseExtendedPrivmsgView)), + SLOT(setEnabled(bool))); + connect( + b, + SIGNAL(toggled(bool)), + addStringSelector(vb,__tr2qs_ctx("Postfix:","options"),KviOption_stringExtendedPrivmsgPostfix,KVI_OPTION_BOOL(KviOption_boolUseExtendedPrivmsgView)), + SLOT(setEnabled(bool))); + addRowSpacer(0,3,0,3); +} + +KviPrivmsgOptionsWidget::~KviPrivmsgOptionsWidget() +{ + +} + +KviTimestampOptionsWidget::KviTimestampOptionsWidget(QWidget * pParent) +: KviOptionsWidget(pParent) +{ + createLayout(5,1); + m_pUseTimestampSelector = addBoolSelector(0,0,0,0,__tr2qs_ctx("Show timestamp","options"),KviOption_boolIrcViewTimestamp); + + connect(m_pUseTimestampSelector,SIGNAL(toggled(bool)),this,SLOT(enableDisableTimestampSelector(bool))); + KviBoolSelector* b = addBoolSelector(0,1,0,1,__tr2qs_ctx("Use UTC time for timestamp","options"),KviOption_boolIrcViewTimestampUTC,KVI_OPTION_BOOL(KviOption_boolIrcViewTimestamp)); + + connect(m_pUseTimestampSelector,SIGNAL(toggled(bool)),b,SLOT(setEnabled(bool))); + + KviTalHBox *hb = new KviTalHBox(this); + addWidgetToLayout(hb,0,2,0,2); + + m_pSpecialTimestampColorSelector = addBoolSelector(hb,__tr2qs_ctx("Use special color for timestamps","options"),KviOption_boolUseSpecialColorForTimestamp,KVI_OPTION_BOOL(KviOption_boolIrcViewTimestamp)); + connect(m_pSpecialTimestampColorSelector,SIGNAL(toggled(bool)),this,SLOT(enableDisableTimestampSelector(bool))); + connect(m_pUseTimestampSelector,SIGNAL(toggled(bool)),m_pSpecialTimestampColorSelector,SLOT(setEnabled(bool))); + + m_pTimestampColorSelector = addMircTextColorSelector(hb,"",KviOption_uintTimeStampForeground,KviOption_uintTimeStampBackground,KVI_OPTION_BOOL(KviOption_boolIrcViewTimestamp) && KVI_OPTION_BOOL(KviOption_boolUseSpecialColorForTimestamp)); + + KviStringSelector * st=addStringSelector(0,3,0,3,__tr2qs_ctx("Timestamp format:","options"),KviOption_stringIrcViewTimestampFormat); + connect(m_pUseTimestampSelector,SIGNAL(toggled(bool)),st,SLOT(setEnabled(bool))); + + connect(m_pUseTimestampSelector,SIGNAL(toggled(bool)),m_pSpecialTimestampColorSelector,SLOT(setEnabled(bool))); + addRowSpacer(0,4,0,4); +} + +KviTimestampOptionsWidget::~KviTimestampOptionsWidget() +{ +} + +void KviTimestampOptionsWidget::enableDisableTimestampSelector(bool) +{ + m_pTimestampColorSelector->setEnabled(m_pUseTimestampSelector->isChecked() && m_pSpecialTimestampColorSelector->isChecked()); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +KviStandardColorsOptionsWidget::KviStandardColorsOptionsWidget(QWidget * parent) +: KviOptionsWidget(parent,"stdcolors") +{ + createLayout(5,4); + + addColorSelector(0,0,0,0,"0:",&(KVI_OPTION_MIRCCOLOR(0))); + addColorSelector(1,0,1,0,"1:",&(KVI_OPTION_MIRCCOLOR(1))); + addColorSelector(2,0,2,0,"2:",&(KVI_OPTION_MIRCCOLOR(2))); + addColorSelector(3,0,3,0,"3:",&(KVI_OPTION_MIRCCOLOR(3))); + addColorSelector(0,1,0,1,"4:",&(KVI_OPTION_MIRCCOLOR(4))); + addColorSelector(1,1,1,1,"5:",&(KVI_OPTION_MIRCCOLOR(5))); + addColorSelector(2,1,2,1,"6:",&(KVI_OPTION_MIRCCOLOR(6))); + addColorSelector(3,1,3,1,"7:",&(KVI_OPTION_MIRCCOLOR(7))); + addColorSelector(0,2,0,2,"8:",&(KVI_OPTION_MIRCCOLOR(8))); + addColorSelector(1,2,1,2,"9:",&(KVI_OPTION_MIRCCOLOR(9))); + addColorSelector(2,2,2,2,"10:",&(KVI_OPTION_MIRCCOLOR(10))); + addColorSelector(3,2,3,2,"11:",&(KVI_OPTION_MIRCCOLOR(11))); + addColorSelector(0,3,0,3,"12:",&(KVI_OPTION_MIRCCOLOR(12))); + addColorSelector(1,3,1,3,"13:",&(KVI_OPTION_MIRCCOLOR(13))); + addColorSelector(2,3,2,3,"14:",&(KVI_OPTION_MIRCCOLOR(14))); + addColorSelector(3,3,3,3,"15:",&(KVI_OPTION_MIRCCOLOR(15))); + + addRowSpacer(0,4,3,4); + + layout()->setRowStretch(4,1); +} + +KviStandardColorsOptionsWidget::~KviStandardColorsOptionsWidget() +{ +} + + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +KviMessageListView::KviMessageListView(QWidget * par) +: KviTalListView(par) +{ + setItemMargin(2); +} + +KviMessageListView::~KviMessageListView() +{ +} + + +void KviMessageListView::paintEmptyAreaInternal(QPainter * p,const QRect &viewportRect,const QRect &painterRect) +{ +#ifdef COMPILE_PSEUDO_TRANSPARENCY + if(g_pShadedChildGlobalDesktopBackground) + { + QPoint pnt = viewport()->mapToGlobal(viewportRect.topLeft()); + p->drawTiledPixmap(painterRect.x(),painterRect.y(),painterRect.width(),painterRect.height(),*g_pShadedChildGlobalDesktopBackground,pnt.x(),pnt.y()); + } else { +#endif + QPixmap * pix = KVI_OPTION_PIXMAP(KviOption_pixmapIrcViewBackground).pixmap(); + if(pix) + { + QPoint pnt = viewportToContents(viewportRect.topLeft()); + p->fillRect(painterRect.x(),painterRect.y(),painterRect.width(),painterRect.height(),KVI_OPTION_COLOR(KviOption_colorIrcViewBackground)); + p->drawTiledPixmap(painterRect.x(),painterRect.y(),painterRect.width(),painterRect.height(),*pix,pnt.x(),pnt.y()); + } else { + p->fillRect(painterRect.x(),painterRect.y(),painterRect.width(),painterRect.height(),KVI_OPTION_COLOR(KviOption_colorIrcViewBackground)); + } +#ifdef COMPILE_PSEUDO_TRANSPARENCY + } +#endif +} + +void KviMessageListView::paintEmptyArea(QPainter * p,const QRect &rct) +{ + paintEmptyAreaInternal(p,rct,rct); + KviTalListView::paintEmptyArea(p,rct); +} + + +KviMessageListViewItem::KviMessageListViewItem(KviTalListView * l,int optId) +: KviTalListViewItem(l) +{ + m_iOptId = optId; + setText(0,"WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW"); + m_pMsgType = new KviMsgType(KVI_OPTION_MSGTYPE(optId)); + setPixmap(0,*(g_pIconManager->getSmallIcon(0))); // just a dummy one to ensure that the size of the item is at least 20 pixels (16 + 2 * margin) +} + +KviMessageListViewItem::~KviMessageListViewItem() +{ + delete m_pMsgType; +} + +void KviMessageListViewItem::paintCell(QPainter * p,const QColorGroup &,int,int w,int) +{ +#ifdef COMPILE_PSEUDO_TRANSPARENCY + if(g_pShadedChildGlobalDesktopBackground) + { + QPoint pnt = listView()->viewport()->mapToGlobal(QPoint(int(p->worldMatrix().dx()),int(p->worldMatrix().dy()))); + p->drawTiledPixmap(0,0,w,height(),*g_pShadedChildGlobalDesktopBackground,pnt.x(),pnt.y()); + } else { +#endif + QPixmap * pix = KVI_OPTION_PIXMAP(KviOption_pixmapIrcViewBackground).pixmap(); + if(pix) + { + QPoint pnt = listView()->viewportToContents(QPoint(int(p->worldMatrix().dx()),int(p->worldMatrix().dy()))); + p->fillRect(0,0,w,height(),KVI_OPTION_COLOR(KviOption_colorIrcViewBackground)); + p->drawTiledPixmap(0,0,w,height(),*pix,pnt.x(),pnt.y()); + } else { + p->fillRect(0,0,w,height(),KVI_OPTION_COLOR(KviOption_colorIrcViewBackground)); + } +#ifdef COMPILE_PSEUDO_TRANSPARENCY + } +#endif + + + p->drawPixmap(listView()->itemMargin(),(height() - 16) / 2,*(g_pIconManager->getSmallIcon(m_pMsgType->pixId()))); + // draw the background + if(m_pMsgType->back() < 16) + { + QColor bColor = KVI_OPTION_MIRCCOLOR(m_pMsgType->back()); + p->fillRect(22,listView()->itemMargin(),w - 24,height() - (listView()->itemMargin() * 2),bColor); + } + unsigned char ucFore = m_pMsgType->fore(); + if(ucFore > 15)ucFore = 0; + p->setPen(QPen(KVI_OPTION_MIRCCOLOR(ucFore))); + // skip the msgtype prefix + QString txt = (g_msgtypeOptionsTable[m_iOptId].name + 7); + txt += " ("; + txt += __tr2qs_no_xgettext(QString::fromUtf8(m_pMsgType->type())); + txt += ")"; + p->drawText(24,listView()->itemMargin(),w - 24,height() - (listView()->itemMargin() * 2),Qt::AlignLeft | Qt::AlignVCenter,txt); + if(isSelected()) + { + QPen pen(KVI_OPTION_COLOR(KviOption_colorIrcViewBackground)); + pen.setStyle(Qt::DashLine); + p->setPen( pen); + p->drawRect(0,0,w,height()); + p->drawRect(1,1,w - 2,height() - 2); + } +} + + +KviMessageColorListBoxItem::KviMessageColorListBoxItem(KviTalListBox * b,const QColor &clr,int idx) +: KviTalListBoxText(b,QString::null) +{ + m_clr = clr; + m_iClrIdx = idx; + if((idx < 0) || (idx > 15))setText(__tr2qs_ctx("Transparent","options")); +} + +KviMessageColorListBoxItem::~KviMessageColorListBoxItem() +{ +} + +void KviMessageColorListBoxItem::paint(QPainter * p) +{ + QColor clr; + + const KviTalListBox * lb = (const KviTalListBox *)listBox(); + + if((m_iClrIdx >= 0) && (m_iClrIdx <= 15)) + { + clr = lb->isEnabled() ? KVI_OPTION_MIRCCOLOR(m_iClrIdx) : Qt::gray; + p->fillRect(0,0,width(lb),height(lb),clr); + } else { + clr = listBox()->colorGroup().background(); + KviTalListBoxText::paint(p); + } + + if(isSelected()) + { + QPen pen(clr); + pen.setStyle(Qt::DashLine); + p->setPen( pen); + p->drawRect(0,0,width(lb),height(lb)); + p->drawRect(1,1,width(lb) - 2,height(lb) - 2); + p->drawRect(2,2,width(lb) - 4,height(lb) - 4); + } +} +/* +int KviMessageColorListBoxItem::width(const KviTalListBox * lb) const +{ + int w = lb->width(); + if(w < 30)w = 30; + if(w > 150)w = 150; + return w; +} + +int KviMessageColorListBoxItem::height(const KviTalListBox *) const +{ + return 30; +} +*/ + +/* +KviIrcColorsOptionsWidget::KviIrcColorsOptionsWidget(QWidget * parent) +: KviOptionsWidget(parent,"irccolors","options") +{ + createLayout(5,4); + + addRowSpacer(0,4,3,4); +} + +KviIrcColorsOptionsWidget::~KviIrcColorsOptionsWidget() +{ +} +*/ + +KviMessageColorsOptionsWidget::KviMessageColorsOptionsWidget(QWidget * parent) +: KviOptionsWidget(parent,"messages") +{ + int i; + + createLayout(2,4); + + m_pLastItem = 0; + + + m_pListView = new KviMessageListView(this); + m_pListView->addColumn(__tr2qs_ctx("Message Type","options")); + m_pListView->setAllColumnsShowFocus(true); + m_pListView->setSelectionMode(KviTalListView::Single); + m_pListView->setFont(KVI_OPTION_FONT(KviOption_fontIrcView)); + m_pListView->setStaticBackground(true); + m_pListView->viewport()->setBackgroundMode(Qt::NoBackground); + + addWidgetToLayout(m_pListView,0,0,2,0); + + KviTalVBox * box = new KviTalVBox(this); + addWidgetToLayout(box,3,0,3,0); + + QLabel * l = new QLabel(__tr2qs_ctx("Background:","options"),box); + + m_pBackListBox = new KviTalListBox(box); + m_pBackItems[16] = new KviMessageColorListBoxItem(m_pBackListBox,Qt::gray,KVI_TRANSPARENT); + for(i=0;i<16;i++) + { + m_pBackItems[i] = new KviMessageColorListBoxItem(m_pBackListBox,KVI_OPTION_MIRCCOLOR(i),i); + } + + l = new QLabel(__tr2qs_ctx("Foreground:","options"),box); + + m_pForeListBox = new KviTalListBox(box); + for(i=0;i<16;i++) + { + m_pForeItems[i] = new KviMessageColorListBoxItem(m_pForeListBox,KVI_OPTION_MIRCCOLOR(i),i); + } + + l = new QLabel(__tr2qs_ctx("Alert level:","options"),box); + + m_pLevelListBox = new KviTalListBox(box); + KviTalListBoxText * lbt; + for(i=0;i<6;i++) + { + QString tmpn; + tmpn.setNum(i); + lbt = new KviTalListBoxText(m_pLevelListBox,tmpn); + } + + m_pIconButton = new KviStyledToolButton(box); + connect(m_pIconButton,SIGNAL(clicked()),this,SLOT(iconButtonClicked())); + + m_pIconPopup = new KviTalPopupMenu(this); + KviIconWidget * iw = new KviIconWidget(m_pIconPopup); + connect(iw,SIGNAL(selected(int)),this,SLOT(newIconSelected(int))); + m_pIconPopup->insertItem(iw); + + + m_pEnableLogging = new KviStyledCheckBox(__tr2qs_ctx("Log this","options"),box); + + KviTalHBox * h = new KviTalHBox(this); + addWidgetToLayout(h,0,1,3,1); + QPushButton * b = new QPushButton(__tr2qs_ctx("Load From...","options"),h); + connect(b,SIGNAL(clicked()),this,SLOT(load())); + b = new QPushButton(__tr2qs_ctx("Save As...","options"),h); + connect(b,SIGNAL(clicked()),this,SLOT(save())); + + + KviMessageListViewItem * it; + + for(i=0;i<KVI_NUM_MSGTYPE_OPTIONS;i++) + { + it = new KviMessageListViewItem(m_pListView,i); + } + + layout()->setRowStretch(0,1); + layout()->setColStretch(0,1); + + connect(m_pListView,SIGNAL(selectionChanged(KviTalListViewItem *)),this,SLOT(itemChanged(KviTalListViewItem *))); + connect(m_pForeListBox,SIGNAL(selectionChanged(KviTalListBoxItem *)),this,SLOT(colorChanged(KviTalListBoxItem *))); + connect(m_pBackListBox,SIGNAL(selectionChanged(KviTalListBoxItem *)),this,SLOT(colorChanged(KviTalListBoxItem *))); + + itemChanged(0); +} + +KviMessageColorsOptionsWidget::~KviMessageColorsOptionsWidget() +{ +} + +void KviMessageColorsOptionsWidget::newIconSelected(int iconId) +{ + if(!m_pLastItem)return; + if(iconId >= KVI_NUM_SMALL_ICONS)return; + m_pLastItem->msgType()->setPixId(iconId); + m_pIconButton->setIconSet(*(g_pIconManager->getSmallIcon(iconId))); + m_pListView->repaintItem(m_pLastItem); +} + +void KviMessageColorsOptionsWidget::saveLastItem() +{ + if(!m_pLastItem)return; + + int curIt = m_pForeListBox->currentItem(); + if(curIt != -1) + { + //qDebug("Setting fore %d",curIt); + KviMessageColorListBoxItem * fore = (KviMessageColorListBoxItem *)m_pForeListBox->item(curIt); + //qDebug("And is %d",fore); + if(fore)m_pLastItem->msgType()->setFore(fore->m_iClrIdx); + } + curIt = m_pBackListBox->currentItem(); + if(curIt != -1) + { + KviMessageColorListBoxItem * back = (KviMessageColorListBoxItem *)m_pBackListBox->item(curIt); + if(back)m_pLastItem->msgType()->setBack(back->m_iClrIdx); + } + m_pLastItem->msgType()->enableLogging(m_pEnableLogging->isChecked()); + //qDebug("Updating","options"); + curIt = m_pLevelListBox->currentItem(); + if(curIt < 0 || curIt > 5)curIt = 1; + m_pLastItem->msgType()->setLevel(curIt); + m_pListView->repaintItem(m_pLastItem); +} + +void KviMessageColorsOptionsWidget::itemChanged(KviTalListViewItem * it) +{ + //qDebug("Item changed","options"); + if(m_pLastItem)saveLastItem(); + + m_pLastItem = 0; // do NOT save in this routine + + m_pForeListBox->setEnabled(it); + m_pBackListBox->setEnabled(it); + m_pEnableLogging->setEnabled(it); + m_pIconButton->setEnabled(it); + m_pLevelListBox->setEnabled(it); + + if(it) + { + int back = ((KviMessageListViewItem *)it)->msgType()->back(); + int fore = ((KviMessageListViewItem *)it)->msgType()->fore(); + if(fore >= 0 && fore <= 15) + { + m_pForeListBox->setCurrentItem(m_pForeItems[fore]); + } + if(back >= 0 && back <= 15) + { + m_pBackListBox->setCurrentItem(m_pBackItems[back]); + } else { + m_pBackListBox->setCurrentItem(m_pBackItems[16]); + } + m_pLevelListBox->setCurrentItem(((KviMessageListViewItem *)it)->msgType()->level()); + m_pEnableLogging->setChecked(((KviMessageListViewItem *)it)->msgType()->logEnabled()); + m_pIconButton->setIconSet(*(g_pIconManager->getSmallIcon(((KviMessageListViewItem *)it)->msgType()->pixId()))); + } + + // Ok...can save from now on + m_pLastItem = (KviMessageListViewItem *)it; +} + +void KviMessageColorsOptionsWidget::colorChanged(KviTalListBoxItem *) +{ + if(m_pLastItem)saveLastItem(); +} + +void KviMessageColorsOptionsWidget::iconButtonClicked() +{ + m_pIconPopup->popup(QCursor::pos()); +} + +void KviMessageColorsOptionsWidget::commit() +{ + saveLastItem(); + + mergeResetFlag(KviOption_resetUpdateGui); + + KviMessageListViewItem * it = (KviMessageListViewItem *)m_pListView->firstChild(); + while(it) + { + KVI_OPTION_MSGTYPE(it->optionId()) = *(it->msgType()); + it = (KviMessageListViewItem *)(it->nextSibling()); + } + + KviOptionsWidget::commit(); +} + +void KviMessageColorsOptionsWidget::save() +{ + QString szName; + QString szInit; + g_pApp->getLocalKvircDirectory(szInit,KviApp::MsgColors); + + if(KviFileDialog::askForSaveFileName(szName,__tr2qs_ctx("Choose a Filename - KVIrc","options"),szInit)) + { + if(m_pLastItem)saveLastItem(); + + KviConfig cfg(szName,KviConfig::Write); + + cfg.setGroup("Messages"); + + KviStr tmp; + + + KviMessageListViewItem * it = (KviMessageListViewItem *)m_pListView->firstChild(); + + while(it) + { + tmp.sprintf("Fore%d",it->optionId()); + cfg.writeEntry(tmp.ptr(),it->msgType()->fore()); + tmp.sprintf("Back%d",it->optionId()); + cfg.writeEntry(tmp.ptr(),it->msgType()->back()); + tmp.sprintf("Icon%d",it->optionId()); + cfg.writeEntry(tmp.ptr(),it->msgType()->pixId()); + tmp.sprintf("Log%d",it->optionId()); + cfg.writeEntry(tmp.ptr(),it->msgType()->logEnabled()); + tmp.sprintf("Level%d",it->optionId()); + cfg.writeEntry(tmp.ptr(),it->msgType()->level()); + it = (KviMessageListViewItem *)(it->nextSibling()); + } + + } +} + +//#include <errno.h> + +void KviMessageColorsOptionsWidget::load() +{ + + //KviStr szName; + QString szName; + //KviStr szInit; + QString szInit; + g_pApp->getLocalKvircDirectory(szInit,KviApp::MsgColors); + +#ifndef COMPILE_ON_WINDOWS + // symlink local to global + //KviStr szGlobal; + QString szGlobal; + g_pApp->getGlobalKvircDirectory(szGlobal,KviApp::MsgColors); + //KviStr szLocal; + QString szLocal; + g_pApp->getLocalKvircDirectory(szLocal,KviApp::MsgColors,"presets"); + //qDebug("SYMLINKING %s to %s",szGlobal.ptr(),szLocal.ptr()); + //qDebug("SYMLINK RETURNS %d (%d)",::symlink(szGlobal.ptr(),szLocal.ptr())); + //qDebug("ERRNO (%d)",errno); + symlink(szGlobal,szLocal); + // FIXME: Do it also on windows... +#endif + + if(KviFileDialog::askForOpenFileName(szName,__tr2qs_ctx("Choose a Filename - KVIrc ","options"),szInit)) + { + itemChanged(0); + + KviConfig cfg(szName,KviConfig::Read); + + cfg.setGroup("Messages"); + + //KviStr tmp; + QString tmp; + KviMessageListViewItem * it = (KviMessageListViewItem *)m_pListView->firstChild(); + + while(it) + { + tmp.sprintf("Fore%d",it->optionId()); + int fore = cfg.readIntEntry(tmp,it->msgType()->fore()); + if(fore < 0 || fore > 15)fore = 0; + it->msgType()->setFore(fore); + + tmp.sprintf("Back%d",it->optionId()); + int back = cfg.readIntEntry(tmp,it->msgType()->back()); + if(back < 0 || back > 15)back = KVI_TRANSPARENT; + it->msgType()->setBack(back); + + tmp.sprintf("Icon%d",it->optionId()); + int ico = cfg.readIntEntry(tmp,it->msgType()->pixId()); + if(ico < 0 || ico >= KVI_NUM_SMALL_ICONS)ico = 0; + it->msgType()->setPixId(ico); + + tmp.sprintf("Log%d",it->optionId()); + bool bLog = cfg.readBoolEntry(tmp,it->msgType()->logEnabled()); + it->msgType()->enableLogging(bLog); + + tmp.sprintf("Level%d",it->optionId()); + int iLevel = cfg.readIntEntry(tmp,it->msgType()->level()); + it->msgType()->setLevel(iLevel); + + m_pListView->repaintItem(it); + + it = (KviMessageListViewItem *)(it->nextSibling()); + } + } +} + +#ifndef COMPILE_USE_STANDALONE_MOC_SOURCES +#include "m_optw_messages.moc" +#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES diff --git a/src/modules/options/optw_texticons.cpp b/src/modules/options/optw_texticons.cpp new file mode 100644 index 000000000..60b8cdaff --- /dev/null +++ b/src/modules/options/optw_texticons.cpp @@ -0,0 +1,244 @@ +// +// File : optw_texticons.cpp +// Creation date : Fri May 24 2002 00:16:13 CEST by Szymon Stefanek +// +// This file is part of the KVirc irc client distribution +// Copyright (C) 2002 Szymon Stefanek (pragma at kvirc dot net) +// +// This program is FREE software. You can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your opinion) any later version. +// +// This program is distributed in the HOPE that it will be USEFUL, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, write to the Free Software Foundation, +// Inc. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// + +#include "optw_texticons.h" + +#include "kvi_iconmanager.h" +#include "kvi_texticonmanager.h" +#include "kvi_locale.h" +#include "kvi_filedialog.h" +#include "kvi_tal_hbox.h" + +#include <QLayout> +#include <QCursor> + + + +KviTextIconEditor::KviTextIconEditor(QWidget * par,KviTextIcon * icon,KviTextIconTableItem* item) +: KviTalHBox(par),m_pTableItem(item) +{ + m_pIconButton=new QToolButton(this); + m_pBrowseButton=new QToolButton(this); + m_pBrowseButton->setSizePolicy(QSizePolicy(QSizePolicy::Maximum,QSizePolicy::Maximum)); + m_pBrowseButton->setText("..."); + m_pIcon = icon; + m_pPopup = 0; + updateIcon(); + connect(m_pIconButton,SIGNAL(clicked()),this,SLOT(doPopup())); + connect(m_pBrowseButton,SIGNAL(clicked()),this,SLOT(chooseFromFile())); +} + + +KviTextIconEditor::~KviTextIconEditor() +{ + +} + +void KviTextIconEditor::doPopup() +{ + if(!m_pPopup) + { + m_pPopup = new KviTalPopupMenu(this); + KviIconWidget * iw = new KviIconWidget(m_pPopup); + connect(iw,SIGNAL(selected(int)),this,SLOT(iconSelected(int))); + m_pPopup->insertItem(iw); + } + m_pPopup->popup(QCursor::pos()); +} + +void KviTextIconEditor::iconSelected(int id) +{ + m_pIcon->setId(id); + updateIcon(); +} + +void KviTextIconEditor::chooseFromFile() +{ + QString szFile; + KviFileDialog::askForOpenFileName(szFile,"Choose icon filename",QString::null,"*.png","options"); + if(!szFile.isEmpty()) + { + if(g_pIconManager->getPixmap(szFile)) + { + m_pIcon->setFilename(szFile); +// qDebug("%s %s %i |%s| %p",__FILE__,__FUNCTION__,__LINE__,m_pIcon->filename().utf8().data(),m_pIcon); + updateIcon(); + } + } +} + +void KviTextIconEditor::updateIcon() +{ + if(m_pIcon) + { + QPixmap* pix=m_pIcon->pixmap(); + if(pix) + m_pIconButton->setPixmap(*pix); + } +} + +KviTextIconTableItem::KviTextIconTableItem(KviTalTable * t,KviTextIcon * icon) +: KviTalTableItem(t,KviTalTableItem::WhenCurrent,QString::null) +{ + if(icon) + m_pIcon=icon; + else + m_pIcon=new KviTextIcon(0); + QPixmap* pix=m_pIcon->pixmap(); + if(pix) + setPixmap(*pix); +} + +KviTextIconTableItem::~KviTextIconTableItem() +{ + delete m_pIcon; +} + +void KviTextIconTableItem::setId(int id) +{ + m_pIcon->setId(id); + QPixmap* pix=m_pIcon->pixmap(); + if(pix) + setPixmap(*pix); +} + +QWidget * KviTextIconTableItem::createEditor() const +{ + return new KviTextIconEditor(table()->viewport(),m_pIcon,(KviTextIconTableItem*)this); +} + +void KviTextIconTableItem::setContentFromEditor(QWidget * w) +{ + if(w->inherits("KviTextIconEditor")) + { + QPixmap* pix=m_pIcon->pixmap(); + if(pix) + setPixmap(*pix); + } +} + +KviTextIconsOptionsWidget::KviTextIconsOptionsWidget(QWidget * parent) +: KviOptionsWidget(parent,"texticons_options_widget") +{ + createLayout(2,2); + + KviPointerHashTableIterator<QString,KviTextIcon> it(*(g_pTextIconManager->textIconDict())); + + m_pTable = new KviTalTable(g_pTextIconManager->textIconDict()->count(),2,this); + + mergeTip(m_pTable->viewport(),__tr2qs_ctx("This table contains the text icon associations.<br>" \ + "KVirc will use them to display the CTRL+I escape sequences and eventually the " \ + "emoticons.","options")); + + int idx = 0; + while(KviTextIcon * i = it.current()) + { + m_pTable->setText(idx,0,it.currentKey()); + m_pTable->setItem(idx,1,new KviTextIconTableItem(m_pTable,new KviTextIcon(i))); + ++idx; + ++it; + } + + layout()->addMultiCellWidget(m_pTable,0,0,0,1); + + m_pAdd = new QPushButton(__tr2qs_ctx("Add","options"),this); + layout()->addWidget(m_pAdd,1,0); + connect(m_pAdd,SIGNAL(clicked()),this,SLOT(addClicked())); + + m_pDel = new QPushButton(__tr2qs_ctx("Delete","options"),this); + layout()->addWidget(m_pDel,1,1); + connect(m_pDel,SIGNAL(clicked()),this,SLOT(delClicked())); + + m_pDel->setEnabled(false); + + connect(m_pTable,SIGNAL(selectionChanged()),this,SLOT(selectionChanged())); +} + +KviTextIconsOptionsWidget::~KviTextIconsOptionsWidget() +{ +} + +void KviTextIconsOptionsWidget::selectionChanged() +{ + int i = m_pTable->currentRow(); + m_pDel->setEnabled(i >= 0 && i < m_pTable->numRows()); +} + +void KviTextIconsOptionsWidget::addClicked() +{ + m_pTable->setNumRows(m_pTable->numRows() + 1); + m_pTable->setText(m_pTable->numRows() - 1,0,__tr2qs_ctx("unnamed","options")); + m_pTable->setItem(m_pTable->numRows() - 1,1,new KviTextIconTableItem(m_pTable,0)); + m_pDel->setEnabled(true); +} + +void KviTextIconsOptionsWidget::delClicked() +{ + int i = m_pTable->currentRow(); + + if((i > -1) && (i < m_pTable->numRows())) + { + // remove row i + m_pTable->clearCell(i,0); + m_pTable->clearCell(i,1); + m_pTable->clearCell(i,2); + + for(;i < (m_pTable->numRows() - 1);i++) + { + m_pTable->swapRows(i,i+1); + } + + m_pTable->setNumRows(m_pTable->numRows() - 1); + if(m_pTable->numRows() == 0)m_pDel->setEnabled(false); + } +} + +void KviTextIconsOptionsWidget::commit() +{ + + KviOptionsWidget::commit(); + g_pTextIconManager->clear(); + int n = m_pTable->numRows(); + for(int i=0;i < n;i++) + { + QString szVal = m_pTable->text(i,0); + if(!szVal.isEmpty()) + { + KviTextIconTableItem * it = (KviTextIconTableItem *)m_pTable->item(i,1); + if(it) + { + g_pTextIconManager->insert(szVal,*(it->icon())); + } + } + } + g_pTextIconManager->checkDefaultAssociations(); + + for(int i=0; i<n; i++) + for (int j=0; j<m_pTable->numCols(); j++) + if (m_pTable->item(i,j)) + m_pTable->clearCell(i,j); + +} + +#ifndef COMPILE_USE_STANDALONE_MOC_SOURCES +#include "m_optw_texticons.moc" +#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES |