You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
kvirc/src/modules/options/optw_servers.cpp

1713 lines
59 KiB

//=============================================================================
//
// File : optw_servers.cpp
// Creation date : Wed Jun 12 2000 03:29:51 by Szymon Stefanek
//
// This file is part of the KVirc irc client distribution
// Copyright (C) 2000-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. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================
#include "optw_servers.h"
#include "optw_proxy.h"
#include "kvi_query.h"
#include "kvi_channel.h"
#include "kvi_locale.h"
#include "kvi_iconmanager.h"
#include "kvi_ircserverdb.h"
#include "kvi_ipeditor.h"
#include "kvi_netutils.h"
#include "kvi_settings.h"
#include "kvi_filedialog.h"
#include "kvi_config.h"
#include "kvi_scripteditor.h"
#include "kvi_options.h"
#include "kvi_app.h"
#include "kvi_console.h"
#include "kvi_ircurl.h"
#include "kvi_module.h"
#include "kvi_modulemanager.h"
#include "kvi_moduleextension.h"
#include "kvi_msgbox.h"
#include "kvi_mexserverimport.h"
#include "kvi_nickserv.h"
#include "optw_nickserv.h" // for the NickServ rule editor
#include "kvi_proxydb.h"
#include "kvi_kvs_script.h"
#include "kvi_styled_controls.h"
#include <tqtoolbutton.h>
#include <tqlineedit.h>
#include <tqcheckbox.h>
#include "kvi_tal_popupmenu.h"
#include <tqcursor.h>
#include "kvi_tal_tooltip.h"
#include <tqvalidator.h>
#include <tqmessagebox.h>
#include "kvi_pointerhashtable.h"
#include <tqcombobox.h>
#include <tqbuttongroup.h>
#include <tqmessagebox.h>
#include <tqinputdialog.h>
#include <tqmessagebox.h>
KviNetworkDetailsWidget::KviNetworkDetailsWidget(TQWidget * par,KviIrcNetwork * n)
: TQDialog(par,"network_details",true)
{
m_pOnConnectEditor=0;
m_pOnLoginEditor=0;
m_pUserEditor=0;
m_pPassEditor=0;
m_pNickEditor=0;
m_pRealEditor=0;
m_pDescEditor=0;
m_pEncodingEditor=0;
m_pAutoConnectCheck=0;
m_pNickServListView=0;
m_pNickServCheck=0;
m_pAddRuleButton=0;
m_pDelRuleButton=0;
m_pEditRuleButton=0;
m_pChannelListSelector=0;
TQGridLayout * g = new TQGridLayout(this,4,4,10,4);
setCaption(__tr2qs_ctx("Network Details","options"));
setIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_WORLD)));
TQString szTmp = "<font size=\"+1\"><b>";
szTmp += n->name();
szTmp += "</b></font>";
TQLabel * l = new TQLabel(szTmp,this);
l->setFrameStyle(TQFrame::Raised | TQFrame::StyledPanel);
l->setAlignment(TQt::AlignCenter);
l->setMargin(10);
g->addMultiCellWidget(l,0,0,0,3);
l->setMinimumWidth(200);
l = new TQLabel(__tr2qs_ctx("Description:","options"),this);
g->addWidget(l,1,0);
m_pDescEditor = new TQLineEdit(this);
g->addMultiCellWidget(m_pDescEditor,1,1,1,3);
m_pDescEditor->setText(n->description());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pDescEditor,__tr2qs_ctx("<center>Put here a brief description of the network.</center>","options"));
#endif
// Identity tab
TQTabWidget * tw = new TQTabWidget(this);
g->addMultiCellWidget(tw,2,2,0,3);
TQWidget * tab = new TQWidget(tw);
TQGridLayout * gl = new TQGridLayout(tab,4,2,10,4);
KviTalGroupBox *gbox = new KviTalGroupBox(2,TQt::Horizontal,__tr2qs_ctx("Properties","options"),tab);
gl->addMultiCellWidget(gbox,0,0,0,1);
l = new TQLabel(__tr2qs_ctx("Username:","options"),gbox);
m_pUserEditor = new TQLineEdit(gbox);
m_pUserEditor->setText(n->userName());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pUserEditor,__tr2qs_ctx("<center>This is the <b>username</b> that KVIrc will use to login to servers on this network.\n" \
"If this field is left empty (most common case), KVIrc will use the default username " \
"specified in the \"Identity\" options tab.</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Nickname:","options"),gbox);
m_pNickEditor = new TQLineEdit(gbox);
TQValidator * v = new TQRegExpValidator(TQRegExp("[^-0-9 ][^ ]*","options"),gbox);
m_pNickEditor->setValidator(v);
m_pNickEditor->setText(n->nickName());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pNickEditor,__tr2qs_ctx("<center>You can specify a \"special\" <b>nickname</b> that will be used to log in to the servers on this network.<br>" \
"If this field is left empty (most common case), the default nickname (specified in the \"Identity\" settings) will be used.</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Real name:","options"),gbox);
m_pRealEditor = new TQLineEdit(gbox);
m_pRealEditor->setText(n->realName());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pRealEditor,__tr2qs_ctx("<center>You can specify a \"special\" <b>real name</b> that will be used to login with the servers on this network.<br>" \
"If you leave this field empty (most common case), the default \"real name\" (specified in the \"Identity\" settings) will be used.</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Encoding:","options"),tab);
gl->addWidget(l,1,0);
m_pEncodingEditor = new TQComboBox(false,tab);
m_pEncodingEditor->setDuplicatesEnabled(false);
gl->addWidget(m_pEncodingEditor,1,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pEncodingEditor,__tr2qs_ctx("<center>This box allows you to choose the preferred encoding for the servers in this network. " \
"If you choose \"Use System Encoding\" then the encoding will be set to the systemwide " \
"value that you choose in the \"Encoding\" page of the options dialog.</center>","options"));
#endif
int i = 0;
int current = 0;
KviLocale::EncodingDescription * d = KviLocale::encodingDescription(i);
TQString tmp;
m_pEncodingEditor->insertItem(__tr2qs_ctx("Use System Encoding","options"));
while(d->szName)
{
KviTQString::sprintf(tmp,"%s (%s)",d->szName,d->szDescription);
m_pEncodingEditor->insertItem(tmp);
if(KviTQString::equalCI(d->szName,n->encoding()))current = i + 1;
i = i + 1;
d = KviLocale::encodingDescription(i);
}
m_pEncodingEditor->setCurrentItem(current);
m_pAutoConnectCheck = new KviStyledCheckBox(__tr2qs_ctx("Connect to this network at startup","options"),tab);
m_pAutoConnectCheck->setChecked(n->autoConnect());
gl->addMultiCellWidget(m_pAutoConnectCheck,2,2,0,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pAutoConnectCheck,__tr2qs_ctx("<center>This option will cause KVIrc to automatically connect to this network at startup</center>","options"));
#endif
l = new TQLabel("",tab);
gl->addWidget(l,3,0);
gl->setRowStretch(3,1);
gl->setColStretch(1,1);
tw->addTab(tab,__tr2qs_ctx("General","options"));
// after login join channels
tab = new TQWidget(tw);
gl = new TQGridLayout(tab,1,1,10,4);
if(n->autoJoinChannelList())
m_lstChannels = *(n->autoJoinChannelList());
m_pChannelListSelector = new KviCahnnelListSelector(tab,
__tr2qs_ctx("Channels to join automatically upon connect:","options"),&m_lstChannels,true);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pChannelListSelector,__tr2qs_ctx("<center>Here you can set a list of channels to be joined automatically " \
"after a connection to a server in this network has been established. To add a channel, type its name in the " \
"text input below and click \"<b>Add</b>\".</center>","options"));
#endif
gl->addWidget(m_pChannelListSelector,0,0);
tw->addTab(tab,__tr2qs_ctx("Join Channels","options"));
// after connect execute
tab = new TQWidget(tw);
gl = new TQGridLayout(tab,1,1,10,4);
m_pOnConnectEditor = KviScriptEditor::createInstance(tab);
gl->addWidget(m_pOnConnectEditor,0,0);
m_pOnConnectEditor->setText(n->onConnectCommand());
m_pOnConnectEditor->setMinimumHeight(150);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pOnConnectEditor,__tr2qs_ctx("<center>The following commands will be executed after a connection to a server in this network has been established.<br>" \
"<b>Important:</b> Enter commands <b>without</b> a preceding slash (e.g. <tt>quote pass secret</tt> instead of <tt>/quote pass secret</tt>).<br>"\
"KVIrc will first send the USER command, then eventually PASS and NICK and then execute this " \
"command sequence.</center>","options"));
#endif
tw->addTab(tab,__tr2qs_ctx("On Connect","options"));
// after login execute
tab = new TQWidget(tw);
gl = new TQGridLayout(tab,1,1,10,4);
m_pOnLoginEditor = KviScriptEditor::createInstance(tab);
gl->addWidget(m_pOnLoginEditor,0,0);
m_pOnLoginEditor->setText(n->onLoginCommand());
m_pOnLoginEditor->setMinimumHeight(150);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pOnLoginEditor,
__tr2qs_ctx("<center>The following commands will be executed after a successful login to a server in this network.<br>" \
"<b>Important:</b> Enter commands <b>without</b> a preceding slash (e.g. <tt>quote privatelog</tt> instead of <tt>/quote privatelog</tt>).<br>"
"This is useful for automatically opening queries, setting variables, etc.</center>","options"));
#endif
tw->addTab(tab,__tr2qs_ctx("On Login","options"));
// nick serv rules
tab = new TQWidget(tw);
gl = new TQGridLayout(tab,3,3,10,5);
KviNickServRuleSet * rs = n->nickServRuleSet();
bool bNickServEnabled = rs ? (rs->isEnabled() && !rs->isEmpty()) : false;
m_pNickServCheck = new KviStyledCheckBox(__tr2qs_ctx("Enable NickServ Identification","options"),tab);
gl->addMultiCellWidget(m_pNickServCheck,0,0,0,2);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pNickServCheck,
__tr2qs_ctx("This check enables the automatic identification with NickServ","options"));
#endif
m_pNickServCheck->setChecked(bNickServEnabled);
m_pNickServListView = new KviTalListView(tab);
m_pNickServListView->setSelectionMode(KviTalListView::Single);
m_pNickServListView->setAllColumnsShowFocus(true);
m_pNickServListView->addColumn(__tr2qs_ctx("Nickname","options"));
m_pNickServListView->addColumn(__tr2qs_ctx("NickServ Mask","options"));
m_pNickServListView->addColumn(__tr2qs_ctx("NickServ Request Mask","options"));
m_pNickServListView->addColumn(__tr2qs_ctx("Identify Command","options"));
connect(m_pNickServListView,TQ_SIGNAL(selectionChanged()),this,TQ_SLOT(enableDisableNickServControls()));
gl->addMultiCellWidget(m_pNickServListView,1,1,0,2);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pNickServListView,
__tr2qs_ctx("<center>This is a list of NickServ identification rules. " \
"KVIrc will use them to model its automatic interaction with NickServ on this network.<br>" \
"Please be aware that this feature can cause your NickServ passwords to be stolen " \
"if used improperly. Make sure that you fully understand the NickServ authentication protocol.<br>" \
"In other words, be sure to know what you're doing.<br>" \
"Also note that the password that you provide is stored as <b>PLAIN TEXT</b>.</center>","options"));
#endif
m_pAddRuleButton = new TQPushButton(__tr2qs_ctx("Add Rule","options"),tab);
connect(m_pAddRuleButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(addNickServRule()));
gl->addWidget(m_pAddRuleButton,2,0);
m_pEditRuleButton = new TQPushButton(__tr2qs_ctx("Edit Rule","options"),tab);
connect(m_pEditRuleButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(editNickServRule()));
gl->addWidget(m_pEditRuleButton,2,1);
m_pDelRuleButton = new TQPushButton(__tr2qs_ctx("Delete Rule","options"),tab);
connect(m_pDelRuleButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(delNickServRule()));
gl->addWidget(m_pDelRuleButton,2,2);
connect(m_pNickServCheck,TQ_SIGNAL(toggled(bool)),this,TQ_SLOT(enableDisableNickServControls()));
if(rs && rs->rules())
{
KviPointerList<KviNickServRule> * ll = rs->rules();
for(KviNickServRule * rule = ll->first();rule;rule = ll->next())
{
(void)new KviTalListViewItem(m_pNickServListView,rule->registeredNick(),rule->nickServMask(),rule->messageRegexp(),rule->identifyCommand());
}
}
enableDisableNickServControls();
gl->setRowStretch(1,1);
tw->addTab(tab,__tr2qs_ctx("NickServ","options"));
TQPushButton * b = new TQPushButton(__tr2qs_ctx("&OK","options"),this);
b->setMinimumWidth(80);
g->addWidget(b,3,2);
b->setDefault(true);
connect(b,TQ_SIGNAL(clicked()),this,TQ_SLOT(accept()));
b = new TQPushButton(__tr2qs_ctx("Cancel","options"),this);
g->addWidget(b,3,3);
b->setMinimumWidth(80);
connect(b,TQ_SIGNAL(clicked()),this,TQ_SLOT(reject()));
g->setRowStretch(2,1);
g->setColStretch(1,1);
tw->setMinimumWidth(375);
}
KviNetworkDetailsWidget::~KviNetworkDetailsWidget()
{
if(m_pOnConnectEditor) KviScriptEditor::destroyInstance(m_pOnConnectEditor);
if(m_pOnLoginEditor) KviScriptEditor::destroyInstance(m_pOnLoginEditor);
}
void KviNetworkDetailsWidget::editNickServRule()
{
KviTalListViewItem * it = m_pNickServListView->currentItem();
if(!it)return;
KviNickServRule r(it->text(0),it->text(1),it->text(2),it->text(3));
KviNickServRuleEditor ed(this,false);
if(ed.editRule(&r))
{
it->setText(0,r.registeredNick());
it->setText(1,r.nickServMask());
it->setText(2,r.messageRegexp());
it->setText(3,r.identifyCommand());
}
}
void KviNetworkDetailsWidget::addNickServRule()
{
KviNickServRule r;
KviNickServRuleEditor ed(this,false);
if(ed.editRule(&r))
(void)new KviTalListViewItem(m_pNickServListView,r.registeredNick(),r.nickServMask(),r.messageRegexp(),r.identifyCommand());
}
void KviNetworkDetailsWidget::delNickServRule()
{
KviTalListViewItem * it = m_pNickServListView->currentItem();
if(!it)return;
delete it;
enableDisableNickServControls();
}
void KviNetworkDetailsWidget::enableDisableNickServControls()
{
bool bEnabled = m_pNickServCheck->isChecked();
m_pNickServListView->setEnabled(bEnabled);
m_pAddRuleButton->setEnabled(bEnabled);
bEnabled = bEnabled && (m_pNickServListView->childCount() > 0) && m_pNickServListView->currentItem();
m_pDelRuleButton->setEnabled(bEnabled);
m_pEditRuleButton->setEnabled(bEnabled);
}
void KviNetworkDetailsWidget::fillData(KviIrcNetwork * n)
{
n->setUserName(m_pUserEditor->text());
n->setNickName(m_pNickEditor->text());
n->setRealName(m_pRealEditor->text());
n->setDescription(m_pDescEditor->text());
if(m_pAutoConnectCheck)
n->setAutoConnect(m_pAutoConnectCheck->isChecked());
if(m_pEncodingEditor)
if(m_pEncodingEditor->currentItem() <= 0)n->setEncoding(TQString());
else {
KviLocale::EncodingDescription * d = KviLocale::encodingDescription(m_pEncodingEditor->currentItem() - 1);
n->setEncoding(d->szName);
}
if(m_pChannelListSelector)
m_pChannelListSelector->commit();
if(m_lstChannels.isEmpty())n->setAutoJoinChannelList(0);
else n->setAutoJoinChannelList(new TQStringList(m_lstChannels));
if(m_pNickServListView)
{
if(m_pNickServListView->childCount() > 0)
{
KviNickServRuleSet * rs = KviNickServRuleSet::createInstance();
rs->setEnabled(m_pNickServCheck->isChecked());
KviTalListViewItem * it = m_pNickServListView->firstChild();
while(it)
{
rs->addRule(KviNickServRule::createInstance(it->text(0),it->text(1),it->text(2),it->text(3)));
it = it->nextSibling();
}
n->setNickServRuleSet(rs);
} else n->setNickServRuleSet(0);
}
if(m_pOnConnectEditor)
{
TQString tmp;
m_pOnConnectEditor->getText(tmp);
n->setOnConnectCommand(tmp);
}
if(m_pOnLoginEditor)
{
TQString tmp;
m_pOnLoginEditor->getText(tmp);
n->setOnLoginCommand(tmp);
}
}
KviServerDetailsWidget::KviServerDetailsWidget(TQWidget * par,KviIrcServer * s)
: TQDialog(par,"server_details",true)
{
m_szHostname = s->hostName();
TQGridLayout * g = new TQGridLayout(this,4,4,10,4);
setCaption(__tr2qs_ctx("Server Details","options"));
setIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SERVER)));
m_pHeaderLabel = new TQLabel("",this); // the text will be set later
m_pHeaderLabel->setFrameStyle(TQFrame::Raised | TQFrame::StyledPanel);
m_pHeaderLabel->setAlignment(TQt::AlignCenter);
m_pHeaderLabel->setMargin(10);
g->addMultiCellWidget(m_pHeaderLabel,0,0,0,3);
m_pHeaderLabel->setMinimumWidth(200);
TQLabel * l = new TQLabel(__tr2qs_ctx("Description:","options"),this);
g->addWidget(l,1,0);
m_pDescEditor = new TQLineEdit(this);
g->addMultiCellWidget(m_pDescEditor,1,1,1,3);
m_pDescEditor->setText(s->description());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pDescEditor,__tr2qs_ctx("<center>This is a brief description of this server. " \
"This field has no restrictions but many server lists use it to describe the server's physical location</center>","options"));
#endif
// Identity tab
TQTabWidget * tw = new TQTabWidget(this);
g->addMultiCellWidget(tw,2,2,0,3);
TQWidget * tab = new TQWidget(tw);
TQGridLayout * gl = new TQGridLayout(tab,3,1,10,4);
KviTalGroupBox *gbox = new KviTalGroupBox(2,TQt::Horizontal,__tr2qs_ctx("Properties","options"),tab);
gl->addWidget(gbox,0,0);
l = new TQLabel(__tr2qs_ctx("Username:","options"),gbox);
m_pUserEditor = new TQLineEdit(gbox);
m_pUserEditor->setText(s->userName());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pUserEditor,__tr2qs_ctx("<center>This is the <b>username</b> that KVIrc will use to login to this server.\n" \
"If this field is left empty (most common case), KVIrc will first look if an username is specified " \
"for the network that this server belongs to, and if that is empty then KVIrc will use the default username " \
"specified in the \"Identity\" options tab.</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Password:","options"),gbox);
m_pPassEditor = new TQLineEdit(gbox);
m_pPassEditor->setEchoMode(TQLineEdit::Password);
m_pPassEditor->setText(s->password());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pPassEditor,__tr2qs_ctx("<center>If this server requires a password, put it in this field, otherwise leave it empty.</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Nickname:","options"),gbox);
m_pNickEditor = new TQLineEdit(gbox);
TQValidator * v = new TQRegExpValidator(TQRegExp("[^-0-9 ][^ ]*"),gbox);
m_pNickEditor->setValidator(v);
m_pNickEditor->setText(s->nickName());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pNickEditor,__tr2qs_ctx("<center>You can specify a \"special\" <b>nickname</b> that will be used to log in to this server.<br>" \
"If this field is left empty (most common case), KVIrc will first look if a nickname is specified " \
"for the network that this server belongs to, and if that is empty then the default nickname (specified in the \"Identity\" settings) will be used.</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Real name:","options"),gbox);
m_pRealEditor = new TQLineEdit(gbox);
m_pRealEditor->setText(s->realName());
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pRealEditor,__tr2qs_ctx("<center>You can specify a \"special\" <b>real name</b> that will be used to login with this server.<br>" \
"If you leave this field empty (most common case), KVIrc will first look if a real name is specified " \
"for the network that this server belongs to, and if that is empty the default \"real name\" (specified in the \"Identity\" settings) will be used.</center>","options"));
#endif
gbox = new KviTalGroupBox(1,TQt::Horizontal,__tr2qs_ctx("User Mode","options"),tab);
gl->addWidget(gbox,1,0);
m_pUseDefaultInitUMode = new KviStyledCheckBox(__tr2qs_ctx("Use default user mode","options"),gbox);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pUseDefaultInitUMode,__tr2qs_ctx("<center>If this is enabled, the global initial <b>user mode</b> (configured from"\
" the identity dialog) will be used. If disabled, you can configure an initial user mode for this server","options"));
#endif
bool bHasUmode = !(s->initUMode().isEmpty());
KviStr szDefUMode = KVI_OPTION_STRING(KviOption_stringDefaultUserMode);
m_pUseDefaultInitUMode->setChecked(!bHasUmode);
connect(m_pUseDefaultInitUMode,TQ_SIGNAL(toggled(bool)),this,TQ_SLOT(useDefaultInitUModeToggled(bool)));
m_pIMode = new KviStyledCheckBox(__tr2qs_ctx("Invisible (+i)","options"),gbox);
m_pIMode->setEnabled(bHasUmode);
m_pIMode->setChecked(bHasUmode ? s->initUMode().contains('i',false) : szDefUMode.contains('i',false));
m_pSMode = new KviStyledCheckBox(__tr2qs_ctx("Server notices (+s)","options"),gbox);
m_pSMode->setEnabled(bHasUmode);
m_pSMode->setChecked(bHasUmode ? s->initUMode().contains('s',false) : szDefUMode.contains('s',false));
m_pWMode = new KviStyledCheckBox(__tr2qs_ctx("Wallops (+w)","options"),gbox);
m_pWMode->setEnabled(bHasUmode);
m_pWMode->setChecked(bHasUmode ? s->initUMode().contains('w',false) : szDefUMode.contains('w',false));
l = new TQLabel("",tab);
gl->addWidget(l,2,0);
gl->setRowStretch(2,1);
//gl->setColStretch(1,1);
tw->addTab(tab,*(g_pIconManager->getSmallIcon(KVI_SMALLICON_WHO)),__tr2qs_ctx("Identity","options"));
// Connection tab
tab = new TQWidget(tw);
gl = new TQGridLayout(tab,11,1,10,4);
l = new TQLabel(__tr2qs_ctx("Port:","options"),tab);
gl->addWidget(l,0,0);
m_pPortEditor = new TQLineEdit(tab);
gl->addWidget(m_pPortEditor,0,1);
TQString tmpz;
tmpz.setNum(s->port());
m_pPortEditor->setText(tmpz);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pPortEditor,__tr2qs_ctx("<center>This is the default <b>port</b> that this server will be contacted on.<br>Usually <b>6667</b> is OK.</center>","options"));
#endif
connect(m_pPortEditor,TQ_SIGNAL(textChanged(const TQString &)),this,TQ_SLOT(portEditorTextChanged(const TQString &)));
l = new TQLabel(__tr2qs_ctx("IP address:","options"),tab);
gl->addWidget(l,1,0);
m_pIpEditor = new KviIpEditor(tab,KviIpEditor::IpV4);
gl->addWidget(m_pIpEditor,1,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pIpEditor,__tr2qs_ctx("<center>This is the <b>IP address</b> of this server, it is here for caching purposes.<br>" \
"If you leave this field empty, KVIrc will fill it in the first time it connects to the server. " \
"If you enable the \"cache IP address\" option below, KVIrc will use it as a \"cached result\" " \
"and avoid looking it up again.</center>","options"));
#endif
#ifdef COMPILE_IPV6_SUPPORT
m_pIpEditor->setAddressType(s->isIpV6() ? KviIpEditor::IpV6 : KviIpEditor::IpV4);
#else
m_pIpEditor->setAddressType(KviIpEditor::IpV4);
#endif
if(!m_pIpEditor->setAddress(s->m_szIp))
{
#ifdef COMPILE_IPV6_SUPPORT
m_pIpEditor->setAddress(s->isIpV6() ? "0:0:0:0:0:0:0:0" : "0.0.0.0");
#else
m_pIpEditor->setAddress("0.0.0.0");
#endif
}
m_pCacheIpCheck = new KviStyledCheckBox(__tr2qs_ctx("Cache IP address","options"),tab);
gl->addMultiCellWidget(m_pCacheIpCheck,2,2,0,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pCacheIpCheck,__tr2qs_ctx("<center>This check will enable <b>IP address caching</b> for this server:<br>" \
"DNS lookups can be time-consuming and might be blocking on some platforms; " \
"this option will cause KVIrc to look up the server hostname only once.<br><br> " \
"Advanced: you can also use this option to force a certain server name to resolve " \
"to a fixed ip address when either the dns for that server is temporairly " \
"unreachable or you want to avoid the round-robin lookups.</center>","options"));
#endif
m_pCacheIpCheck->setChecked(s->cacheIp());
m_pUseIPV6Check = new KviStyledCheckBox(__tr2qs_ctx("Use IPv6 protocol","options"),tab);
gl->addMultiCellWidget(m_pUseIPV6Check,3,3,0,1);
#ifdef COMPILE_IPV6_SUPPORT
m_pUseIPV6Check->setChecked(s->isIpV6());
#else
m_pUseIPV6Check->setEnabled(false);
#endif
connect(m_pUseIPV6Check,TQ_SIGNAL(toggled(bool)),this,TQ_SLOT(useIPV6CheckToggled(bool)));
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pUseIPV6Check,__tr2qs_ctx("<center>This check identifies IPv6 servers.<br>If enabled, KVIrc will attempt to use the IPv6 protocol " \
"(thus your OS <b>must</b> have a working IPv6 stack and you <b>must</b> have an IPv6 connection).</center>","options"));
#endif
m_pUseSSLCheck = new KviStyledCheckBox(__tr2qs_ctx("Use SSL protocol","options"),tab);
gl->addMultiCellWidget(m_pUseSSLCheck,4,4,0,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pUseSSLCheck,__tr2qs_ctx("<center>This check will cause the connection to use the <b>Secure Socket Layer</b> " \
"encryption support. Obviously, this server must have support for this, too. :)</center>","options"));
#endif
#ifndef COMPILE_SSL_SUPPORT
m_pUseSSLCheck->setEnabled(false);
#endif
m_pUseSSLCheck->setChecked(s->useSSL());
m_pUseAutoConnect = new KviStyledCheckBox(__tr2qs_ctx("Connect to this server at startup","options"),tab);
m_pUseAutoConnect->setChecked(s->autoConnect());
gl->addMultiCellWidget(m_pUseAutoConnect,5,5,0,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pUseAutoConnect,__tr2qs_ctx("<center>This option will cause KVIrc to connect to the IRC server when it is started.</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Encoding:","options"),tab);
gl->addWidget(l,6,0);
m_pEncodingEditor = new TQComboBox(false,tab);
m_pEncodingEditor->setDuplicatesEnabled(false);
gl->addWidget(m_pEncodingEditor,6,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pEncodingEditor,__tr2qs_ctx("<center>This box allows you to choose the preferred encoding for this sever. " \
"If you choose \"Use Network Encoding\" then the encoding will be inherited from the " \
"network that this server belongs to.</center>","options"));
#endif
int i = 0;
int current = 0;
KviLocale::EncodingDescription * d = KviLocale::encodingDescription(i);
TQString tmp;
m_pEncodingEditor->insertItem(__tr2qs_ctx("Use Network Encoding","options"));
while(d->szName)
{
KviTQString::sprintf(tmp,"%s (%s)",d->szName,d->szDescription);
m_pEncodingEditor->insertItem(tmp);
if(KviTQString::equalCI(d->szName,s->encoding()))current = i + 1;
i = i + 1;
d = KviLocale::encodingDescription(i);
}
m_pEncodingEditor->setCurrentItem(current);
l = new TQLabel(__tr2qs_ctx("Link filter:","options"),tab);
gl->addWidget(l,7,0);
m_pLinkFilterEditor = new TQComboBox(true,tab);
m_pLinkFilterEditor->setDuplicatesEnabled(false);
gl->addWidget(m_pLinkFilterEditor,7,1);
m_pLinkFilterEditor->insertItem("");
g_pModuleManager->loadModulesByCaps("linkfilter");
KviModuleExtensionDescriptorList * mexl = KviModuleExtensionManager::instance()->getExtensionList("linkfilter");
if(mexl)
{
for(KviModuleExtensionDescriptor * d = mexl->first();d;d = mexl->next())
m_pLinkFilterEditor->insertItem(d->name().ptr());
} else {
if(!s->linkFilter().isEmpty())
m_pLinkFilterEditor->insertItem(s->linkFilter());
}
if(!s->linkFilter().isEmpty())
m_pLinkFilterEditor->setCurrentText(s->linkFilter());
else
m_pLinkFilterEditor->setCurrentText("");
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pLinkFilterEditor,__tr2qs_ctx("<center>This field specifies the name of a module that exports a link filter for this type of server.<br>" \
"For plain IRC connections, you don't need any link filters; this is used for incompatible protocols.</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Id:","options"),tab);
gl->addWidget(l,8,0);
m_pIdEditor = new TQLineEdit(tab);
if(s->id().isEmpty())s->generateUniqueId();
m_pIdEditor->setText(s->id());
gl->addWidget(m_pIdEditor,8,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pIdEditor,__tr2qs_ctx("<center>This field allows you to specify a really unique id for this server. " \
"You will then be able to use /server -x &lt;this_id&gt; to make the connection. This is especially " \
"useful when you have multiple server entries with the same hostname and port in different networks (bouncers?)</center>","options"));
#endif
l = new TQLabel(__tr2qs_ctx("Proxy server:","options"),tab);
gl->addWidget(l,9,0);
m_pProxyEditor = new TQComboBox(tab);
gl->addWidget(m_pProxyEditor,9,1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pProxyEditor,__tr2qs_ctx("<center>This is the <b>proxy</b> that KVIrc will use to connect to thos server.\n" \
"If this field is set in \"Default\" KVirc will use global proxy settings, if it is set in \"Direct connection\" " \
"KVirc will connect to this server without proxy. You can define new proxy server in global options' \"Proxy servers\" menu.</center>","options"));
#endif
m_pProxyEditor->insertItem(__tr2qs_ctx("Default","options"));
m_pProxyEditor->insertItem(__tr2qs_ctx("Direct connection","options"));
KviPointerList<KviProxy> * proxylist = g_pProxyDataBase->proxyList();
for(KviProxy * p = proxylist->first();p;p = proxylist->next())
{
m_pProxyEditor->insertItem(TQString("%1:%2").arg(p->hostname()).arg(p->port()));
}
if(m_pProxyEditor->count() > (s->proxy()+2))
m_pProxyEditor->setCurrentItem(s->proxy()+2);
l = new TQLabel("",tab);
gl->addMultiCellWidget(l,10,10,0,1);
gl->setRowStretch(10,1);
tw->addTab(tab,*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SOCKETWARNING)),__tr2qs_ctx("Connection","options"));
// after login join channels
tab = new TQWidget(tw);
gl = new TQGridLayout(tab,1,1,10,4);
if(s->autoJoinChannelList())
m_lstChannels = *(s->autoJoinChannelList());
m_pChannelListSelector = new KviCahnnelListSelector(tab,
__tr2qs_ctx("Channels to join automatically upon connect:","options"),&m_lstChannels,true);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pChannelListSelector,__tr2qs_ctx("<center>Here you can set a list of channels to be joined automatically " \
"after a connection to this server has been established. To add a channel, type its name in the " \
"text input below and click \"<b>Add</b>\".</center>","options"));
#endif
gl->addWidget(m_pChannelListSelector,0,0);
tw->addTab(tab,*(g_pIconManager->getSmallIcon(KVI_SMALLICON_CHANNEL)),__tr2qs_ctx("Join Channels","options"));
// after connect execute
tab = new TQWidget(tw);
gl = new TQGridLayout(tab,1,1,10,4);
m_pOnConnectEditor = KviScriptEditor::createInstance(tab);
gl->addWidget(m_pOnConnectEditor,0,0);
m_pOnConnectEditor->setText(s->onConnectCommand());
m_pOnConnectEditor->setMinimumHeight(150);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pOnConnectEditor,__tr2qs_ctx("<center>The following commands will be executed after a connection has been established.<br>" \
"<b>Important:</b> Enter commands <b>without</b> a preceding slash (e.g. <tt>quote pass secret</tt> instead of <tt>/quote pass secret</tt>).<br>"\
"KVIrc will first send the USER command, then eventually PASS and NICK and then execute this " \
"command sequence.<br>This is particularly useful for IRC bouncers that require login commands.</center>","options"));
#endif
tw->addTab(tab,__tr2qs_ctx("On Connect","options"));
// after login execute
tab = new TQWidget(tw);
gl = new TQGridLayout(tab,1,1,10,4);
m_pOnLoginEditor = KviScriptEditor::createInstance(tab);
gl->addWidget(m_pOnLoginEditor,0,0);
m_pOnLoginEditor->setText(s->onLoginCommand());
m_pOnLoginEditor->setMinimumHeight(150);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pOnLoginEditor,
__tr2qs_ctx("<center>The following commands will be executed after a successful login to this server.<br>" \
"<b>Important:</b> Enter commands <b>without</b> a preceding slash (e.g. <tt>quote privatelog</tt> instead of <tt>/quote privatelog</tt>).<br>"
"This is useful for automatically opening queries, setting variables, etc.</center>","options"));
#endif
tw->addTab(tab,__tr2qs_ctx("On Login","options"));
TQPushButton * b = new TQPushButton(__tr2qs_ctx("OK","options"),this);
b->setMinimumWidth(80);
g->addWidget(b,3,2);
b->setDefault(true);
connect(b,TQ_SIGNAL(clicked()),this,TQ_SLOT(accept()));
b = new TQPushButton(__tr2qs_ctx("Cancel","options"),this);
g->addWidget(b,3,3);
b->setMinimumWidth(80);
connect(b,TQ_SIGNAL(clicked()),this,TQ_SLOT(reject()));
g->setRowStretch(2,1);
g->setColStretch(1,1);
tw->setMinimumWidth(390);
setHeaderLabelText();
}
KviServerDetailsWidget::~KviServerDetailsWidget()
{
if(m_pOnConnectEditor) KviScriptEditor::destroyInstance(m_pOnConnectEditor);
if(m_pOnLoginEditor) KviScriptEditor::destroyInstance(m_pOnLoginEditor);
}
void KviServerDetailsWidget::useIPV6CheckToggled(bool)
{
#ifdef COMPILE_IPV6_SUPPORT
m_pIpEditor->setAddressType(m_pUseIPV6Check->isChecked() ? KviIpEditor::IpV6 : KviIpEditor::IpV4);
#else
m_pIpEditor->setAddressType(KviIpEditor::IpV4);
#endif
setHeaderLabelText();
}
void KviServerDetailsWidget::portEditorTextChanged(const TQString &)
{
setHeaderLabelText();
}
void KviServerDetailsWidget::setHeaderLabelText()
{
TQString szTmp = "<font size=\"+1\"><b>irc";
if(m_pUseIPV6Check->isChecked())szTmp += "6";
szTmp += "://";
szTmp += m_szHostname;
szTmp += ":";
bool bOk;
TQString num = m_pPortEditor->text();
unsigned int uPort = num.toUInt(&bOk);
if(!bOk)uPort = 6667;
num.setNum(uPort);
szTmp += num;
szTmp += "</b></font>";
m_pHeaderLabel->setText(szTmp);
}
void KviServerDetailsWidget::fillData(KviIrcServer * s)
{
s->setUserName(m_pUserEditor->text());
s->setPassword(m_pPassEditor->text());
s->setNickName(m_pNickEditor->text());
s->setRealName(m_pRealEditor->text());
if(m_pDescEditor)
s->setDescription(m_pDescEditor->text());
if(m_pLinkFilterEditor)
s->setLinkFilter(m_pLinkFilterEditor->lineEdit()->text());
if(m_pEncodingEditor)
if(m_pEncodingEditor->currentItem() <= 0)s->m_szEncoding = "";
else {
KviLocale::EncodingDescription * d = KviLocale::encodingDescription(m_pEncodingEditor->currentItem() - 1);
s->m_szEncoding = d->szName;
}
s->setIpAddress("");
if(m_pCacheIpCheck)
s->setCacheIp(m_pCacheIpCheck->isChecked());
if(m_pUseSSLCheck)
s->setUseSSL(m_pUseSSLCheck->isChecked());
if(m_pIdEditor)
s->setId(m_pIdEditor->text());
if(s->id().isEmpty())s->generateUniqueId();
if(m_pUseDefaultInitUMode)
{
KviStr szUMode;
if(!m_pUseDefaultInitUMode->isChecked())
{
if(m_pIMode->isChecked())szUMode.append('i');
if(m_pWMode->isChecked())szUMode.append('w');
if(m_pSMode->isChecked())szUMode.append('s');
}
s->setInitUMode(szUMode.ptr());
}
TQString tmp = m_pPortEditor->text();
bool bOk;
kvi_u32_t uPort = tmp.toUInt(&bOk);
if(!bOk)uPort = 6667;
s->m_uPort = uPort;
#ifdef COMPILE_IPV6_SUPPORT
s->setIpV6(m_pUseIPV6Check->isChecked());
#else
s->setIpV6(false);
#endif
if(m_pIpEditor)
{
KviStr tmpAddr = m_pIpEditor->address();
if(!m_pIpEditor->hasEmptyFields())
{
#ifdef COMPILE_IPV6_SUPPORT
if(s->isIpV6())
{
if((!kvi_strEqualCI(tmpAddr.ptr(),"0:0:0:0:0:0:0:0")) && kvi_isValidStringIp_V6(tmpAddr.ptr()))
{
s->setIpAddress(tmpAddr.ptr());
} else {
s->setCacheIp(false);
s->setIpAddress("");
}
} else {
#endif
if((!kvi_strEqualCI(tmpAddr.ptr(),"0.0.0.0")) && kvi_isValidStringIp(tmpAddr.ptr()))
{
s->setIpAddress(tmpAddr.ptr());
} else {
s->setCacheIp(false);
s->setIpAddress("");
}
#ifdef COMPILE_IPV6_SUPPORT
}
#endif
} else {
s->setCacheIp(false);
s->setIpAddress("");
}
}
if(m_pOnConnectEditor)
{
TQString tmp;
m_pOnConnectEditor->getText(tmp);
s->setOnConnectCommand(tmp);
}
if(m_pOnLoginEditor)
{
TQString tmp;
m_pOnLoginEditor->getText(tmp);
s->setOnLoginCommand(tmp);
}
if(m_pChannelListSelector)
m_pChannelListSelector->commit();
if(m_lstChannels.isEmpty())s->setAutoJoinChannelList(0);
else s->setAutoJoinChannelList(new TQStringList(m_lstChannels));
if(m_pUseAutoConnect)
s->setAutoConnect(m_pUseAutoConnect->isChecked());
if(m_pProxyEditor)
s->setProxy(m_pProxyEditor->currentItem()-2);
}
void KviServerDetailsWidget::useDefaultInitUModeToggled(bool b)
{
m_pIMode->setEnabled(!b);
m_pWMode->setEnabled(!b);
m_pSMode->setEnabled(!b);
}
// kvi_app.cpp
extern KVIRC_API KviIrcServerDataBase * g_pIrcServerDataBase;
KviServerOptionsListViewItem::KviServerOptionsListViewItem(KviTalListView *parent,const TQPixmap &pm,const KviIrcNetwork *n)
: KviTalListViewItem(parent)
{
setPixmap(0,pm);
m_pServerData = 0;
m_pNetworkData = new KviIrcNetwork(*n);
setText(0,n->name());
setText(1,n->description());
}
KviServerOptionsListViewItem::KviServerOptionsListViewItem(KviTalListViewItem *parent,const TQPixmap &pm,const KviIrcServer *s)
: KviTalListViewItem(parent)
{
setPixmap(0,pm);
m_pServerData = new KviIrcServer(*s);
setText(0,s->hostName());
setText(1,s->description());
m_pNetworkData = 0;
}
KviServerOptionsListViewItem::~KviServerOptionsListViewItem()
{
if(m_pServerData)delete m_pServerData;
if(m_pNetworkData)delete m_pNetworkData;
}
void KviServerOptionsListViewItem::updateVisibleStrings()
{
if(m_pNetworkData)
{
setText(0,m_pNetworkData->name());
setText(1,m_pNetworkData->description());
return;
}
if(m_pServerData)
{
setText(0,m_pServerData->hostName());
setText(1,m_pServerData->description());
}
}
KviServerOptionsWidget::KviServerOptionsWidget(TQWidget * parent)
: KviOptionsWidget(parent,"server_options_widget")
{
createLayout(4,2);
m_pContextPopup = new KviTalPopupMenu(this);
m_pImportPopup = new KviTalPopupMenu(this);
connect(m_pImportPopup,TQ_SIGNAL(aboutToShow()),this,TQ_SLOT(importPopupAboutToShow()));
connect(m_pImportPopup,TQ_SIGNAL(activated(int)),this,TQ_SLOT(importPopupActivated(int)));
m_pServerDetailsDialog = 0;
m_pNetworkDetailsDialog = 0;
m_pImportFilter = 0;
m_pListView = new KviTalListView(this);
addWidgetToLayout(m_pListView,0,0,0,0);
m_pListView->addColumn(__tr2qs_ctx("Server","options"));
m_pListView->addColumn(__tr2qs_ctx("Description","options"));
m_pListView->setRootIsDecorated(true);
m_pListView->setAllColumnsShowFocus(true);
m_pListView->setSelectionMode(KviTalListView::Single);
connect(m_pListView,TQ_SIGNAL(selectionChanged(KviTalListViewItem *)),
this,TQ_SLOT(listViewItemSelectionChanged(KviTalListViewItem *)));
connect(m_pListView,TQ_SIGNAL(rightButtonPressed(KviTalListViewItem *,const TQPoint &,int)),
this,TQ_SLOT(listViewRightButtonPressed(KviTalListViewItem *,const TQPoint &,int)));
connect(m_pListView,TQ_SIGNAL(doubleClicked(KviTalListViewItem*, const TQPoint&, int )),
this,TQ_SLOT(detailsClicked()));
#ifdef COMPILE_INFO_TIPS
TQString tiptxt = __tr2qs_ctx("<center>This is the list of available IRC servers.<br>" \
"Right-click on the list to add or remove servers and perform other actions.<br>"\
"Double-click on a item for advanced options.</center>","options");
KviTalToolTip::add(m_pListView,tiptxt);
KviTalToolTip::add(m_pListView->viewport(),tiptxt);
#endif
KviTalVBox * vbox = new KviTalVBox(this);
addWidgetToLayout(vbox,1,0,1,0);
m_pNewNetworkButton = new KviStyledToolButton(vbox);
m_pNewNetworkButton->setPixmap(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_WORLD)));
m_pNewNetworkButton->setAutoRaise(true);
connect(m_pNewNetworkButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(newNetwork()));
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pNewNetworkButton,__tr2qs_ctx("New Network","options"));
#endif
m_pNewServerButton = new KviStyledToolButton(vbox);
m_pNewServerButton->setPixmap(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SERVER)));
m_pNewServerButton->setAutoRaise(true);
connect(m_pNewServerButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(newServer()));
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pNewServerButton,__tr2qs_ctx("New Server","options"));
#endif
m_pRemoveButton = new KviStyledToolButton(vbox);
m_pRemoveButton->setPixmap(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_CUT)));
m_pRemoveButton->setEnabled(false);
m_pRemoveButton->setAutoRaise(true);
connect(m_pRemoveButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(removeCurrent()));
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pRemoveButton,__tr2qs_ctx("Remove Network/Server","options"));
#endif
TQFrame * f = new TQFrame(vbox);
f->setFrameStyle(TQFrame::Sunken | TQFrame::HLine);
m_pCopyServerButton = new KviStyledToolButton(vbox);
m_pCopyServerButton->setPixmap(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_COPY)));
m_pCopyServerButton->setEnabled(false);
m_pCopyServerButton->setAutoRaise(true);
connect(m_pCopyServerButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(copyServer()));
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pCopyServerButton,__tr2qs_ctx("Copy Server","options"));
#endif
m_pPasteServerButton = new KviStyledToolButton(vbox);
m_pPasteServerButton->setPixmap(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_PASTE)));
m_pPasteServerButton->setEnabled(false);
m_pPasteServerButton->setAutoRaise(true);
connect(m_pPasteServerButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(pasteServer()));
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pPasteServerButton,__tr2qs_ctx("Paste Server","options"));
#endif
f = new TQFrame(vbox);
f->setFrameStyle(TQFrame::Sunken | TQFrame::HLine);
m_pImportButton = new KviStyledToolButton(vbox);
m_pImportButton->setPixmap(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_FOLDER)));
m_pImportButton->setAutoRaise(true);
m_pImportButton->setPopup(m_pImportPopup);
m_pImportButton->setPopupDelay(1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pImportButton,__tr2qs_ctx("Import List","options"));
#endif
TQFrame * lll = new TQFrame(vbox);
vbox->setStretchFactor(lll,100);
KviTalGroupBox *gbox = addGroupBox(0,1,1,1,3,TQt::Horizontal,__tr2qs_ctx("Active Configuration","options"));
m_pSrvNetLabel = new TQLabel(__tr2qs_ctx("Server:","options"),gbox);
m_pSrvNetEdit = new TQLineEdit(gbox);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pSrvNetEdit,__tr2qs_ctx("<center>This is the name of the currently selected server or network</center>","options"));
#endif
/*
m_pIpV6Check = new KviStyledCheckBox(__tr2qs_ctx("Use IPv6 protocol","options"),gbox);
#ifndef COMPILE_IPV6_SUPPORT
m_pIpV6Check->setEnabled(false);
#endif
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pIpV6Check,__tr2qs_ctx("<center>This check identifies IPv6 servers.<br>If enabled, KVIrc will attempt to use the IPv6 protocol " \
"(thus your OS <b>must</b> have a working IPv6 stack and you <b>must</b> have an IPv6 connection).</center>","options"));
#endif
m_pPortLabel = new TQLabel(__tr2qs_ctx("Port:","options"),gbox);
m_pPortEdit = new TQLineEdit(gbox);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pPortEdit,__tr2qs_ctx("<center>This is the default <b>port</b> that this server will be contacted on.<br>Usually <b>6667</b> is OK.</center>","options"));
#endif
*/
m_pDetailsButton = new TQPushButton(__tr2qs_ctx("Advanced...","options"),gbox);
connect(m_pDetailsButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(detailsClicked()));
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pDetailsButton,__tr2qs_ctx("<center>Click here to edit advanced options for this entry</center>","options"));
#endif
m_pConnectCurrent = new TQPushButton(__tr2qs_ctx("Connect &Now","options"),this);
addWidgetToLayout(m_pConnectCurrent,0,2,0,2);
connect(m_pConnectCurrent,TQ_SIGNAL(clicked()),this,TQ_SLOT(connectCurrentClicked()));
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(m_pConnectCurrent,__tr2qs_ctx("<center>Hit this button to connect to the currently selected server.</center>","options"));
#endif
m_pRecentPopup = new KviTalPopupMenu(this);
connect(m_pRecentPopup,TQ_SIGNAL(aboutToShow()),this,TQ_SLOT(recentServersPopupAboutToShow()));
connect(m_pRecentPopup,TQ_SIGNAL(activated(int)),this,TQ_SLOT(recentServersPopupClicked(int)));
TQToolButton * tb = new KviStyledToolButton(this);
addWidgetToLayout(tb,1,2,1,2);
tb->setPixmap(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_TIME)));
tb->setPopup(m_pRecentPopup);
tb->setPopupDelay(1);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(tb,__tr2qs_ctx("<center>This button shows a list of recently used servers. It allows you to quickly find them in the list.</center>","options"));
#endif
KviBoolSelector * b = addBoolSelector(0,3,1,3,__tr2qs_ctx("Show this dialog at startup","options"),KviOption_boolShowServersConnectDialogOnStart);
#ifdef COMPILE_INFO_TIPS
KviTalToolTip::add(b,__tr2qs_ctx("<center>If this option is enabled, the Servers dialog will appear every time you start KVIrc</center>","options"));
#endif
// KviBoolSelector * c = addBoolSelector(0,6,2,6,__tr("Close after connection","options"),KviOption_boolCloseServerWidgetAfterConnect);
m_pLastEditedItem = 0;
m_pClipboard = 0;
fillServerList();
layout()->setRowStretch(0,1);
//layout()->setColStretch(1,5);
//layout()->setColStretch(2,2);
layout()->setColStretch(0,1);
setMinimumWidth(320);
}
KviServerOptionsWidget::~KviServerOptionsWidget()
{
if(m_pImportFilter)
{
disconnect(m_pImportFilter,0,this,0);
m_pImportFilter->die();
m_pImportFilter = 0;
}
if(m_pClipboard)delete m_pClipboard;
if(m_pServerDetailsDialog)delete m_pServerDetailsDialog;
if(m_pNetworkDetailsDialog)delete m_pNetworkDetailsDialog;
}
void KviServerOptionsWidget::recentServersPopupAboutToShow()
{
g_pApp->fillRecentServersPopup(m_pRecentPopup);
}
void KviServerOptionsWidget::recentServersPopupClicked(int id)
{
KviStr data = m_pRecentPopup->text(id);
data.cutToFirst('/');
while(data.firstCharIs('/'))data.cutLeft(1);
data.cutFromLast(':');
data.replaceAll("/","");
// we should have a full server name now , with no port
KviStr port = m_pRecentPopup->text(id);
port.cutToLast(':');
bool bOk;
kvi_u32_t uPort = port.toUInt(&bOk);
// we have the port too
KviTalListViewItem * pFoundNet = 0;
KviTalListViewItem * pFoundSrv = 0;
for(KviTalListViewItem * net = m_pListView->firstChild();net;net = net->nextSibling())
{
for(KviTalListViewItem * srv = net->firstChild();srv;srv = srv->nextSibling())
{
KviStr tmp = ((KviServerOptionsListViewItem *)srv)->m_pServerData->hostName();
if(kvi_strEqualCI(tmp.ptr(),data.ptr()))
{
if(((KviServerOptionsListViewItem *)srv)->m_pServerData->port() == uPort)
{
net->setOpen(true);
m_pListView->setCurrentItem(srv);
m_pListView->ensureItemVisible(srv);
return;
} else {
if(!pFoundNet)
{
// the port doesn't match.. check for
// another entry with the correct port
// but keep track of this entry in case we don't find it
pFoundNet = srv;
pFoundSrv = net;
}
}
}
}
}
// fallback to the server with the wrong port
if(pFoundNet)
{
pFoundNet->setOpen(true);
m_pListView->setCurrentItem(pFoundSrv);
m_pListView->ensureItemVisible(pFoundSrv);
}
}
void KviServerOptionsWidget::connectCurrentClicked()
{
saveLastItem();
commit();
KviStr szServer = m_pSrvNetEdit->text();
if(szServer.isEmpty())return;
KviKvsScript::run("server -u",g_pApp->activeConsole());
}
void KviServerOptionsWidget::fillServerList()
{
KviServerOptionsListViewItem * net;
KviServerOptionsListViewItem * srv;
KviServerOptionsListViewItem * cur = 0;
KviPointerHashTableIterator<TQString,KviIrcServerDataBaseRecord> it(*(g_pIrcServerDataBase->recordDict()));
while(KviIrcServerDataBaseRecord * r = it.current())
{
net = new KviServerOptionsListViewItem(m_pListView,*(g_pIconManager->getSmallIcon(KVI_SMALLICON_WORLD)),r->network());
KviPointerList<KviIrcServer> * sl = r->serverList();
bool bCurrent = r->network()->name() == g_pIrcServerDataBase->currentNetworkName().utf8().data();
net->setOpen(bCurrent);
for(KviIrcServer * s = sl->first();s;s = sl->next())
{
srv = new KviServerOptionsListViewItem(net,*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SERVER)),s);
if((s == r->currentServer()) && bCurrent)
{
m_pListView->setSelected(srv,true);
cur = srv;
}
}
++it;
}
if(cur)m_pListView->ensureItemVisible(cur);
}
void KviServerOptionsWidget::listViewItemSelectionChanged(KviTalListViewItem *it)
{
saveLastItem();
m_pLastEditedItem = (KviServerOptionsListViewItem *)it;
if(m_pLastEditedItem)
{
m_pSrvNetLabel->setEnabled(true);
m_pSrvNetEdit->setEnabled(true);
m_pDetailsButton->setEnabled(true);
m_pConnectCurrent->setEnabled(m_pLastEditedItem->m_pServerData);
m_pRemoveButton->setEnabled(true);
m_pCopyServerButton->setEnabled(m_pLastEditedItem->m_pServerData);
if(m_pLastEditedItem->m_pServerData)
{
m_pSrvNetLabel->setText(__tr2qs_ctx("Server:","options"));
m_pSrvNetEdit->setText(m_pLastEditedItem->m_pServerData->m_szHostname);
} else {
m_pSrvNetLabel->setText(__tr2qs_ctx("Network:","options"));
m_pSrvNetEdit->setText(it->text(0));
}
} else {
m_pRemoveButton->setEnabled(false);
m_pCopyServerButton->setEnabled(true);
m_pConnectCurrent->setEnabled(false);
m_pSrvNetLabel->setEnabled(false);
m_pSrvNetEdit->setEnabled(false);
m_pSrvNetEdit->setText(__tr2qs_ctx("No selection","options"));
m_pDetailsButton->setEnabled(false);
}
}
void KviServerOptionsWidget::saveLastItem()
{
if(!m_pLastEditedItem)return;
if(m_pLastEditedItem->m_pServerData)
{
KviStr tmp = m_pSrvNetEdit->text();
if(tmp.isEmpty())tmp = "irc.unknown.net";
m_pLastEditedItem->m_pServerData->m_szHostname = tmp;
m_pLastEditedItem->updateVisibleStrings();
} else if(m_pLastEditedItem->m_pNetworkData)
{
TQString tmp = m_pSrvNetEdit->text();
if(tmp.isEmpty())tmp = __tr2qs_ctx("UnknownNet","options");
m_pLastEditedItem->m_pNetworkData->setName(tmp);
m_pLastEditedItem->updateVisibleStrings();
}
}
void KviServerOptionsWidget::commit()
{
saveLastItem();
g_pIrcServerDataBase->clear();
KviServerOptionsListViewItem * it = (KviServerOptionsListViewItem *)m_pListView->firstChild();
while(it)
{
TQString tmp = it->m_pNetworkData ? it->m_pNetworkData->name() : TQString();
if(!tmp.isEmpty())
{
KviIrcNetwork * net = 0;
KviIrcServerDataBaseRecord * r = g_pIrcServerDataBase->findRecord(tmp);
if(r)
{
net = r->network();
net->copyFrom(*(it->m_pNetworkData));
} else {
net = new KviIrcNetwork(tmp);
net->copyFrom(*(it->m_pNetworkData));
r = g_pIrcServerDataBase->insertNetwork(net);
}
if(it == m_pLastEditedItem)g_pIrcServerDataBase->setCurrentNetwork(net->name());
KviServerOptionsListViewItem * ch = (KviServerOptionsListViewItem *)it->firstChild();
KviIrcServer *srv;
while(ch)
{
if(ch->m_pServerData)
{
if(!ch->m_pServerData->m_szHostname.isEmpty())
{
srv = r->findServer(ch->m_pServerData);
if(!srv)
{
srv = new KviIrcServer(*(ch->m_pServerData));
r->insertServer(srv);
} else *srv = *(ch->m_pServerData);
if(srv->id().isEmpty())srv->generateUniqueId();
if(ch == m_pLastEditedItem)
{
g_pIrcServerDataBase->setCurrentNetwork(net->name());
r->setCurrentServer(srv);
}
}
}
ch = (KviServerOptionsListViewItem *)ch->nextSibling();
}
}
it = (KviServerOptionsListViewItem *)it->nextSibling();
}
KviOptionsWidget::commit();
}
void KviServerOptionsWidget::listViewRightButtonPressed(KviTalListViewItem *it,const TQPoint &pnt,int col)
{
int id;
bool bServer = (it && ((KviServerOptionsListViewItem *)it)->m_pServerData);
m_pContextPopup->clear();
m_pContextPopup->insertItem(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_WORLD)),__tr2qs_ctx("New Network","options"),this,TQ_SLOT(newNetwork()));
id = m_pContextPopup->insertItem(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_CUT)),__tr2qs_ctx("Remove Network","options"),this,TQ_SLOT(removeCurrent()));
m_pContextPopup->setItemEnabled(id,!bServer);
m_pContextPopup->insertSeparator();
id = m_pContextPopup->insertItem(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SERVER)),__tr2qs_ctx("&New Server","options"),this,TQ_SLOT(newServer()));
id = m_pContextPopup->insertItem(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_CUT)),__tr2qs_ctx("Re&move Server","options"),this,TQ_SLOT(removeCurrent()));
m_pContextPopup->setItemEnabled(id,bServer);
id = m_pContextPopup->insertItem(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_COPY)),__tr2qs_ctx("&Copy Server","options"),this,TQ_SLOT(copyServer()));
m_pContextPopup->setItemEnabled(id,bServer);
id = m_pContextPopup->insertItem(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_PASTE)),__tr2qs_ctx("&Paste Server","options"),this,TQ_SLOT(pasteServer()));
m_pContextPopup->setItemEnabled(id,m_pClipboard);
m_pContextPopup->insertSeparator();
// m_pContextPopup->insertItem(__c2q(__tr("Merge list from server.ini","options")),this,TQ_SLOT(importFromIni()));
m_pContextPopup->insertItem(__tr2qs_ctx("Clear List","options"),this,TQ_SLOT(clearList()));
m_pContextPopup->insertSeparator();
m_pContextPopup->insertItem(__tr2qs_ctx("Import List","options"),m_pImportPopup);
m_pContextPopup->popup(TQCursor::pos());
}
void KviServerOptionsWidget::importPopupAboutToShow()
{
g_pModuleManager->loadModulesByCaps("serverimport");
m_pImportPopup->clear();
KviModuleExtensionDescriptorList * l = KviModuleExtensionManager::instance()->getExtensionList("serverimport");
if(!l)return;
int id;
for(KviModuleExtensionDescriptor * d = l->first();d;d = l->next())
{
if(d->icon())
id = m_pImportPopup->insertItem(*(d->icon()),d->visibleName());
else
id = m_pImportPopup->insertItem(d->visibleName());
m_pImportPopup->setItemParameter(id,d->id());
}
}
void KviServerOptionsWidget::importPopupActivated(int id)
{
// ensure that we have all the modules : they could have been unloaded while the popup was displayed
g_pModuleManager->loadModulesByCaps("serverimport");
KviModuleExtensionDescriptorList * l = KviModuleExtensionManager::instance()->getExtensionList("serverimport");
if(!l)
{
// ops.. internal error: I thought to have a module capable of importing servers
// but actually it's not the case.. something weird happened (in the best case
// the user has just unloaded the module and removed it from disk ?)
KviMessageBox::warning(__tr2qs_ctx("Oops... something weird happened:<br>Can't find any module capable of importing servers.","options"));
return;
}
if(m_pImportFilter)
{
disconnect(m_pImportFilter,0,this,0);
m_pImportFilter->die();
m_pImportFilter = 0;
}
id = m_pImportPopup->itemParameter(id);
m_pImportFilter = (KviMexServerImport *)KviModuleExtensionManager::instance()->allocateExtension("serverimport",id,0);
if(!m_pImportFilter)
{
KviMessageBox::warning(__tr2qs_ctx("Oops... something weird happened:<br>Can't find the module that was capable of this import action. :(","options"));
return;
}
connect(m_pImportFilter,TQ_SIGNAL(server(const KviIrcServer &,const char *)),this,TQ_SLOT(importServer(const KviIrcServer &,const char *)));
connect(m_pImportFilter,TQ_SIGNAL(destroyed()),this,TQ_SLOT(importerDead()));
m_pImportFilter->start();
}
void KviServerOptionsWidget::importerDead()
{
m_pImportFilter = 0;
}
void KviServerOptionsWidget::importServer(const KviIrcServer &s,const char * network)
{
KviServerOptionsListViewItem * net = findNetItem(network);
if(!net)
{
KviIrcNetwork d(network);
net = new KviServerOptionsListViewItem(m_pListView,*(g_pIconManager->getSmallIcon(KVI_SMALLICON_WORLD)),&d);
net->setOpen(true);
}
for(KviServerOptionsListViewItem * srv = (KviServerOptionsListViewItem *)net->firstChild();srv;srv = (KviServerOptionsListViewItem *)srv->nextSibling())
{
if((srv)->m_pServerData->useSSL() == s.useSSL())
{
if(srv->m_pServerData->isIpV6() == s.isIpV6())
{
if(KviTQString::equalCI(srv->m_pServerData->hostName(),s.hostName()))
{
// update the port
srv->m_pServerData->setPort(s.port());
if(!s.ipAddress().isEmpty())srv->m_pServerData->setIpAddress(s.ipAddress());
if(!s.password().isEmpty())srv->m_pServerData->setPassword(s.password());
if(!s.nickName().isEmpty())srv->m_pServerData->setNickName(s.nickName());
m_pListView->setCurrentItem(srv);
m_pListView->ensureItemVisible(srv);
return;
}
}
}
}
// not found : add it!
KviServerOptionsListViewItem * newServer = new KviServerOptionsListViewItem(net,*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SERVER)),&s);
m_pListView->setCurrentItem(newServer);
m_pListView->ensureItemVisible(newServer);
}
void KviServerOptionsWidget::newNetwork()
{
KviIrcNetwork d(__tr2qs_ctx("New Network","options"));
KviServerOptionsListViewItem * it = new KviServerOptionsListViewItem(m_pListView,*(g_pIconManager->getSmallIcon(KVI_SMALLICON_WORLD)),&d);
it->setOpen(true);
m_pListView->setSelected(it,true);
m_pListView->ensureItemVisible(it);
}
void KviServerOptionsWidget::newServer()
{
if(m_pLastEditedItem)
{
KviServerOptionsListViewItem * net;
if(m_pLastEditedItem->m_pServerData)
{
net = (KviServerOptionsListViewItem *)m_pLastEditedItem->parent();
if(!net)return;
}
else net = m_pLastEditedItem;
KviIrcServer tmp;
tmp.m_szHostname = __tr2qs_ctx("irc.unknown.net","options");
tmp.setCacheIp(false);
tmp.generateUniqueId();
KviServerOptionsListViewItem * it = new KviServerOptionsListViewItem(net,
*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SERVER)),&tmp);
net->setOpen(true);
m_pListView->setSelected(it,true);
m_pListView->ensureItemVisible(it);
}
}
void KviServerOptionsWidget::copyServer()
{
if(m_pLastEditedItem)
{
if(m_pLastEditedItem->m_pServerData)
{
if(!m_pClipboard)m_pClipboard = new KviIrcServer();
*m_pClipboard = *(m_pLastEditedItem->m_pServerData);
m_pPasteServerButton->setEnabled(true);
}
}
}
void KviServerOptionsWidget::pasteServer()
{
if(m_pClipboard)
{
if(m_pLastEditedItem)
{
KviServerOptionsListViewItem * net;
if(m_pLastEditedItem->m_pServerData)
{
net = (KviServerOptionsListViewItem *)m_pLastEditedItem->parent();
if(!net)return;
}
else net = m_pLastEditedItem;
KviServerOptionsListViewItem * it = new KviServerOptionsListViewItem(net,
*(g_pIconManager->getSmallIcon(KVI_SMALLICON_SERVER)),m_pClipboard);
net->setOpen(true);
m_pListView->setSelected(it,true);
m_pListView->ensureItemVisible(it);
}
}
}
void KviServerOptionsWidget::removeCurrent()
{
if(m_pLastEditedItem)
{
KviTalListViewItem * it = m_pLastEditedItem->itemAbove();
if(!it)it = m_pLastEditedItem->firstChild() ? m_pLastEditedItem->nextSibling() : m_pLastEditedItem->itemBelow();
delete m_pLastEditedItem;
m_pLastEditedItem = 0;
if(!it)it = m_pListView->firstChild();
if(it)
{
m_pListView->setSelected(it,true);
m_pListView->ensureItemVisible(it);
}
}
}
KviServerOptionsListViewItem * KviServerOptionsWidget::findNetItem(const char * netname)
{
KviServerOptionsListViewItem * it = (KviServerOptionsListViewItem *)m_pListView->firstChild();
while(it)
{
KviStr szNetName = it->text(0);
if(kvi_strEqualCI(szNetName.ptr(),netname))return it;
it = (KviServerOptionsListViewItem *)it->nextSibling();
}
return 0;
}
void KviServerOptionsWidget::clearList()
{
m_pListView->clear();
m_pLastEditedItem = 0;
listViewItemSelectionChanged(0);
}
void KviServerOptionsWidget::detailsClicked()
{
if(!m_pLastEditedItem)return;
if(m_pLastEditedItem->m_pServerData)
{
saveLastItem();
m_pServerDetailsDialog = new KviServerDetailsWidget(this,m_pLastEditedItem->m_pServerData);
int retCode = m_pServerDetailsDialog->exec();
if(retCode == TQDialog::Accepted)
{
if(m_pLastEditedItem)
{
if(m_pLastEditedItem->m_pServerData)
{
m_pServerDetailsDialog->fillData(m_pLastEditedItem->m_pServerData);
saveLastItem();
}
}
}
delete m_pServerDetailsDialog;
m_pServerDetailsDialog = 0;
return;
}
if(m_pLastEditedItem->m_pNetworkData)
{
saveLastItem();
m_pNetworkDetailsDialog = new KviNetworkDetailsWidget(this,m_pLastEditedItem->m_pNetworkData);
int retCode = m_pNetworkDetailsDialog->exec();
if(retCode == TQDialog::Accepted)
{
if(m_pLastEditedItem)
{
if(m_pLastEditedItem->m_pNetworkData)
{
m_pNetworkDetailsDialog->fillData(m_pLastEditedItem->m_pNetworkData);
saveLastItem();
}
}
}
delete m_pNetworkDetailsDialog;
m_pNetworkDetailsDialog = 0;
}
}
#include "m_optw_servers.moc"