Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/19/head
Michele Calgaro 10 months ago
parent 3d581777cd
commit c650254e18
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF

@ -48,21 +48,21 @@ BorrowerDialog::BorrowerDialog(TQWidget* parent_, const char* name_/*=0*/)
topLayout->addWidget(m_listView); topLayout->addWidget(m_listView);
m_listView->addColumn(i18n("Name")); m_listView->addColumn(i18n("Name"));
m_listView->setFullWidth(true); m_listView->setFullWidth(true);
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem*)), TQT_SLOT(slotOk())); connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), TQ_SLOT(slotOk()));
connect(m_listView, TQT_SIGNAL(selectionChanged(TQListViewItem*)), TQT_SLOT(updateEdit(TQListViewItem*))); connect(m_listView, TQ_SIGNAL(selectionChanged(TQListViewItem*)), TQ_SLOT(updateEdit(TQListViewItem*)));
m_lineEdit = new KLineEdit(mainWidget); m_lineEdit = new KLineEdit(mainWidget);
topLayout->addWidget(m_lineEdit); topLayout->addWidget(m_lineEdit);
connect(m_lineEdit->completionObject(), TQT_SIGNAL(match(const TQString&)), connect(m_lineEdit->completionObject(), TQ_SIGNAL(match(const TQString&)),
TQT_SLOT(selectItem(const TQString&))); TQ_SLOT(selectItem(const TQString&)));
m_lineEdit->setFocus(); m_lineEdit->setFocus();
m_lineEdit->completionObject()->setIgnoreCase(true); m_lineEdit->completionObject()->setIgnoreCase(true);
TDEABC::AddressBook* abook = TDEABC::StdAddressBook::self(true); TDEABC::AddressBook* abook = TDEABC::StdAddressBook::self(true);
connect(abook, TQT_SIGNAL(addressBookChanged(AddressBook*)), connect(abook, TQ_SIGNAL(addressBookChanged(AddressBook*)),
TQT_SLOT(slotLoadAddressBook())); TQ_SLOT(slotLoadAddressBook()));
connect(abook, TQT_SIGNAL(loadingFinished(Resource*)), connect(abook, TQ_SIGNAL(loadingFinished(Resource*)),
TQT_SLOT(slotLoadAddressBook())); TQ_SLOT(slotLoadAddressBook()));
slotLoadAddressBook(); slotLoadAddressBook();
setMinimumWidth(400); setMinimumWidth(400);

@ -200,17 +200,17 @@ bool OpenOffice::connectionDialog() {
KLineEdit* pipeEdit = new KLineEdit(w2); KLineEdit* pipeEdit = new KLineEdit(w2);
pipeEdit->setText(d->pipe); pipeEdit->setText(d->pipe);
gl->addMultiCellWidget(pipeEdit, 0, 0, 1, 2); gl->addMultiCellWidget(pipeEdit, 0, 0, 1, 2);
pipeEdit->connect(radioPipe, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setEnabled(bool))); pipeEdit->connect(radioPipe, TQ_SIGNAL(toggled(bool)), TQ_SLOT(setEnabled(bool)));
KLineEdit* hostEdit = new KLineEdit(w2); KLineEdit* hostEdit = new KLineEdit(w2);
hostEdit->setText(d->host); hostEdit->setText(d->host);
gl->addWidget(hostEdit, 1, 1); gl->addWidget(hostEdit, 1, 1);
hostEdit->connect(radioTCP, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setEnabled(bool))); hostEdit->connect(radioTCP, TQ_SIGNAL(toggled(bool)), TQ_SLOT(setEnabled(bool)));
KIntSpinBox* portSpin = new KIntSpinBox(w2); KIntSpinBox* portSpin = new KIntSpinBox(w2);
portSpin->setMaxValue(99999); portSpin->setMaxValue(99999);
portSpin->setValue(d->port); portSpin->setValue(d->port);
gl->addWidget(portSpin, 1, 2); gl->addWidget(portSpin, 1, 2);
portSpin->connect(radioTCP, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setEnabled(bool))); portSpin->connect(radioTCP, TQ_SIGNAL(toggled(bool)), TQ_SLOT(setEnabled(bool)));
if(d->pipe.isEmpty()) { if(d->pipe.isEmpty()) {
radioTCP->setChecked(true); radioTCP->setChecked(true);

@ -77,7 +77,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
(void) new FieldListBox(m_fieldsBox, it); (void) new FieldListBox(m_fieldsBox, it);
} }
} }
connect(m_fieldsBox, TQT_SIGNAL(highlighted(int)), TQT_SLOT(slotHighlightedChanged(int))); connect(m_fieldsBox, TQ_SIGNAL(highlighted(int)), TQ_SLOT(slotHighlightedChanged(int)));
TQHBox* hb1 = new TQHBox(fieldsGroup); TQHBox* hb1 = new TQHBox(fieldsGroup);
hb1->setSpacing(KDialog::spacingHint()); hb1->setSpacing(KDialog::spacingHint());
@ -88,8 +88,8 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
m_btnDelete->setIconSet(BarIconSet(TQString::fromLatin1("edit-delete"), TDEIcon::SizeSmall)); m_btnDelete->setIconSet(BarIconSet(TQString::fromLatin1("edit-delete"), TDEIcon::SizeSmall));
TQWhatsThis::add(m_btnDelete, i18n("Remove a field from the collection")); TQWhatsThis::add(m_btnDelete, i18n("Remove a field from the collection"));
connect(m_btnNew, TQT_SIGNAL(clicked()), TQT_SLOT(slotNew()) ); connect(m_btnNew, TQ_SIGNAL(clicked()), TQ_SLOT(slotNew()) );
connect(m_btnDelete, TQT_SIGNAL(clicked()), TQT_SLOT(slotDelete())); connect(m_btnDelete, TQ_SIGNAL(clicked()), TQ_SLOT(slotDelete()));
TQHBox* hb2 = new TQHBox(fieldsGroup); TQHBox* hb2 = new TQHBox(fieldsGroup);
hb2->setSpacing(KDialog::spacingHint()); hb2->setSpacing(KDialog::spacingHint());
@ -102,8 +102,8 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
TQWhatsThis::add(m_btnDown, i18n("Move this field down in the list. The list order is important " TQWhatsThis::add(m_btnDown, i18n("Move this field down in the list. The list order is important "
"for the layout of the entry editor.")); "for the layout of the entry editor."));
connect(m_btnUp, TQT_SIGNAL(clicked()), TQT_SLOT(slotMoveUp()) ); connect(m_btnUp, TQ_SIGNAL(clicked()), TQ_SLOT(slotMoveUp()) );
connect(m_btnDown, TQT_SIGNAL(clicked()), TQT_SLOT(slotMoveDown())); connect(m_btnDown, TQ_SIGNAL(clicked()), TQ_SLOT(slotMoveDown()));
TQVBox* vbox = new TQVBox(page); TQVBox* vbox = new TQVBox(page);
vbox->setSpacing(KDialog::spacingHint()); vbox->setSpacing(KDialog::spacingHint());
@ -124,7 +124,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
TQString whats = i18n("The title of the field"); TQString whats = i18n("The title of the field");
TQWhatsThis::add(label, whats); TQWhatsThis::add(label, whats);
TQWhatsThis::add(m_titleEdit, whats); TQWhatsThis::add(m_titleEdit, whats);
connect(m_titleEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_titleEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
label = new TQLabel(i18n("T&ype:"), grid); label = new TQLabel(i18n("T&ype:"), grid);
layout->addWidget(label, row, 2); layout->addWidget(label, row, 2);
@ -151,8 +151,8 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
TQWhatsThis::add(m_typeCombo, whats); TQWhatsThis::add(m_typeCombo, whats);
// the typeTitles match the fieldMap().values() but in a better order // the typeTitles match the fieldMap().values() but in a better order
m_typeCombo->insertStringList(Data::Field::typeTitles()); m_typeCombo->insertStringList(Data::Field::typeTitles());
connect(m_typeCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotModified())); connect(m_typeCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotModified()));
connect(m_typeCombo, TQT_SIGNAL(activated(const TQString&)), TQT_SLOT(slotTypeChanged(const TQString&))); connect(m_typeCombo, TQ_SIGNAL(activated(const TQString&)), TQ_SLOT(slotTypeChanged(const TQString&)));
label = new TQLabel(i18n("Cate&gory:"), grid); label = new TQLabel(i18n("Cate&gory:"), grid);
layout->addWidget(label, ++row, 0); layout->addWidget(label, ++row, 0);
@ -174,7 +174,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
} }
m_catCombo->insertStringList(cats); m_catCombo->insertStringList(cats);
m_catCombo->setDuplicatesEnabled(false); m_catCombo->setDuplicatesEnabled(false);
connect(m_catCombo, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_catCombo, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
label = new TQLabel(i18n("Descr&iption:"), grid); label = new TQLabel(i18n("Descr&iption:"), grid);
layout->addWidget(label, ++row, 0); layout->addWidget(label, ++row, 0);
@ -188,7 +188,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
"\"%{year} %{title}\" where the named fields get substituted in the string."); "\"%{year} %{title}\" where the named fields get substituted in the string.");
TQWhatsThis::add(label, whats); TQWhatsThis::add(label, whats);
TQWhatsThis::add(m_descEdit, whats); TQWhatsThis::add(m_descEdit, whats);
connect(m_descEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_descEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
label = new TQLabel(i18n("&Default value:"), grid); label = new TQLabel(i18n("&Default value:"), grid);
layout->addWidget(label, ++row, 0); layout->addWidget(label, ++row, 0);
@ -198,7 +198,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
whats = i18n("<qt>A default value can be set for new entries.</qt>"); whats = i18n("<qt>A default value can be set for new entries.</qt>");
TQWhatsThis::add(label, whats); TQWhatsThis::add(label, whats);
TQWhatsThis::add(m_defaultEdit, whats); TQWhatsThis::add(m_defaultEdit, whats);
connect(m_defaultEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_defaultEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
label = new TQLabel(i18n("A&llowed values:"), grid); label = new TQLabel(i18n("A&llowed values:"), grid);
layout->addWidget(label, ++row, 0); layout->addWidget(label, ++row, 0);
@ -210,7 +210,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
"for example: \"dog; cat; mouse\"</qt>"); "for example: \"dog; cat; mouse\"</qt>");
TQWhatsThis::add(label, whats); TQWhatsThis::add(label, whats);
TQWhatsThis::add(m_allowEdit, whats); TQWhatsThis::add(m_allowEdit, whats);
connect(m_allowEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_allowEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
label = new TQLabel(i18n("Extended &properties:"), grid); label = new TQLabel(i18n("Extended &properties:"), grid);
layout->addWidget(label, ++row, 0); layout->addWidget(label, ++row, 0);
@ -221,7 +221,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
whats = i18n("Extended field properties are used to specify things such as the corresponding bibtex field."); whats = i18n("Extended field properties are used to specify things such as the corresponding bibtex field.");
TQWhatsThis::add(label, whats); TQWhatsThis::add(label, whats);
TQWhatsThis::add(m_btnExtended, whats); TQWhatsThis::add(m_btnExtended, whats);
connect(m_btnExtended, TQT_SIGNAL(clicked()), TQT_SLOT(slotShowExtendedProperties())); connect(m_btnExtended, TQ_SIGNAL(clicked()), TQ_SLOT(slotShowExtendedProperties()));
TQButtonGroup* bg = new TQButtonGroup(1, TQt::Horizontal, i18n("Format Options"), vbox); TQButtonGroup* bg = new TQButtonGroup(1, TQt::Horizontal, i18n("Format Options"), vbox);
m_formatNone = new TQRadioButton(i18n("No formatting"), bg); m_formatNone = new TQRadioButton(i18n("No formatting"), bg);
@ -236,7 +236,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
m_formatName = new TQRadioButton(i18n("Format as a name"), bg); m_formatName = new TQRadioButton(i18n("Format as a name"), bg);
TQWhatsThis::add(m_formatName, i18n("This option capitalizes and formats the field as a " TQWhatsThis::add(m_formatName, i18n("This option capitalizes and formats the field as a "
"name, but only if those options are globally set.")); "name, but only if those options are globally set."));
connect(bg, TQT_SIGNAL(clicked(int)), TQT_SLOT(slotModified())); connect(bg, TQ_SIGNAL(clicked(int)), TQ_SLOT(slotModified()));
TQGroupBox* optionsGroup = new TQGroupBox(1, TQt::Horizontal, i18n("Field Options"), vbox); TQGroupBox* optionsGroup = new TQGroupBox(1, TQt::Horizontal, i18n("Field Options"), vbox);
m_complete = new TQCheckBox(i18n("Enable auto-completion"), optionsGroup); m_complete = new TQCheckBox(i18n("Enable auto-completion"), optionsGroup);
@ -248,9 +248,9 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
m_grouped = new TQCheckBox(i18n("Allow grouping"), optionsGroup); m_grouped = new TQCheckBox(i18n("Allow grouping"), optionsGroup);
TQWhatsThis::add(m_grouped, i18n("If checked, this field may be used to group the entries in " TQWhatsThis::add(m_grouped, i18n("If checked, this field may be used to group the entries in "
"the group view.")); "the group view."));
connect(m_complete, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_complete, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
connect(m_multiple, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_multiple, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
connect(m_grouped, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_grouped, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
// need to stretch at bottom // need to stretch at bottom
vbox->setStretchFactor(new TQWidget(vbox), 1); vbox->setStretchFactor(new TQWidget(vbox), 1);
@ -271,7 +271,7 @@ CollectionFieldsDialog::CollectionFieldsDialog(Data::CollPtr coll_, TQWidget* pa
// new types. The problem is that when more types are added, the size of the combo box // new types. The problem is that when more types are added, the size of the combo box
// doesn't change. So when everything is laid out, the combo box needs to have all the // doesn't change. So when everything is laid out, the combo box needs to have all the
// items there. // items there.
TQTimer::singleShot(0, this, TQT_SLOT(slotSelectInitial())); TQTimer::singleShot(0, this, TQ_SLOT(slotSelectInitial()));
} }
CollectionFieldsDialog::~CollectionFieldsDialog() { CollectionFieldsDialog::~CollectionFieldsDialog() {

@ -134,7 +134,7 @@ ConfigDialog::ConfigDialog(TQWidget* parent_, const char* name_/*=0*/)
enableButtonApply(false); enableButtonApply(false);
setHelp(TQString::fromLatin1("general-options")); setHelp(TQString::fromLatin1("general-options"));
connect(this, TQT_SIGNAL(aboutToShowPage(TQWidget*)), TQT_SLOT(slotUpdateHelpLink(TQWidget*))); connect(this, TQ_SIGNAL(aboutToShowPage(TQWidget*)), TQ_SLOT(slotUpdateHelpLink(TQWidget*)));
} }
ConfigDialog::~ConfigDialog() { ConfigDialog::~ConfigDialog() {
@ -202,13 +202,13 @@ void ConfigDialog::setupGeneralPage() {
TQWhatsThis::add(m_cbOpenLastFile, i18n("If checked, the file that was last open " TQWhatsThis::add(m_cbOpenLastFile, i18n("If checked, the file that was last open "
"will be re-opened at program start-up.")); "will be re-opened at program start-up."));
l->addWidget(m_cbOpenLastFile); l->addWidget(m_cbOpenLastFile);
connect(m_cbOpenLastFile, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_cbOpenLastFile, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
m_cbShowTipDay = new TQCheckBox(i18n("&Show \"Tip of the Day\" at startup"), frame); m_cbShowTipDay = new TQCheckBox(i18n("&Show \"Tip of the Day\" at startup"), frame);
TQWhatsThis::add(m_cbShowTipDay, i18n("If checked, the \"Tip of the Day\" will be " TQWhatsThis::add(m_cbShowTipDay, i18n("If checked, the \"Tip of the Day\" will be "
"shown at program start-up.")); "shown at program start-up."));
l->addWidget(m_cbShowTipDay); l->addWidget(m_cbShowTipDay);
connect(m_cbShowTipDay, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_cbShowTipDay, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
TQButtonGroup* imageGroup = new TQVButtonGroup(i18n("Image Storage Options"), frame); TQButtonGroup* imageGroup = new TQVButtonGroup(i18n("Image Storage Options"), frame);
m_rbImageInFile = new TQRadioButton(i18n("Store images in data file"), imageGroup); m_rbImageInFile = new TQRadioButton(i18n("Store images in data file"), imageGroup);
@ -219,7 +219,7 @@ void ConfigDialog::setupGeneralPage() {
"application directory, or stored in a directory in the " "application directory, or stored in a directory in the "
"same location as the data file.")); "same location as the data file."));
l->addWidget(imageGroup); l->addWidget(imageGroup);
connect(imageGroup, TQT_SIGNAL(clicked(int)), TQT_SLOT(slotModified())); connect(imageGroup, TQ_SIGNAL(clicked(int)), TQ_SLOT(slotModified()));
TQVGroupBox* formatGroup = new TQVGroupBox(i18n("Formatting Options"), frame); TQVGroupBox* formatGroup = new TQVGroupBox(i18n("Formatting Options"), frame);
l->addWidget(formatGroup); l->addWidget(formatGroup);
@ -227,12 +227,12 @@ void ConfigDialog::setupGeneralPage() {
m_cbCapitalize = new TQCheckBox(i18n("Auto capitalize &titles and names"), formatGroup); m_cbCapitalize = new TQCheckBox(i18n("Auto capitalize &titles and names"), formatGroup);
TQWhatsThis::add(m_cbCapitalize, i18n("If checked, titles and names will " TQWhatsThis::add(m_cbCapitalize, i18n("If checked, titles and names will "
"be automatically capitalized.")); "be automatically capitalized."));
connect(m_cbCapitalize, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_cbCapitalize, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
m_cbFormat = new TQCheckBox(i18n("Auto &format titles and names"), formatGroup); m_cbFormat = new TQCheckBox(i18n("Auto &format titles and names"), formatGroup);
TQWhatsThis::add(m_cbFormat, i18n("If checked, titles and names will " TQWhatsThis::add(m_cbFormat, i18n("If checked, titles and names will "
"be automatically formatted.")); "be automatically formatted."));
connect(m_cbFormat, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_cbFormat, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
TQGrid* g1 = new TQGrid(2, formatGroup); TQGrid* g1 = new TQGrid(2, formatGroup);
g1->setSpacing(5); g1->setSpacing(5);
@ -244,7 +244,7 @@ void ConfigDialog::setupGeneralPage() {
"should be separated by a semi-colon.</qt>"); "should be separated by a semi-colon.</qt>");
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_leCapitals, whats); TQWhatsThis::add(m_leCapitals, whats);
connect(m_leCapitals, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_leCapitals, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
lab = new TQLabel(i18n("Artic&les:"), g1); lab = new TQLabel(i18n("Artic&les:"), g1);
m_leArticles = new KLineEdit(g1); m_leArticles = new KLineEdit(g1);
@ -254,7 +254,7 @@ void ConfigDialog::setupGeneralPage() {
"should be separated by a semi-colon.</qt>"); "should be separated by a semi-colon.</qt>");
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_leArticles, whats); TQWhatsThis::add(m_leArticles, whats);
connect(m_leArticles, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_leArticles, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
lab = new TQLabel(i18n("Personal suffi&xes:"), g1); lab = new TQLabel(i18n("Personal suffi&xes:"), g1);
m_leSuffixes = new KLineEdit(g1); m_leSuffixes = new KLineEdit(g1);
@ -263,7 +263,7 @@ void ConfigDialog::setupGeneralPage() {
"should be separated by a semi-colon.</qt>"); "should be separated by a semi-colon.</qt>");
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_leSuffixes, whats); TQWhatsThis::add(m_leSuffixes, whats);
connect(m_leSuffixes, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_leSuffixes, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
lab = new TQLabel(i18n("Surname &prefixes:"), g1); lab = new TQLabel(i18n("Surname &prefixes:"), g1);
m_lePrefixes = new KLineEdit(g1); m_lePrefixes = new KLineEdit(g1);
@ -272,7 +272,7 @@ void ConfigDialog::setupGeneralPage() {
"should be separated by a semi-colon.</qt>"); "should be separated by a semi-colon.</qt>");
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_lePrefixes, whats); TQWhatsThis::add(m_lePrefixes, whats);
connect(m_lePrefixes, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_lePrefixes, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
// stretch to fill lower area // stretch to fill lower area
l->addStretch(1); l->addStretch(1);
@ -301,18 +301,18 @@ void ConfigDialog::setupPrintingPage() {
m_cbPrintFormatted = new TQCheckBox(i18n("&Format titles and names"), formatOptions); m_cbPrintFormatted = new TQCheckBox(i18n("&Format titles and names"), formatOptions);
TQWhatsThis::add(m_cbPrintFormatted, i18n("If checked, titles and names will be automatically formatted.")); TQWhatsThis::add(m_cbPrintFormatted, i18n("If checked, titles and names will be automatically formatted."));
connect(m_cbPrintFormatted, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_cbPrintFormatted, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
m_cbPrintHeaders = new TQCheckBox(i18n("&Print field headers"), formatOptions); m_cbPrintHeaders = new TQCheckBox(i18n("&Print field headers"), formatOptions);
TQWhatsThis::add(m_cbPrintHeaders, i18n("If checked, the field names will be printed as table headers.")); TQWhatsThis::add(m_cbPrintHeaders, i18n("If checked, the field names will be printed as table headers."));
connect(m_cbPrintHeaders, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_cbPrintHeaders, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
TQHGroupBox* groupOptions = new TQHGroupBox(i18n("Grouping Options"), frame); TQHGroupBox* groupOptions = new TQHGroupBox(i18n("Grouping Options"), frame);
l->addWidget(groupOptions); l->addWidget(groupOptions);
m_cbPrintGrouped = new TQCheckBox(i18n("&Group the entries"), groupOptions); m_cbPrintGrouped = new TQCheckBox(i18n("&Group the entries"), groupOptions);
TQWhatsThis::add(m_cbPrintGrouped, i18n("If checked, the entries will be grouped by the selected field.")); TQWhatsThis::add(m_cbPrintGrouped, i18n("If checked, the entries will be grouped by the selected field."));
connect(m_cbPrintGrouped, TQT_SIGNAL(clicked()), TQT_SLOT(slotModified())); connect(m_cbPrintGrouped, TQ_SIGNAL(clicked()), TQ_SLOT(slotModified()));
TQVGroupBox* imageOptions = new TQVGroupBox(i18n("Image Options"), frame); TQVGroupBox* imageOptions = new TQVGroupBox(i18n("Image Options"), frame);
l->addWidget(imageOptions); l->addWidget(imageOptions);
@ -328,10 +328,10 @@ void ConfigDialog::setupPrintingPage() {
TQString whats = i18n("The maximum width of the images in the printout. The aspect ration is preserved."); TQString whats = i18n("The maximum width of the images in the printout. The aspect ration is preserved.");
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_imageWidthBox, whats); TQWhatsThis::add(m_imageWidthBox, whats);
connect(m_imageWidthBox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotModified())); connect(m_imageWidthBox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotModified()));
// TQSpinBox doesn't emit valueChanged if you edit the value with // TQSpinBox doesn't emit valueChanged if you edit the value with
// the lineEdit until you change the keyboard focus // the lineEdit until you change the keyboard focus
connect(m_imageWidthBox->child("qt_spinbox_edit"), TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_imageWidthBox->child("qt_spinbox_edit"), TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
lab = new TQLabel(i18n("&Maximum image height:"), grid); lab = new TQLabel(i18n("&Maximum image height:"), grid);
m_imageHeightBox = new KIntSpinBox(0, 999, 1, 50, 10, grid); m_imageHeightBox = new KIntSpinBox(0, 999, 1, 50, 10, grid);
@ -341,10 +341,10 @@ void ConfigDialog::setupPrintingPage() {
whats = i18n("The maximum height of the images in the printout. The aspect ration is preserved."); whats = i18n("The maximum height of the images in the printout. The aspect ration is preserved.");
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_imageHeightBox, whats); TQWhatsThis::add(m_imageHeightBox, whats);
connect(m_imageHeightBox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotModified())); connect(m_imageHeightBox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotModified()));
// TQSpinBox doesn't emit valueChanged if you edit the value with // TQSpinBox doesn't emit valueChanged if you edit the value with
// the lineEdit until you change the keyboard focus // the lineEdit until you change the keyboard focus
connect(m_imageHeightBox->child("qt_spinbox_edit"), TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotModified())); connect(m_imageHeightBox->child("qt_spinbox_edit"), TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotModified()));
// stretch to fill lower area // stretch to fill lower area
l->addStretch(1); l->addStretch(1);
@ -368,7 +368,7 @@ void ConfigDialog::setupTemplatePage() {
lab = new TQLabel(i18n("Template:"), frame); lab = new TQLabel(i18n("Template:"), frame);
m_templateCombo = new GUI::ComboBox(frame); m_templateCombo = new GUI::ComboBox(frame);
connect(m_templateCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotModified())); connect(m_templateCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotModified()));
lab->setBuddy(m_templateCombo); lab->setBuddy(m_templateCombo);
TQString whats = i18n("Select the template to use for the current type of collections. " TQString whats = i18n("Select the template to use for the current type of collections. "
"Not all templates will use the font and color settings."); "Not all templates will use the font and color settings.");
@ -381,7 +381,7 @@ void ConfigDialog::setupTemplatePage() {
TQWhatsThis::add(btn, i18n("Show a preview of the template")); TQWhatsThis::add(btn, i18n("Show a preview of the template"));
btn->setIconSet(SmallIconSet(TQString::fromLatin1("viewmag"))); btn->setIconSet(SmallIconSet(TQString::fromLatin1("viewmag")));
gridLayout->addWidget(btn, row, 2); gridLayout->addWidget(btn, row, 2);
connect(btn, TQT_SIGNAL(clicked()), TQT_SLOT(slotShowTemplatePreview())); connect(btn, TQ_SIGNAL(clicked()), TQ_SLOT(slotShowTemplatePreview()));
// so the button is squeezed small // so the button is squeezed small
gridLayout->setColStretch(0, 10); gridLayout->setColStretch(0, 10);
@ -406,7 +406,7 @@ void ConfigDialog::setupTemplatePage() {
fontLayout->addWidget(lab, ++row, 0); fontLayout->addWidget(lab, ++row, 0);
m_fontCombo = new TDEFontCombo(fontGroup); m_fontCombo = new TDEFontCombo(fontGroup);
fontLayout->addWidget(m_fontCombo, row, 1); fontLayout->addWidget(m_fontCombo, row, 1);
connect(m_fontCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotModified())); connect(m_fontCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotModified()));
lab->setBuddy(m_fontCombo); lab->setBuddy(m_fontCombo);
whats = i18n("This font is passed to the template used in the Entry View."); whats = i18n("This font is passed to the template used in the Entry View.");
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
@ -417,7 +417,7 @@ void ConfigDialog::setupTemplatePage() {
m_fontSizeInput->setRange(5, 30); // 30 is same max as konq config m_fontSizeInput->setRange(5, 30); // 30 is same max as konq config
m_fontSizeInput->setSuffix(TQString::fromLatin1("pt")); m_fontSizeInput->setSuffix(TQString::fromLatin1("pt"));
fontLayout->addWidget(m_fontSizeInput, row, 1); fontLayout->addWidget(m_fontSizeInput, row, 1);
connect(m_fontSizeInput, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotModified())); connect(m_fontSizeInput, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotModified()));
lab->setBuddy(m_fontSizeInput); lab->setBuddy(m_fontSizeInput);
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_fontSizeInput, whats); TQWhatsThis::add(m_fontSizeInput, whats);
@ -433,7 +433,7 @@ void ConfigDialog::setupTemplatePage() {
colLayout->addWidget(lab, ++row, 0); colLayout->addWidget(lab, ++row, 0);
m_baseColorCombo = new KColorCombo(colGroup); m_baseColorCombo = new KColorCombo(colGroup);
colLayout->addWidget(m_baseColorCombo, row, 1); colLayout->addWidget(m_baseColorCombo, row, 1);
connect(m_baseColorCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotModified())); connect(m_baseColorCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotModified()));
lab->setBuddy(m_baseColorCombo); lab->setBuddy(m_baseColorCombo);
whats = i18n("This color is passed to the template used in the Entry View."); whats = i18n("This color is passed to the template used in the Entry View.");
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
@ -443,7 +443,7 @@ void ConfigDialog::setupTemplatePage() {
colLayout->addWidget(lab, ++row, 0); colLayout->addWidget(lab, ++row, 0);
m_textColorCombo = new KColorCombo(colGroup); m_textColorCombo = new KColorCombo(colGroup);
colLayout->addWidget(m_textColorCombo, row, 1); colLayout->addWidget(m_textColorCombo, row, 1);
connect(m_textColorCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotModified())); connect(m_textColorCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotModified()));
lab->setBuddy(m_textColorCombo); lab->setBuddy(m_textColorCombo);
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_textColorCombo, whats); TQWhatsThis::add(m_textColorCombo, whats);
@ -452,7 +452,7 @@ void ConfigDialog::setupTemplatePage() {
colLayout->addWidget(lab, ++row, 0); colLayout->addWidget(lab, ++row, 0);
m_highBaseColorCombo = new KColorCombo(colGroup); m_highBaseColorCombo = new KColorCombo(colGroup);
colLayout->addWidget(m_highBaseColorCombo, row, 1); colLayout->addWidget(m_highBaseColorCombo, row, 1);
connect(m_highBaseColorCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotModified())); connect(m_highBaseColorCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotModified()));
lab->setBuddy(m_highBaseColorCombo); lab->setBuddy(m_highBaseColorCombo);
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_highBaseColorCombo, whats); TQWhatsThis::add(m_highBaseColorCombo, whats);
@ -461,7 +461,7 @@ void ConfigDialog::setupTemplatePage() {
colLayout->addWidget(lab, ++row, 0); colLayout->addWidget(lab, ++row, 0);
m_highTextColorCombo = new KColorCombo(colGroup); m_highTextColorCombo = new KColorCombo(colGroup);
colLayout->addWidget(m_highTextColorCombo, row, 1); colLayout->addWidget(m_highTextColorCombo, row, 1);
connect(m_highTextColorCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotModified())); connect(m_highTextColorCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotModified()));
lab->setBuddy(m_highTextColorCombo); lab->setBuddy(m_highTextColorCombo);
TQWhatsThis::add(lab, whats); TQWhatsThis::add(lab, whats);
TQWhatsThis::add(m_highTextColorCombo, whats); TQWhatsThis::add(m_highTextColorCombo, whats);
@ -474,19 +474,19 @@ void ConfigDialog::setupTemplatePage() {
KPushButton* b1 = new KPushButton(i18n("Install..."), box1); KPushButton* b1 = new KPushButton(i18n("Install..."), box1);
b1->setIconSet(SmallIconSet(TQString::fromLatin1("add"))); b1->setIconSet(SmallIconSet(TQString::fromLatin1("add")));
connect(b1, TQT_SIGNAL(clicked()), TQT_SLOT(slotInstallTemplate())); connect(b1, TQ_SIGNAL(clicked()), TQ_SLOT(slotInstallTemplate()));
whats = i18n("Click to install a new template directly."); whats = i18n("Click to install a new template directly.");
TQWhatsThis::add(b1, whats); TQWhatsThis::add(b1, whats);
KPushButton* b2 = new KPushButton(i18n("Download..."), box1); KPushButton* b2 = new KPushButton(i18n("Download..."), box1);
b2->setIconSet(SmallIconSet(TQString::fromLatin1("knewstuff"))); b2->setIconSet(SmallIconSet(TQString::fromLatin1("knewstuff")));
connect(b2, TQT_SIGNAL(clicked()), TQT_SLOT(slotDownloadTemplate())); connect(b2, TQ_SIGNAL(clicked()), TQ_SLOT(slotDownloadTemplate()));
whats = i18n("Click to download additional templates via the Internet."); whats = i18n("Click to download additional templates via the Internet.");
TQWhatsThis::add(b2, whats); TQWhatsThis::add(b2, whats);
KPushButton* b3 = new KPushButton(i18n("Delete..."), box1); KPushButton* b3 = new KPushButton(i18n("Delete..."), box1);
b3->setIconSet(SmallIconSet(TQString::fromLatin1("remove"))); b3->setIconSet(SmallIconSet(TQString::fromLatin1("remove")));
connect(b3, TQT_SIGNAL(clicked()), TQT_SLOT(slotDeleteTemplate())); connect(b3, TQ_SIGNAL(clicked()), TQ_SLOT(slotDeleteTemplate()));
whats = i18n("Click to select and remove installed templates."); whats = i18n("Click to select and remove installed templates.");
TQWhatsThis::add(b3, whats); TQWhatsThis::add(b3, whats);
@ -508,8 +508,8 @@ void ConfigDialog::setupFetchPage() {
m_sourceListView->setSorting(-1); // no sorting m_sourceListView->setSorting(-1); // no sorting
m_sourceListView->setSelectionMode(TQListView::Single); m_sourceListView->setSelectionMode(TQListView::Single);
leftLayout->addWidget(m_sourceListView, 1); leftLayout->addWidget(m_sourceListView, 1);
connect(m_sourceListView, TQT_SIGNAL(selectionChanged(TQListViewItem*)), TQT_SLOT(slotSelectedSourceChanged(TQListViewItem*))); connect(m_sourceListView, TQ_SIGNAL(selectionChanged(TQListViewItem*)), TQ_SLOT(slotSelectedSourceChanged(TQListViewItem*)));
connect(m_sourceListView, TQT_SIGNAL(doubleClicked(TQListViewItem*, const TQPoint&, int)), TQT_SLOT(slotModifySourceClicked())); connect(m_sourceListView, TQ_SIGNAL(doubleClicked(TQListViewItem*, const TQPoint&, int)), TQ_SLOT(slotModifySourceClicked()));
TQHBox* hb = new TQHBox(frame); TQHBox* hb = new TQHBox(frame);
leftLayout->addWidget(hb); leftLayout->addWidget(hb);
@ -551,12 +551,12 @@ void ConfigDialog::setupFetchPage() {
vlay->addWidget(m_newStuffBtn); vlay->addWidget(m_newStuffBtn);
vlay->addStretch(1); vlay->addStretch(1);
connect(newSourceBtn, TQT_SIGNAL(clicked()), TQT_SLOT(slotNewSourceClicked())); connect(newSourceBtn, TQ_SIGNAL(clicked()), TQ_SLOT(slotNewSourceClicked()));
connect(m_modifySourceBtn, TQT_SIGNAL(clicked()), TQT_SLOT(slotModifySourceClicked())); connect(m_modifySourceBtn, TQ_SIGNAL(clicked()), TQ_SLOT(slotModifySourceClicked()));
connect(m_moveUpSourceBtn, TQT_SIGNAL(clicked()), TQT_SLOT(slotMoveUpSourceClicked())); connect(m_moveUpSourceBtn, TQ_SIGNAL(clicked()), TQ_SLOT(slotMoveUpSourceClicked()));
connect(m_moveDownSourceBtn, TQT_SIGNAL(clicked()), TQT_SLOT(slotMoveDownSourceClicked())); connect(m_moveDownSourceBtn, TQ_SIGNAL(clicked()), TQ_SLOT(slotMoveDownSourceClicked()));
connect(m_removeSourceBtn, TQT_SIGNAL(clicked()), TQT_SLOT(slotRemoveSourceClicked())); connect(m_removeSourceBtn, TQ_SIGNAL(clicked()), TQ_SLOT(slotRemoveSourceClicked()));
connect(m_newStuffBtn, TQT_SIGNAL(clicked()), TQT_SLOT(slotNewStuffClicked())); connect(m_newStuffBtn, TQ_SIGNAL(clicked()), TQ_SLOT(slotNewStuffClicked()));
TDEAcceleratorManager::manage(frame); TDEAcceleratorManager::manage(frame);
} }

@ -141,11 +141,11 @@ void Controller::slotCollectionAdded(Data::CollPtr coll_) {
updateActions(); updateActions();
connect(coll_, TQT_SIGNAL(signalGroupsModified(Tellico::Data::CollPtr, PtrVector<Tellico::Data::EntryGroup>)), connect(coll_, TQ_SIGNAL(signalGroupsModified(Tellico::Data::CollPtr, PtrVector<Tellico::Data::EntryGroup>)),
m_mainWindow->m_groupView, TQT_SLOT(slotModifyGroups(Tellico::Data::CollPtr, PtrVector<Tellico::Data::EntryGroup>))); m_mainWindow->m_groupView, TQ_SLOT(slotModifyGroups(Tellico::Data::CollPtr, PtrVector<Tellico::Data::EntryGroup>)));
connect(coll_, TQT_SIGNAL(signalRefreshField(Tellico::Data::FieldPtr)), connect(coll_, TQ_SIGNAL(signalRefreshField(Tellico::Data::FieldPtr)),
this, TQT_SLOT(slotRefreshField(Tellico::Data::FieldPtr))); this, TQ_SLOT(slotRefreshField(Tellico::Data::FieldPtr)));
} }
void Controller::slotCollectionModified(Data::CollPtr coll_) { void Controller::slotCollectionModified(Data::CollPtr coll_) {

@ -73,8 +73,8 @@ TQPixmap NetAccess::filePreview(const KURL& url, int size) {
KURL::List list; KURL::List list;
list.append(url); list.append(url);
TDEIO::Job* previewJob = TDEIO::filePreview(list, size, size); TDEIO::Job* previewJob = TDEIO::filePreview(list, size, size);
connect(previewJob, TQT_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)), connect(previewJob, TQ_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)),
&netaccess, TQT_SLOT(slotPreview(const KFileItem*, const TQPixmap&))); &netaccess, TQ_SLOT(slotPreview(const KFileItem*, const TQPixmap&)));
TDEIO::NetAccess::synchronousRun(previewJob, Kernel::self()->widget()); TDEIO::NetAccess::synchronousRun(previewJob, Kernel::self()->widget());
return netaccess.m_preview; return netaccess.m_preview;
@ -86,8 +86,8 @@ TQPixmap NetAccess::filePreview(KFileItem* item, int size) {
KFileItemList list; KFileItemList list;
list.append(item); list.append(item);
TDEIO::Job* previewJob = TDEIO::filePreview(list, size, size); TDEIO::Job* previewJob = TDEIO::filePreview(list, size, size);
connect(previewJob, TQT_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)), connect(previewJob, TQ_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)),
&netaccess, TQT_SLOT(slotPreview(const KFileItem*, const TQPixmap&))); &netaccess, TQ_SLOT(slotPreview(const KFileItem*, const TQPixmap&)));
TDEIO::NetAccess::synchronousRun(previewJob, Kernel::self()->widget()); TDEIO::NetAccess::synchronousRun(previewJob, Kernel::self()->widget());
return netaccess.m_preview; return netaccess.m_preview;

@ -62,13 +62,13 @@ void DetailedEntryItem::setState(State state_) {
if(!m_timer) { if(!m_timer) {
m_timer = new TQTimer(); m_timer = new TQTimer();
m_timer->connect(m_timer, TQT_SIGNAL(timeout()), listView(), TQT_SLOT(triggerUpdate())); m_timer->connect(m_timer, TQ_SIGNAL(timeout()), listView(), TQ_SLOT(triggerUpdate()));
} }
m_timer->start(30 * 1000); // every 30 seconds m_timer->start(30 * 1000); // every 30 seconds
} }
// have to put this in a timer, or it doesn't update properly // have to put this in a timer, or it doesn't update properly
TQTimer::singleShot(500, listView(), TQT_SLOT(triggerUpdate())); TQTimer::singleShot(500, listView(), TQ_SLOT(triggerUpdate()));
} }
void DetailedEntryItem::paintCell(TQPainter* p_, const TQColorGroup& cg_, void DetailedEntryItem::paintCell(TQPainter* p_, const TQColorGroup& cg_,

@ -50,23 +50,23 @@ DetailedListView::DetailedListView(TQWidget* parent_, const char* name_/*=0*/)
setShowSortIndicator(true); setShowSortIndicator(true);
setShadeSortColumn(true); setShadeSortColumn(true);
// connect(this, TQT_SIGNAL(selectionChanged()), TQT_SLOT(slotSelectionChanged())); // connect(this, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotSelectionChanged()));
connect(this, TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)), connect(this, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
TQT_SLOT(contextMenuRequested(TQListViewItem*, const TQPoint&, int))); TQ_SLOT(contextMenuRequested(TQListViewItem*, const TQPoint&, int)));
connect(header(), TQT_SIGNAL(indexChange(int, int, int)), connect(header(), TQ_SIGNAL(indexChange(int, int, int)),
TQT_SLOT(slotUpdatePixmap())); TQ_SLOT(slotUpdatePixmap()));
// header menu // header menu
header()->setClickEnabled(true); header()->setClickEnabled(true);
header()->installEventFilter(this); header()->installEventFilter(this);
connect(header(), TQT_SIGNAL(sizeChange(int, int, int)), connect(header(), TQ_SIGNAL(sizeChange(int, int, int)),
this, TQT_SLOT(slotCacheColumnWidth(int, int, int))); this, TQ_SLOT(slotCacheColumnWidth(int, int, int)));
m_headerMenu = new TDEPopupMenu(this); m_headerMenu = new TDEPopupMenu(this);
m_headerMenu->setCheckable(true); m_headerMenu->setCheckable(true);
m_headerMenu->insertTitle(i18n("View Columns")); m_headerMenu->insertTitle(i18n("View Columns"));
connect(m_headerMenu, TQT_SIGNAL(activated(int)), connect(m_headerMenu, TQ_SIGNAL(activated(int)),
this, TQT_SLOT(slotHeaderMenuActivated(int))); this, TQ_SLOT(slotHeaderMenuActivated(int)));
m_checkPix = UserIcon(TQString::fromLatin1("checkmark")); m_checkPix = UserIcon(TQString::fromLatin1("checkmark"));
} }

@ -149,7 +149,7 @@ bool Document::openDocument(const KURL& url_) {
// } // }
if(m_importer->hasImages()) { if(m_importer->hasImages()) {
m_cancelImageWriting = false; m_cancelImageWriting = false;
TQTimer::singleShot(500, this, TQT_SLOT(slotLoadAllImages())); TQTimer::singleShot(500, this, TQ_SLOT(slotLoadAllImages()));
} else { } else {
emit signalCollectionImagesLoaded(m_coll); emit signalCollectionImagesLoaded(m_coll);
m_importer->deleteLater(); m_importer->deleteLater();

@ -67,10 +67,10 @@ EntryEditDialog::EntryEditDialog(TQWidget* parent_, const char* name_)
setButtonGuiItem(m_saveBtn, save); setButtonGuiItem(m_saveBtn, save);
enableButton(m_saveBtn, false); enableButton(m_saveBtn, false);
connect(this, TQT_SIGNAL(applyClicked()), TQT_SLOT(slotHandleSave())); connect(this, TQ_SIGNAL(applyClicked()), TQ_SLOT(slotHandleSave()));
connect(this, TQT_SIGNAL(user1Clicked()), TQT_SLOT(slotHandleNew())); connect(this, TQ_SIGNAL(user1Clicked()), TQ_SLOT(slotHandleNew()));
connect(this, TQT_SIGNAL(user2Clicked()), TQT_SLOT(slotGoNextEntry())); connect(this, TQ_SIGNAL(user2Clicked()), TQ_SLOT(slotGoNextEntry()));
connect(this, TQT_SIGNAL(user3Clicked()), TQT_SLOT(slotGoPrevEntry())); connect(this, TQ_SIGNAL(user3Clicked()), TQ_SLOT(slotGoPrevEntry()));
KGuiItem prev; KGuiItem prev;
prev.setIconName(TQString::fromLatin1(TQApplication::reverseLayout() ? "forward" : "back")); prev.setIconName(TQString::fromLatin1(TQApplication::reverseLayout() ? "forward" : "back"));
@ -87,9 +87,9 @@ EntryEditDialog::EntryEditDialog(TQWidget* parent_, const char* name_)
TDEAccel* accel = new TDEAccel(this); TDEAccel* accel = new TDEAccel(this);
accel->insert(TQString::fromLatin1("Go Prev"), TQString(), prev.toolTip(), TQt::Key_PageUp, accel->insert(TQString::fromLatin1("Go Prev"), TQString(), prev.toolTip(), TQt::Key_PageUp,
Controller::self(), TQT_SLOT(slotGoPrevEntry())); Controller::self(), TQ_SLOT(slotGoPrevEntry()));
accel->insert(TQString::fromLatin1("Go Next"), TQString(), next.toolTip(), TQt::Key_PageDown, accel->insert(TQString::fromLatin1("Go Next"), TQString(), next.toolTip(), TQt::Key_PageDown,
Controller::self(), TQT_SLOT(slotGoNextEntry())); Controller::self(), TQ_SLOT(slotGoNextEntry()));
setHelp(TQString::fromLatin1("entry-editor")); setHelp(TQString::fromLatin1("entry-editor"));
@ -194,7 +194,7 @@ void EntryEditDialog::setLayout(Data::CollPtr coll_) {
if(!widget) { if(!widget) {
continue; continue;
} }
connect(widget, TQT_SIGNAL(modified()), TQT_SLOT(slotSetModified())); connect(widget, TQ_SIGNAL(modified()), TQ_SLOT(slotSetModified()));
if(!focusedFirst && widget->isFocusEnabled()) { if(!focusedFirst && widget->isFocusEnabled()) {
widget->setFocus(); widget->setFocus();
focusedFirst = true; focusedFirst = true;

@ -57,10 +57,10 @@ EntryIconView::EntryIconView(TQWidget* parent_, const char* name_/*=0*/)
m_defaultPixmaps.setAutoDelete(true); m_defaultPixmaps.setAutoDelete(true);
connect(this, TQT_SIGNAL(selectionChanged()), TQT_SLOT(slotSelectionChanged())); connect(this, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotSelectionChanged()));
connect(this, TQT_SIGNAL(doubleClicked(TQIconViewItem*)), TQT_SLOT(slotDoubleClicked(TQIconViewItem*))); connect(this, TQ_SIGNAL(doubleClicked(TQIconViewItem*)), TQ_SLOT(slotDoubleClicked(TQIconViewItem*)));
connect(this, TQT_SIGNAL(contextMenuRequested(TQIconViewItem*, const TQPoint&)), connect(this, TQ_SIGNAL(contextMenuRequested(TQIconViewItem*, const TQPoint&)),
TQT_SLOT(slotShowContextMenu(TQIconViewItem*, const TQPoint&))); TQ_SLOT(slotShowContextMenu(TQIconViewItem*, const TQPoint&)));
} }
EntryIconView::~EntryIconView() { EntryIconView::~EntryIconView() {
@ -282,7 +282,7 @@ void EntryIconView::slotShowContextMenu(TQIconViewItem* item_, const TQPoint& po
for(TQStringList::ConstIterator it = titles.begin(); it != titles.end(); ++it) { for(TQStringList::ConstIterator it = titles.begin(); it != titles.end(); ++it) {
sortMenu.insertItem(*it); sortMenu.insertItem(*it);
} }
connect(&sortMenu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSortMenuActivated(int))); connect(&sortMenu, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSortMenuActivated(int)));
menu.insertItem(i18n("&Sort By"), &sortMenu); menu.insertItem(i18n("&Sort By"), &sortMenu);
menu.exec(point_); menu.exec(point_);

@ -35,11 +35,11 @@ EntryMerger::EntryMerger(Data::EntryVec entries_, TQObject* parent_)
TQString label = i18n("Merging entries..."); TQString label = i18n("Merging entries...");
ProgressItem& item = ProgressManager::self()->newProgressItem(this, label, true /*canCancel*/); ProgressItem& item = ProgressManager::self()->newProgressItem(this, label, true /*canCancel*/);
item.setTotalSteps(m_origCount); item.setTotalSteps(m_origCount);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
// done if no entries to merge // done if no entries to merge
if(m_origCount < 2) { if(m_origCount < 2) {
TQTimer::singleShot(500, this, TQT_SLOT(slotCleanup())); TQTimer::singleShot(500, this, TQ_SLOT(slotCleanup()));
} else { } else {
slotStartNext(); // starts fetching slotStartNext(); // starts fetching
} }
@ -72,9 +72,9 @@ void EntryMerger::slotStartNext() {
m_entriesToCheck.remove(baseEntry); m_entriesToCheck.remove(baseEntry);
if(m_cancelled || m_entriesToCheck.count() < 2) { if(m_cancelled || m_entriesToCheck.count() < 2) {
TQTimer::singleShot(0, this, TQT_SLOT(slotCleanup())); TQTimer::singleShot(0, this, TQ_SLOT(slotCleanup()));
} else { } else {
TQTimer::singleShot(0, this, TQT_SLOT(slotStartNext())); TQTimer::singleShot(0, this, TQ_SLOT(slotStartNext()));
} }
} }

@ -42,10 +42,10 @@ EntryUpdater::EntryUpdater(Data::CollPtr coll_, Data::EntryVec entries_, TQObjec
// for now, we're assuming all entries are same collection type // for now, we're assuming all entries are same collection type
m_fetchers = Fetch::Manager::self()->createUpdateFetchers(m_coll->type()); m_fetchers = Fetch::Manager::self()->createUpdateFetchers(m_coll->type());
for(Fetch::FetcherVec::Iterator it = m_fetchers.begin(); it != m_fetchers.end(); ++it) { for(Fetch::FetcherVec::Iterator it = m_fetchers.begin(); it != m_fetchers.end(); ++it) {
connect(it.data(), TQT_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)), connect(it.data(), TQ_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)),
TQT_SLOT(slotResult(Tellico::Fetch::SearchResult*))); TQ_SLOT(slotResult(Tellico::Fetch::SearchResult*)));
connect(it.data(), TQT_SIGNAL(signalDone(Tellico::Fetch::Fetcher::Ptr)), connect(it.data(), TQ_SIGNAL(signalDone(Tellico::Fetch::Fetcher::Ptr)),
TQT_SLOT(slotDone())); TQ_SLOT(slotDone()));
} }
init(); init();
} }
@ -59,10 +59,10 @@ EntryUpdater::EntryUpdater(const TQString& source_, Data::CollPtr coll_, Data::E
Fetch::Fetcher::Ptr f = Fetch::Manager::self()->createUpdateFetcher(m_coll->type(), source_); Fetch::Fetcher::Ptr f = Fetch::Manager::self()->createUpdateFetcher(m_coll->type(), source_);
if(f) { if(f) {
m_fetchers.append(f); m_fetchers.append(f);
connect(f, TQT_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)), connect(f, TQ_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)),
TQT_SLOT(slotResult(Tellico::Fetch::SearchResult*))); TQ_SLOT(slotResult(Tellico::Fetch::SearchResult*)));
connect(f, TQT_SIGNAL(signalDone(Tellico::Fetch::Fetcher::Ptr)), connect(f, TQ_SIGNAL(signalDone(Tellico::Fetch::Fetcher::Ptr)),
TQT_SLOT(slotDone())); TQ_SLOT(slotDone()));
} }
init(); init();
} }
@ -85,11 +85,11 @@ void EntryUpdater::init() {
Kernel::self()->beginCommandGroup(i18n("Update Entries")); Kernel::self()->beginCommandGroup(i18n("Update Entries"));
ProgressItem& item = ProgressManager::self()->newProgressItem(this, label, true /*canCancel*/); ProgressItem& item = ProgressManager::self()->newProgressItem(this, label, true /*canCancel*/);
item.setTotalSteps(m_fetchers.count() * m_origEntryCount); item.setTotalSteps(m_fetchers.count() * m_origEntryCount);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
// done if no fetchers available // done if no fetchers available
if(m_fetchers.isEmpty()) { if(m_fetchers.isEmpty()) {
TQTimer::singleShot(500, this, TQT_SLOT(slotCleanup())); TQTimer::singleShot(500, this, TQ_SLOT(slotCleanup()));
} else { } else {
slotStartNext(); // starts fetching slotStartNext(); // starts fetching
} }
@ -107,7 +107,7 @@ void EntryUpdater::slotStartNext() {
void EntryUpdater::slotDone() { void EntryUpdater::slotDone() {
if(m_cancelled) { if(m_cancelled) {
myLog() << "EntryUpdater::slotDone() - cancelled" << endl; myLog() << "EntryUpdater::slotDone() - cancelled" << endl;
TQTimer::singleShot(500, this, TQT_SLOT(slotCleanup())); TQTimer::singleShot(500, this, TQ_SLOT(slotCleanup()));
return; return;
} }
@ -125,13 +125,13 @@ void EntryUpdater::slotDone() {
m_entriesToUpdate.remove(m_entriesToUpdate.begin()); m_entriesToUpdate.remove(m_entriesToUpdate.begin());
// if there are no more entries, and this is the last fetcher, time to delete // if there are no more entries, and this is the last fetcher, time to delete
if(m_entriesToUpdate.isEmpty()) { if(m_entriesToUpdate.isEmpty()) {
TQTimer::singleShot(500, this, TQT_SLOT(slotCleanup())); TQTimer::singleShot(500, this, TQ_SLOT(slotCleanup()));
return; return;
} }
} }
kapp->processEvents(); kapp->processEvents();
// so the entry updater can clean up a bit // so the entry updater can clean up a bit
TQTimer::singleShot(500, this, TQT_SLOT(slotStartNext())); TQTimer::singleShot(500, this, TQ_SLOT(slotStartNext()));
} }
void EntryUpdater::slotResult(Fetch::SearchResult* result_) { void EntryUpdater::slotResult(Fetch::SearchResult* result_) {

@ -65,9 +65,9 @@ EntryView::EntryView(TQWidget* parent_, const char* name_) : TDEHTMLPart(new Ent
DropHandler* drophandler = new DropHandler(this); DropHandler* drophandler = new DropHandler(this);
view()->installEventFilter(drophandler); view()->installEventFilter(drophandler);
connect(browserExtension(), TQT_SIGNAL(openURLRequest(const KURL&, const KParts::URLArgs&)), connect(browserExtension(), TQ_SIGNAL(openURLRequest(const KURL&, const KParts::URLArgs&)),
TQT_SLOT(slotOpenURL(const KURL&))); TQ_SLOT(slotOpenURL(const KURL&)));
connect(kapp, TQT_SIGNAL(tdedisplayPaletteChanged()), TQT_SLOT(slotResetColors())); connect(kapp, TQ_SIGNAL(tdedisplayPaletteChanged()), TQ_SLOT(slotResetColors()));
} }
EntryView::~EntryView() { EntryView::~EntryView() {
@ -305,7 +305,7 @@ void EntryView::slotOpenURL(const KURL& url_) {
void EntryView::slotReloadEntry() { void EntryView::slotReloadEntry() {
// this slot should only be connected in setXSLTFile() // this slot should only be connected in setXSLTFile()
// must disconnect the signal first, otherwise, get an infinite loop // must disconnect the signal first, otherwise, get an infinite loop
disconnect(TQT_SIGNAL(completed())); disconnect(TQ_SIGNAL(completed()));
closeURL(); // this is needed to stop everything, for some reason closeURL(); // this is needed to stop everything, for some reason
view()->setUpdatesEnabled(true); view()->setUpdatesEnabled(true);
@ -371,7 +371,7 @@ void EntryView::resetColors() {
// don't flicker // don't flicker
view()->setUpdatesEnabled(false); view()->setUpdatesEnabled(false);
openURL(m_tempFile->name()); openURL(m_tempFile->name());
connect(this, TQT_SIGNAL(completed()), TQT_SLOT(slotReloadEntry())); connect(this, TQ_SIGNAL(completed()), TQ_SLOT(slotReloadEntry()));
} }
#include "entryview.moc" #include "entryview.moc"

@ -88,7 +88,7 @@ ExportDialog::ExportDialog(Export::Format format_, Data::CollPtr coll_, TQWidget
} else if(format_ == Export::Alexandria || format_ == Export::PilotDB) { } else if(format_ == Export::Alexandria || format_ == Export::PilotDB) {
bg->setEnabled(false); bg->setEnabled(false);
} }
connect(this, TQT_SIGNAL(okClicked()), TQT_SLOT(slotSaveOptions())); connect(this, TQ_SIGNAL(okClicked()), TQ_SLOT(slotSaveOptions()));
} }
ExportDialog::~ExportDialog() { ExportDialog::~ExportDialog() {

@ -321,10 +321,10 @@ void AmazonFetcher::doSearch() {
// myDebug() << "AmazonFetcher::search() - url: " << newUrl.url() << endl; // myDebug() << "AmazonFetcher::search() - url: " << newUrl.url() << endl;
m_job = TDEIO::get(newUrl, false, false); m_job = TDEIO::get(newUrl, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void AmazonFetcher::stop() { void AmazonFetcher::stop() {
@ -869,8 +869,8 @@ AmazonFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const AmazonFetcher
m_siteCombo->insertItem(i18n("Japan"), JP); m_siteCombo->insertItem(i18n("Japan"), JP);
m_siteCombo->insertItem(i18n("France"), FR); m_siteCombo->insertItem(i18n("France"), FR);
m_siteCombo->insertItem(i18n("Canada"), CA); m_siteCombo->insertItem(i18n("Canada"), CA);
connect(m_siteCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSetModified())); connect(m_siteCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSetModified()));
connect(m_siteCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSiteChanged())); connect(m_siteCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSiteChanged()));
l->addWidget(m_siteCombo, row, 1); l->addWidget(m_siteCombo, row, 1);
TQString w = i18n("Amazon.com provides data from several different localized sites. Choose the one " TQString w = i18n("Amazon.com provides data from several different localized sites. Choose the one "
"you wish to use for this data source."); "you wish to use for this data source.");
@ -885,7 +885,7 @@ AmazonFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const AmazonFetcher
m_imageCombo->insertItem(i18n("Medium Image"), MediumImage); m_imageCombo->insertItem(i18n("Medium Image"), MediumImage);
m_imageCombo->insertItem(i18n("Large Image"), LargeImage); m_imageCombo->insertItem(i18n("Large Image"), LargeImage);
m_imageCombo->insertItem(i18n("No Image"), NoImage); m_imageCombo->insertItem(i18n("No Image"), NoImage);
connect(m_imageCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSetModified())); connect(m_imageCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSetModified()));
l->addWidget(m_imageCombo, row, 1); l->addWidget(m_imageCombo, row, 1);
w = i18n("The cover image may be downloaded as well. However, too many large images in the " w = i18n("The cover image may be downloaded as well. However, too many large images in the "
"collection may degrade performance."); "collection may degrade performance.");
@ -896,7 +896,7 @@ AmazonFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const AmazonFetcher
label = new TQLabel(i18n("&Associate's ID: "), optionsWidget()); label = new TQLabel(i18n("&Associate's ID: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_assocEdit = new KLineEdit(optionsWidget()); m_assocEdit = new KLineEdit(optionsWidget());
connect(m_assocEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_assocEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_assocEdit, row, 1); l->addWidget(m_assocEdit, row, 1);
w = i18n("The associate's id identifies the person accessing the Amazon.com Web Services, and is included " w = i18n("The associate's id identifies the person accessing the Amazon.com Web Services, and is included "
"in any links to the Amazon.com site."); "in any links to the Amazon.com site.");
@ -907,13 +907,13 @@ AmazonFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const AmazonFetcher
label = new TQLabel(i18n("Access key: "), optionsWidget()); label = new TQLabel(i18n("Access key: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_accessEdit = new KLineEdit(optionsWidget()); m_accessEdit = new KLineEdit(optionsWidget());
connect(m_accessEdit, SIGNAL(textChanged(const TQString&)), SLOT(slotSetModified())); connect(m_accessEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_accessEdit, row, 1); l->addWidget(m_accessEdit, row, 1);
label = new TQLabel(i18n("Secret Key: "), optionsWidget()); label = new TQLabel(i18n("Secret Key: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_secretKeyEdit = new KLineEdit(optionsWidget()); m_secretKeyEdit = new KLineEdit(optionsWidget());
connect(m_secretKeyEdit, SIGNAL(textChanged(const TQString&)), SLOT(slotSetModified())); connect(m_secretKeyEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_secretKeyEdit, row, 1); l->addWidget(m_secretKeyEdit, row, 1);
l->setRowStretch(++row, 10); l->setRowStretch(++row, 10);

@ -91,10 +91,10 @@ void AnimeNfoFetcher::search(FetchKey key_, const TQString& value_) {
// myDebug() << "AnimeNfoFetcher::search() - url: " << u.url() << endl; // myDebug() << "AnimeNfoFetcher::search() - url: " << u.url() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void AnimeNfoFetcher::stop() { void AnimeNfoFetcher::stop() {

@ -96,10 +96,10 @@ void ArxivFetcher::doSearch() {
} }
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void ArxivFetcher::stop() { void ArxivFetcher::stop() {

@ -79,10 +79,10 @@ void BibsonomyFetcher::search(FetchKey key_, const TQString& value_) {
} }
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void BibsonomyFetcher::stop() { void BibsonomyFetcher::stop() {

@ -80,10 +80,10 @@ void CitebaseFetcher::search(FetchKey key_, const TQString& value_) {
} }
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void CitebaseFetcher::stop() { void CitebaseFetcher::stop() {

@ -45,7 +45,7 @@ void ConfigWidget::addFieldsWidget(const StringMap& customFields_, const TQStrin
if(fieldsToAdd_.contains(it.key())) { if(fieldsToAdd_.contains(it.key())) {
cb->setChecked(true); cb->setChecked(true);
} }
connect(cb, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetModified())); connect(cb, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetModified()));
} }
TDEAcceleratorManager::manage(this); TDEAcceleratorManager::manage(this);

@ -104,10 +104,10 @@ void CrossRefFetcher::search(FetchKey key_, const TQString& value_) {
} }
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void CrossRefFetcher::stop() { void CrossRefFetcher::stop() {
@ -352,7 +352,7 @@ CrossRefFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const CrossRefFet
TQLabel* label = new TQLabel(i18n("&Username: "), optionsWidget()); TQLabel* label = new TQLabel(i18n("&Username: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_userEdit = new KLineEdit(optionsWidget()); m_userEdit = new KLineEdit(optionsWidget());
connect(m_userEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_userEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_userEdit, row, 1); l->addWidget(m_userEdit, row, 1);
TQString w = i18n("A username and password is required to access the CrossRef service. The password is " TQString w = i18n("A username and password is required to access the CrossRef service. The password is "
"stored as plain text in the Tellico configuration file."); "stored as plain text in the Tellico configuration file.");
@ -363,7 +363,7 @@ CrossRefFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const CrossRefFet
label = new TQLabel(i18n("&Password: "), optionsWidget()); label = new TQLabel(i18n("&Password: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_passEdit = new KLineEdit(optionsWidget()); m_passEdit = new KLineEdit(optionsWidget());
connect(m_passEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_passEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_passEdit, row, 1); l->addWidget(m_passEdit, row, 1);
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
TQWhatsThis::add(m_passEdit, w); TQWhatsThis::add(m_passEdit, w);

@ -128,10 +128,10 @@ void DiscogsFetcher::doSearch() {
// myDebug() << "DiscogsFetcher::search() - url: " << u.url() << endl; // myDebug() << "DiscogsFetcher::search() - url: " << u.url() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void DiscogsFetcher::stop() { void DiscogsFetcher::stop() {
@ -357,7 +357,7 @@ DiscogsFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const DiscogsFetch
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_apiKeyEdit = new KLineEdit(optionsWidget()); m_apiKeyEdit = new KLineEdit(optionsWidget());
connect(m_apiKeyEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_apiKeyEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_apiKeyEdit, row, 1); l->addWidget(m_apiKeyEdit, row, 1);
TQString w = i18n("With your discogs.com account you receive an API key for the usage of their XML-based interface " TQString w = i18n("With your discogs.com account you receive an API key for the usage of their XML-based interface "
"(See http://www.discogs.com/help/api)."); "(See http://www.discogs.com/help/api).");
@ -366,7 +366,7 @@ DiscogsFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const DiscogsFetch
label->setBuddy(m_apiKeyEdit); label->setBuddy(m_apiKeyEdit);
m_fetchImageCheck = new TQCheckBox(i18n("Download cover &image"), optionsWidget()); m_fetchImageCheck = new TQCheckBox(i18n("Download cover &image"), optionsWidget());
connect(m_fetchImageCheck, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetModified())); connect(m_fetchImageCheck, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetModified()));
++row; ++row;
l->addMultiCellWidget(m_fetchImageCheck, row, row, 0, 1); l->addMultiCellWidget(m_fetchImageCheck, row, row, 0, 1);
w = i18n("The cover image may be downloaded as well. However, too many large images in the " w = i18n("The cover image may be downloaded as well. However, too many large images in the "

@ -131,10 +131,10 @@ void EntrezFetcher::search(FetchKey key_, const TQString& value_) {
m_step = Search; m_step = Search;
// myLog() << "EntrezFetcher::doSearch() - url: " << u.url() << endl; // myLog() << "EntrezFetcher::doSearch() - url: " << u.url() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void EntrezFetcher::continueSearch() { void EntrezFetcher::continueSearch() {
@ -256,10 +256,10 @@ void EntrezFetcher::doSummary() {
m_step = Summary; m_step = Summary;
// myLog() << "EntrezFetcher::searchResults() - url: " << u.url() << endl; // myLog() << "EntrezFetcher::searchResults() - url: " << u.url() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void EntrezFetcher::summaryResults() { void EntrezFetcher::summaryResults() {

@ -163,9 +163,9 @@ void ExecExternalFetcher::startSearch(const TQStringList& args_) {
#endif #endif
m_process = new TDEProcess(); m_process = new TDEProcess();
connect(m_process, TQT_SIGNAL(receivedStdout(TDEProcess*, char*, int)), TQT_SLOT(slotData(TDEProcess*, char*, int))); connect(m_process, TQ_SIGNAL(receivedStdout(TDEProcess*, char*, int)), TQ_SLOT(slotData(TDEProcess*, char*, int)));
connect(m_process, TQT_SIGNAL(receivedStderr(TDEProcess*, char*, int)), TQT_SLOT(slotError(TDEProcess*, char*, int))); connect(m_process, TQ_SIGNAL(receivedStderr(TDEProcess*, char*, int)), TQ_SLOT(slotError(TDEProcess*, char*, int)));
connect(m_process, TQT_SIGNAL(processExited(TDEProcess*)), TQT_SLOT(slotProcessExited(TDEProcess*))); connect(m_process, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(slotProcessExited(TDEProcess*)));
*m_process << m_path << args_; *m_process << m_path << args_;
if(!m_process->start(TDEProcess::NotifyOnExit, TDEProcess::AllOutput)) { if(!m_process->start(TDEProcess::NotifyOnExit, TDEProcess::AllOutput)) {
myDebug() << "ExecExternalFetcher::startSearch() - process failed to start" << endl; myDebug() << "ExecExternalFetcher::startSearch() - process failed to start" << endl;
@ -346,7 +346,7 @@ ExecExternalFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const ExecExt
TQLabel* label = new TQLabel(i18n("Collection &type:"), optionsWidget()); TQLabel* label = new TQLabel(i18n("Collection &type:"), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_collCombo = new GUI::CollectionTypeCombo(optionsWidget()); m_collCombo = new GUI::CollectionTypeCombo(optionsWidget());
connect(m_collCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSetModified())); connect(m_collCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSetModified()));
l->addWidget(m_collCombo, row, 1); l->addWidget(m_collCombo, row, 1);
TQString w = i18n("Set the collection type of the data returned from the external application."); TQString w = i18n("Set the collection type of the data returned from the external application.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -362,7 +362,7 @@ ExecExternalFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const ExecExt
m_formatCombo->insertItem(it.data(), it.key()); m_formatCombo->insertItem(it.data(), it.key());
} }
} }
connect(m_formatCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSetModified())); connect(m_formatCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSetModified()));
l->addWidget(m_formatCombo, row, 1); l->addWidget(m_formatCombo, row, 1);
w = i18n("Set the result type of the data returned from the external application."); w = i18n("Set the result type of the data returned from the external application.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -372,7 +372,7 @@ ExecExternalFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const ExecExt
label = new TQLabel(i18n("Application &path: "), optionsWidget()); label = new TQLabel(i18n("Application &path: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_pathEdit = new KURLRequester(optionsWidget()); m_pathEdit = new KURLRequester(optionsWidget());
connect(m_pathEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_pathEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_pathEdit, row, 1); l->addWidget(m_pathEdit, row, 1);
w = i18n("Set the path of the application to run that should output a valid Tellico data file."); w = i18n("Set the path of the application to run that should output a valid Tellico data file.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -410,7 +410,7 @@ ExecExternalFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const ExecExt
cb->setChecked(false); cb->setChecked(false);
le->setEnabled(false); le->setEnabled(false);
} }
connect(cb, TQT_SIGNAL(toggled(bool)), le, TQT_SLOT(setEnabled(bool))); connect(cb, TQ_SIGNAL(toggled(bool)), le, TQ_SLOT(setEnabled(bool)));
TQWhatsThis::add(cb, w); TQWhatsThis::add(cb, w);
TQWhatsThis::add(le, w2); TQWhatsThis::add(le, w2);
} }
@ -435,7 +435,7 @@ ExecExternalFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const ExecExt
m_cbUpdate->setChecked(false); m_cbUpdate->setChecked(false);
m_leUpdate->setEnabled(false); m_leUpdate->setEnabled(false);
} }
connect(m_cbUpdate, TQT_SIGNAL(toggled(bool)), m_leUpdate, TQT_SLOT(setEnabled(bool))); connect(m_cbUpdate, TQ_SIGNAL(toggled(bool)), m_leUpdate, TQ_SLOT(setEnabled(bool)));
l->setRowStretch(++row, 1); l->setRowStretch(++row, 1);

@ -163,10 +163,10 @@ void Manager::startSearch(const TQString& source_, FetchKey key_, const TQString
for(FetcherVec::Iterator it = m_fetchers.begin(); it != m_fetchers.end(); ++it, ++i) { for(FetcherVec::Iterator it = m_fetchers.begin(); it != m_fetchers.end(); ++it, ++i) {
if(source_ == it->source()) { if(source_ == it->source()) {
++m_count; // Fetcher::search() might emit done(), so increment before calling search() ++m_count; // Fetcher::search() might emit done(), so increment before calling search()
connect(it.data(), TQT_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)), connect(it.data(), TQ_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)),
TQT_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*))); TQ_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)));
connect(it.data(), TQT_SIGNAL(signalDone(Tellico::Fetch::Fetcher::Ptr)), connect(it.data(), TQ_SIGNAL(signalDone(Tellico::Fetch::Fetcher::Ptr)),
TQT_SLOT(slotFetcherDone(Tellico::Fetch::Fetcher::Ptr))); TQ_SLOT(slotFetcherDone(Tellico::Fetch::Fetcher::Ptr)));
it->search(key_, value_); it->search(key_, value_);
m_currentFetcherIndex = i; m_currentFetcherIndex = i;
break; break;
@ -183,10 +183,10 @@ void Manager::continueSearch() {
Fetcher::Ptr f = m_fetchers[m_currentFetcherIndex]; Fetcher::Ptr f = m_fetchers[m_currentFetcherIndex];
if(f && f->hasMoreResults()) { if(f && f->hasMoreResults()) {
++m_count; ++m_count;
connect(f, TQT_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)), connect(f, TQ_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)),
TQT_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*))); TQ_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)));
connect(f, TQT_SIGNAL(signalDone(Tellico::Fetch::Fetcher::Ptr)), connect(f, TQ_SIGNAL(signalDone(Tellico::Fetch::Fetcher::Ptr)),
TQT_SLOT(slotFetcherDone(Tellico::Fetch::Fetcher::Ptr))); TQ_SLOT(slotFetcherDone(Tellico::Fetch::Fetcher::Ptr)));
f->continueSearch(); f->continueSearch();
} else { } else {
emit signalDone(); emit signalDone();

@ -229,9 +229,9 @@ void GCstarPluginFetcher::search(FetchKey key_, const TQString& value_) {
} }
m_process = new TDEProcess(); m_process = new TDEProcess();
connect(m_process, TQT_SIGNAL(receivedStdout(TDEProcess*, char*, int)), TQT_SLOT(slotData(TDEProcess*, char*, int))); connect(m_process, TQ_SIGNAL(receivedStdout(TDEProcess*, char*, int)), TQ_SLOT(slotData(TDEProcess*, char*, int)));
connect(m_process, TQT_SIGNAL(receivedStderr(TDEProcess*, char*, int)), TQT_SLOT(slotError(TDEProcess*, char*, int))); connect(m_process, TQ_SIGNAL(receivedStderr(TDEProcess*, char*, int)), TQ_SLOT(slotError(TDEProcess*, char*, int)));
connect(m_process, TQT_SIGNAL(processExited(TDEProcess*)), TQT_SLOT(slotProcessExited(TDEProcess*))); connect(m_process, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(slotProcessExited(TDEProcess*)));
TQStringList args; TQStringList args;
args << gcstar << TQString::fromLatin1("-x") args << gcstar << TQString::fromLatin1("-x")
<< TQString::fromLatin1("--collection") << gcstarCollection << TQString::fromLatin1("--collection") << gcstarCollection
@ -398,8 +398,8 @@ GCstarPluginFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const GCstarP
TQLabel* label = new TQLabel(i18n("Collection &type:"), optionsWidget()); TQLabel* label = new TQLabel(i18n("Collection &type:"), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_collCombo = new GUI::CollectionTypeCombo(optionsWidget()); m_collCombo = new GUI::CollectionTypeCombo(optionsWidget());
connect(m_collCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSetModified())); connect(m_collCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSetModified()));
connect(m_collCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotTypeChanged())); connect(m_collCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotTypeChanged()));
l->addMultiCellWidget(m_collCombo, row, row, 1, 3); l->addMultiCellWidget(m_collCombo, row, row, 1, 3);
TQString w = i18n("Set the collection type of the data returned from the plugin."); TQString w = i18n("Set the collection type of the data returned from the plugin.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -409,8 +409,8 @@ GCstarPluginFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const GCstarP
label = new TQLabel(i18n("&Plugin: "), optionsWidget()); label = new TQLabel(i18n("&Plugin: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_pluginCombo = new GUI::ComboBox(optionsWidget()); m_pluginCombo = new GUI::ComboBox(optionsWidget());
connect(m_pluginCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSetModified())); connect(m_pluginCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSetModified()));
connect(m_pluginCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotPluginChanged())); connect(m_pluginCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotPluginChanged()));
l->addMultiCellWidget(m_pluginCombo, row, row, 1, 3); l->addMultiCellWidget(m_pluginCombo, row, row, 1, 3);
w = i18n("Select the GCstar plugin used for the data source."); w = i18n("Select the GCstar plugin used for the data source.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);

@ -114,10 +114,10 @@ void GoogleScholarFetcher::doSearch() {
// myDebug() << "GoogleScholarFetcher::search() - url: " << u.url() << endl; // myDebug() << "GoogleScholarFetcher::search() - url: " << u.url() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void GoogleScholarFetcher::stop() { void GoogleScholarFetcher::stop() {

@ -110,12 +110,12 @@ void IBSFetcher::search(FetchKey key_, const TQString& value_) {
// myDebug() << "IBSFetcher::search() - url: " << u.url() << endl; // myDebug() << "IBSFetcher::search() - url: " << u.url() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
if(key_ == ISBN) { if(key_ == ISBN) {
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), TQT_SLOT(slotCompleteISBN(TDEIO::Job*))); connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)), TQ_SLOT(slotCompleteISBN(TDEIO::Job*)));
} else { } else {
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), TQT_SLOT(slotComplete(TDEIO::Job*))); connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)), TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
} }

@ -165,12 +165,12 @@ void IMDBFetcher::search(FetchKey key_, const TQString& value_) {
#endif #endif
m_job = TDEIO::get(m_url, false, false); m_job = TDEIO::get(m_url, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
connect(m_job, TQT_SIGNAL(redirection(TDEIO::Job *, const KURL&)), connect(m_job, TQ_SIGNAL(redirection(TDEIO::Job *, const KURL&)),
TQT_SLOT(slotRedirection(TDEIO::Job*, const KURL&))); TQ_SLOT(slotRedirection(TDEIO::Job*, const KURL&)));
} }
void IMDBFetcher::continueSearch() { void IMDBFetcher::continueSearch() {
@ -609,12 +609,12 @@ void IMDBFetcher::parseMultipleNameResults() {
m_redirected = true; m_redirected = true;
m_data.truncate(0); m_data.truncate(0);
m_job = TDEIO::get(m_url, false, false); m_job = TDEIO::get(m_url, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
connect(m_job, TQT_SIGNAL(redirection(TDEIO::Job *, const KURL&)), connect(m_job, TQ_SIGNAL(redirection(TDEIO::Job *, const KURL&)),
TQT_SLOT(slotRedirection(TDEIO::Job*, const KURL&))); TQ_SLOT(slotRedirection(TDEIO::Job*, const KURL&)));
// do not stop() here // do not stop() here
} }
@ -1109,12 +1109,12 @@ void IMDBFetcher::updateEntry(Data::EntryPtr entry_) {
m_url = link; m_url = link;
m_redirected = true; // m_redirected is used as a flag later to tell if we get a single result m_redirected = true; // m_redirected is used as a flag later to tell if we get a single result
m_job = TDEIO::get(m_url, false, false); m_job = TDEIO::get(m_url, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
connect(m_job, TQT_SIGNAL(redirection(TDEIO::Job *, const KURL&)), connect(m_job, TQ_SIGNAL(redirection(TDEIO::Job *, const KURL&)),
TQT_SLOT(slotRedirection(TDEIO::Job*, const KURL&))); TQ_SLOT(slotRedirection(TDEIO::Job*, const KURL&)));
return; return;
} }
// optimistically try searching for title and rely on Collection::sameEntry() to figure things out // optimistically try searching for title and rely on Collection::sameEntry() to figure things out
@ -1139,7 +1139,7 @@ IMDBFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const IMDBFetcher* fe
TQLabel* label = new TQLabel(i18n("Hos&t: "), optionsWidget()); TQLabel* label = new TQLabel(i18n("Hos&t: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_hostEdit = new KLineEdit(optionsWidget()); m_hostEdit = new KLineEdit(optionsWidget());
connect(m_hostEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_hostEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_hostEdit, row, 1); l->addWidget(m_hostEdit, row, 1);
TQString w = i18n("The Internet Movie Database uses several different servers. Choose the one " TQString w = i18n("The Internet Movie Database uses several different servers. Choose the one "
"you wish to use."); "you wish to use.");
@ -1150,7 +1150,7 @@ IMDBFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const IMDBFetcher* fe
label = new TQLabel(i18n("&Maximum cast: "), optionsWidget()); label = new TQLabel(i18n("&Maximum cast: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_numCast = new KIntSpinBox(0, 99, 1, 10, 10, optionsWidget()); m_numCast = new KIntSpinBox(0, 99, 1, 10, 10, optionsWidget());
connect(m_numCast, TQT_SIGNAL(valueChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_numCast, TQ_SIGNAL(valueChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_numCast, row, 1); l->addWidget(m_numCast, row, 1);
w = i18n("The list of cast members may include many people. Set the maximum number returned from the search."); w = i18n("The list of cast members may include many people. Set the maximum number returned from the search.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -1158,7 +1158,7 @@ IMDBFetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const IMDBFetcher* fe
label->setBuddy(m_numCast); label->setBuddy(m_numCast);
m_fetchImageCheck = new TQCheckBox(i18n("Download cover &image"), optionsWidget()); m_fetchImageCheck = new TQCheckBox(i18n("Download cover &image"), optionsWidget());
connect(m_fetchImageCheck, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetModified())); connect(m_fetchImageCheck, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetModified()));
++row; ++row;
l->addMultiCellWidget(m_fetchImageCheck, row, row, 0, 1); l->addMultiCellWidget(m_fetchImageCheck, row, row, 0, 1);
w = i18n("The cover image may be downloaded as well. However, too many large images in the " w = i18n("The cover image may be downloaded as well. However, too many large images in the "

@ -134,10 +134,10 @@ void ISBNdbFetcher::doSearch() {
// myDebug() << "ISBNdbFetcher::search() - url: " << u.url() << endl; // myDebug() << "ISBNdbFetcher::search() - url: " << u.url() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void ISBNdbFetcher::stop() { void ISBNdbFetcher::stop() {

@ -184,10 +184,10 @@ void SRUFetcher::search(FetchKey key_, const TQString& value_) {
// myDebug() << u.prettyURL() << endl; // myDebug() << u.prettyURL() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void SRUFetcher::stop() { void SRUFetcher::stop() {
@ -439,9 +439,9 @@ SRUConfigWidget::SRUConfigWidget(TQWidget* parent_, const SRUFetcher* fetcher_ /
TQLabel* label = new TQLabel(i18n("Hos&t: "), optionsWidget()); TQLabel* label = new TQLabel(i18n("Hos&t: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_hostEdit = new GUI::LineEdit(optionsWidget()); m_hostEdit = new GUI::LineEdit(optionsWidget());
connect(m_hostEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_hostEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
connect(m_hostEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SIGNAL(signalName(const TQString&))); connect(m_hostEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SIGNAL(signalName(const TQString&)));
connect(m_hostEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotCheckHost())); connect(m_hostEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotCheckHost()));
l->addWidget(m_hostEdit, row, 1); l->addWidget(m_hostEdit, row, 1);
TQString w = i18n("Enter the host name of the server."); TQString w = i18n("Enter the host name of the server.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -451,7 +451,7 @@ SRUConfigWidget::SRUConfigWidget(TQWidget* parent_, const SRUFetcher* fetcher_ /
label = new TQLabel(i18n("&Port: "), optionsWidget()); label = new TQLabel(i18n("&Port: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_portSpinBox = new KIntSpinBox(0, 999999, 1, SRU_DEFAULT_PORT, 10, optionsWidget()); m_portSpinBox = new KIntSpinBox(0, 999999, 1, SRU_DEFAULT_PORT, 10, optionsWidget());
connect(m_portSpinBox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotSetModified())); connect(m_portSpinBox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotSetModified()));
l->addWidget(m_portSpinBox, row, 1); l->addWidget(m_portSpinBox, row, 1);
w = i18n("Enter the port number of the server. The default is %1.").arg(SRU_DEFAULT_PORT); w = i18n("Enter the port number of the server. The default is %1.").arg(SRU_DEFAULT_PORT);
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -461,7 +461,7 @@ SRUConfigWidget::SRUConfigWidget(TQWidget* parent_, const SRUFetcher* fetcher_ /
label = new TQLabel(i18n("Path: "), optionsWidget()); label = new TQLabel(i18n("Path: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_pathEdit = new GUI::LineEdit(optionsWidget()); m_pathEdit = new GUI::LineEdit(optionsWidget());
connect(m_pathEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_pathEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_pathEdit, row, 1); l->addWidget(m_pathEdit, row, 1);
w = i18n("Enter the path to the database used by the server."); w = i18n("Enter the path to the database used by the server.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -474,7 +474,7 @@ SRUConfigWidget::SRUConfigWidget(TQWidget* parent_, const SRUFetcher* fetcher_ /
m_formatCombo->insertItem(TQString::fromLatin1("MODS"), TQString::fromLatin1("mods")); m_formatCombo->insertItem(TQString::fromLatin1("MODS"), TQString::fromLatin1("mods"));
m_formatCombo->insertItem(TQString::fromLatin1("MARCXML"), TQString::fromLatin1("marcxml")); m_formatCombo->insertItem(TQString::fromLatin1("MARCXML"), TQString::fromLatin1("marcxml"));
m_formatCombo->insertItem(TQString::fromLatin1("Dublin Core"), TQString::fromLatin1("dc")); m_formatCombo->insertItem(TQString::fromLatin1("Dublin Core"), TQString::fromLatin1("dc"));
connect(m_formatCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotSetModified())); connect(m_formatCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotSetModified()));
l->addWidget(m_formatCombo, row, 1); l->addWidget(m_formatCombo, row, 1);
w = i18n("Enter the result format used by the server."); w = i18n("Enter the result format used by the server.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);

@ -120,10 +120,10 @@ void YahooFetcher::doSearch() {
// myDebug() << "YahooFetcher::search() - url: " << u.url() << endl; // myDebug() << "YahooFetcher::search() - url: " << u.url() << endl;
m_job = TDEIO::get(u, false, false); m_job = TDEIO::get(u, false, false);
connect(m_job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(m_job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job*)), connect(m_job, TQ_SIGNAL(result(TDEIO::Job*)),
TQT_SLOT(slotComplete(TDEIO::Job*))); TQ_SLOT(slotComplete(TDEIO::Job*)));
} }
void YahooFetcher::stop() { void YahooFetcher::stop() {

@ -517,9 +517,9 @@ Z3950Fetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const Z3950Fetcher*
m_usePreset = new TQCheckBox(i18n("Use preset &server:"), optionsWidget()); m_usePreset = new TQCheckBox(i18n("Use preset &server:"), optionsWidget());
l->addWidget(m_usePreset, ++row, 0); l->addWidget(m_usePreset, ++row, 0);
connect(m_usePreset, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotTogglePreset(bool))); connect(m_usePreset, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotTogglePreset(bool)));
m_serverCombo = new GUI::ComboBox(optionsWidget()); m_serverCombo = new GUI::ComboBox(optionsWidget());
connect(m_serverCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotPresetChanged())); connect(m_serverCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotPresetChanged()));
l->addWidget(m_serverCombo, row, 1); l->addWidget(m_serverCombo, row, 1);
++row; ++row;
l->addMultiCellWidget(new KSeparator(optionsWidget()), row, row, 0, 1); l->addMultiCellWidget(new KSeparator(optionsWidget()), row, row, 0, 1);
@ -528,8 +528,8 @@ Z3950Fetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const Z3950Fetcher*
TQLabel* label = new TQLabel(i18n("Hos&t: "), optionsWidget()); TQLabel* label = new TQLabel(i18n("Hos&t: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_hostEdit = new GUI::LineEdit(optionsWidget()); m_hostEdit = new GUI::LineEdit(optionsWidget());
connect(m_hostEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_hostEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
connect(m_hostEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SIGNAL(signalName(const TQString&))); connect(m_hostEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SIGNAL(signalName(const TQString&)));
l->addWidget(m_hostEdit, row, 1); l->addWidget(m_hostEdit, row, 1);
TQString w = i18n("Enter the host name of the server."); TQString w = i18n("Enter the host name of the server.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -539,7 +539,7 @@ Z3950Fetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const Z3950Fetcher*
label = new TQLabel(i18n("&Port: "), optionsWidget()); label = new TQLabel(i18n("&Port: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_portSpinBox = new KIntSpinBox(0, 999999, 1, Z3950_DEFAULT_PORT, 10, optionsWidget()); m_portSpinBox = new KIntSpinBox(0, 999999, 1, Z3950_DEFAULT_PORT, 10, optionsWidget());
connect(m_portSpinBox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotSetModified())); connect(m_portSpinBox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotSetModified()));
l->addWidget(m_portSpinBox, row, 1); l->addWidget(m_portSpinBox, row, 1);
w = i18n("Enter the port number of the server. The default is %1.").arg(Z3950_DEFAULT_PORT); w = i18n("Enter the port number of the server. The default is %1.").arg(Z3950_DEFAULT_PORT);
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -549,7 +549,7 @@ Z3950Fetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const Z3950Fetcher*
label = new TQLabel(i18n("&Database: "), optionsWidget()); label = new TQLabel(i18n("&Database: "), optionsWidget());
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_databaseEdit = new GUI::LineEdit(optionsWidget()); m_databaseEdit = new GUI::LineEdit(optionsWidget());
connect(m_databaseEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_databaseEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_databaseEdit, row, 1); l->addWidget(m_databaseEdit, row, 1);
w = i18n("Enter the database name used by the server."); w = i18n("Enter the database name used by the server.");
TQWhatsThis::add(label, w); TQWhatsThis::add(label, w);
@ -563,7 +563,7 @@ Z3950Fetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const Z3950Fetcher*
m_charSetCombo->insertItem(TQString::fromLatin1("marc8")); m_charSetCombo->insertItem(TQString::fromLatin1("marc8"));
m_charSetCombo->insertItem(TQString::fromLatin1("iso-8859-1")); m_charSetCombo->insertItem(TQString::fromLatin1("iso-8859-1"));
m_charSetCombo->insertItem(TQString::fromLatin1("utf-8")); m_charSetCombo->insertItem(TQString::fromLatin1("utf-8"));
connect(m_charSetCombo, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_charSetCombo, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_charSetCombo, row, 1); l->addWidget(m_charSetCombo, row, 1);
w = i18n("Enter the character set encoding used by the z39.50 server. The most likely choice " w = i18n("Enter the character set encoding used by the z39.50 server. The most likely choice "
"is MARC-8, although ISO-8859-1 is common as well."); "is MARC-8, although ISO-8859-1 is common as well.");
@ -580,7 +580,7 @@ Z3950Fetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const Z3950Fetcher*
m_syntaxCombo->insertItem(TQString::fromLatin1("UNIMARC"), TQString::fromLatin1("unimarc")); m_syntaxCombo->insertItem(TQString::fromLatin1("UNIMARC"), TQString::fromLatin1("unimarc"));
m_syntaxCombo->insertItem(TQString::fromLatin1("USMARC"), TQString::fromLatin1("usmarc")); m_syntaxCombo->insertItem(TQString::fromLatin1("USMARC"), TQString::fromLatin1("usmarc"));
m_syntaxCombo->insertItem(TQString::fromLatin1("GRS-1"), TQString::fromLatin1("grs-1")); m_syntaxCombo->insertItem(TQString::fromLatin1("GRS-1"), TQString::fromLatin1("grs-1"));
connect(m_syntaxCombo, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_syntaxCombo, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_syntaxCombo, row, 1); l->addWidget(m_syntaxCombo, row, 1);
w = i18n("Enter the data format used by the z39.50 server. Tellico will attempt to " w = i18n("Enter the data format used by the z39.50 server. Tellico will attempt to "
"automatically detect the best setting if <i>auto-detect</i> is selected."); "automatically detect the best setting if <i>auto-detect</i> is selected.");
@ -592,7 +592,7 @@ Z3950Fetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const Z3950Fetcher*
l->addWidget(label, ++row, 0); l->addWidget(label, ++row, 0);
m_userEdit = new GUI::LineEdit(optionsWidget()); m_userEdit = new GUI::LineEdit(optionsWidget());
m_userEdit->setHint(i18n("Optional")); m_userEdit->setHint(i18n("Optional"));
connect(m_userEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_userEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_userEdit, row, 1); l->addWidget(m_userEdit, row, 1);
w = i18n("Enter the authentication user name used by the z39.50 database. Most servers " w = i18n("Enter the authentication user name used by the z39.50 database. Most servers "
"do not need one."); "do not need one.");
@ -605,7 +605,7 @@ Z3950Fetcher::ConfigWidget::ConfigWidget(TQWidget* parent_, const Z3950Fetcher*
m_passwordEdit = new GUI::LineEdit(optionsWidget()); m_passwordEdit = new GUI::LineEdit(optionsWidget());
m_passwordEdit->setHint(i18n("Optional")); m_passwordEdit->setHint(i18n("Optional"));
m_passwordEdit->setEchoMode(TQLineEdit::Password); m_passwordEdit->setEchoMode(TQLineEdit::Password);
connect(m_passwordEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotSetModified())); connect(m_passwordEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotSetModified()));
l->addWidget(m_passwordEdit, row, 1); l->addWidget(m_passwordEdit, row, 1);
w = i18n("Enter the authentication password used by the z39.50 database. Most servers " w = i18n("Enter the authentication password used by the z39.50 database. Most servers "
"do not need one. The password will be saved in plain text in the Tellico " "do not need one. The password will be saved in plain text in the Tellico "

@ -107,13 +107,13 @@ FetchDialog::FetchDialog(TQWidget* parent_, const char* name_)
for(Fetch::KeyMap::ConstIterator it = map.begin(); it != map.end(); ++it) { for(Fetch::KeyMap::ConstIterator it = map.begin(); it != map.end(); ++it) {
m_keyCombo->insertItem(it.data(), it.key()); m_keyCombo->insertItem(it.data(), it.key());
} }
connect(m_keyCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotKeyChanged(int))); connect(m_keyCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotKeyChanged(int)));
TQWhatsThis::add(m_keyCombo, i18n("Choose the type of search")); TQWhatsThis::add(m_keyCombo, i18n("Choose the type of search"));
m_searchButton = new KPushButton(box1); m_searchButton = new KPushButton(box1);
m_searchButton->setGuiItem(KGuiItem(i18n(FETCH_STRING_STOP), m_searchButton->setGuiItem(KGuiItem(i18n(FETCH_STRING_STOP),
SmallIconSet(TQString::fromLatin1("cancel")))); SmallIconSet(TQString::fromLatin1("cancel"))));
connect(m_searchButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotSearchClicked())); connect(m_searchButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotSearchClicked()));
TQWhatsThis::add(m_searchButton, i18n("Click to start or stop the search")); TQWhatsThis::add(m_searchButton, i18n("Click to start or stop the search"));
// the search button's text changes from search to stop // the search button's text changes from search to stop
@ -133,12 +133,12 @@ FetchDialog::FetchDialog(TQWidget* parent_, const char* name_)
m_multipleISBN = new TQCheckBox(i18n("&Multiple ISBN/UPC search"), box2); m_multipleISBN = new TQCheckBox(i18n("&Multiple ISBN/UPC search"), box2);
TQWhatsThis::add(m_multipleISBN, i18n("Check this box to search for multiple ISBN or UPC values.")); TQWhatsThis::add(m_multipleISBN, i18n("Check this box to search for multiple ISBN or UPC values."));
connect(m_multipleISBN, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotMultipleISBN(bool))); connect(m_multipleISBN, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotMultipleISBN(bool)));
m_editISBN = new KPushButton(KGuiItem(i18n("Edit List..."), TQString::fromLatin1("text_block")), box2); m_editISBN = new KPushButton(KGuiItem(i18n("Edit List..."), TQString::fromLatin1("text_block")), box2);
m_editISBN->setEnabled(false); m_editISBN->setEnabled(false);
TQWhatsThis::add(m_editISBN, i18n("Click to open a text edit box for entering or editing multiple ISBN values.")); TQWhatsThis::add(m_editISBN, i18n("Click to open a text edit box for entering or editing multiple ISBN values."));
connect(m_editISBN, TQT_SIGNAL(clicked()), TQT_SLOT(slotEditMultipleISBN())); connect(m_editISBN, TQ_SIGNAL(clicked()), TQ_SLOT(slotEditMultipleISBN()));
// add for spacing // add for spacing
box2->setStretchFactor(new TQWidget(box2), 10); box2->setStretchFactor(new TQWidget(box2), 10);
@ -150,7 +150,7 @@ FetchDialog::FetchDialog(TQWidget* parent_, const char* name_)
for(Fetch::FetcherVec::Iterator it = sources.begin(); it != sources.end(); ++it) { for(Fetch::FetcherVec::Iterator it = sources.begin(); it != sources.end(); ++it) {
m_sourceCombo->insertItem(Fetch::Manager::self()->fetcherIcon(it.data()), (*it).source()); m_sourceCombo->insertItem(Fetch::Manager::self()->fetcherIcon(it.data()), (*it).source());
} }
connect(m_sourceCombo, TQT_SIGNAL(activated(const TQString&)), TQT_SLOT(slotSourceChanged(const TQString&))); connect(m_sourceCombo, TQ_SIGNAL(activated(const TQString&)), TQ_SLOT(slotSourceChanged(const TQString&)));
TQWhatsThis::add(m_sourceCombo, i18n("Select the database to search")); TQWhatsThis::add(m_sourceCombo, i18n("Select the database to search"));
TQSplitter* split = new TQSplitter(TQt::Vertical, mainWidget); TQSplitter* split = new TQSplitter(TQt::Vertical, mainWidget);
@ -171,9 +171,9 @@ FetchDialog::FetchDialog(TQWidget* parent_, const char* name_)
m_listView->addColumn(i18n("Source")); m_listView->addColumn(i18n("Source"));
m_listView->viewport()->installEventFilter(this); m_listView->viewport()->installEventFilter(this);
connect(m_listView, TQT_SIGNAL(selectionChanged()), TQT_SLOT(slotShowEntry())); connect(m_listView, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotShowEntry()));
// double clicking should add the entry // double clicking should add the entry
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem*)), TQT_SLOT(slotAddEntry())); connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem*)), TQ_SLOT(slotAddEntry()));
TQWhatsThis::add(m_listView, i18n("As results are found, they are added to this list. Selecting one " TQWhatsThis::add(m_listView, i18n("As results are found, they are added to this list. Selecting one "
"will fetch the complete entry and show it in the view below.")); "will fetch the complete entry and show it in the view below."));
@ -192,16 +192,16 @@ FetchDialog::FetchDialog(TQWidget* parent_, const char* name_)
m_addButton = new KPushButton(i18n("&Add Entry"), box3); m_addButton = new KPushButton(i18n("&Add Entry"), box3);
m_addButton->setEnabled(false); m_addButton->setEnabled(false);
m_addButton->setIconSet(UserIconSet(Kernel::self()->collectionTypeName())); m_addButton->setIconSet(UserIconSet(Kernel::self()->collectionTypeName()));
connect(m_addButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddEntry())); connect(m_addButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotAddEntry()));
TQWhatsThis::add(m_addButton, i18n("Add the selected entry to the current collection")); TQWhatsThis::add(m_addButton, i18n("Add the selected entry to the current collection"));
m_moreButton = new KPushButton(KGuiItem(i18n("Get More Results"), SmallIconSet(TQString::fromLatin1("edit-find"))), box3); m_moreButton = new KPushButton(KGuiItem(i18n("Get More Results"), SmallIconSet(TQString::fromLatin1("edit-find"))), box3);
m_moreButton->setEnabled(false); m_moreButton->setEnabled(false);
connect(m_moreButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotMoreClicked())); connect(m_moreButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotMoreClicked()));
TQWhatsThis::add(m_moreButton, i18n("Fetch more results from the current data source")); TQWhatsThis::add(m_moreButton, i18n("Fetch more results from the current data source"));
KPushButton* clearButton = new KPushButton(KStdGuiItem::clear(), box3); KPushButton* clearButton = new KPushButton(KStdGuiItem::clear(), box3);
connect(clearButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotClearClicked())); connect(clearButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotClearClicked()));
TQWhatsThis::add(clearButton, i18n("Clear all search fields and results")); TQWhatsThis::add(clearButton, i18n("Clear all search fields and results"));
TQHBox* bottombox = new TQHBox(mainWidget, "box"); TQHBox* bottombox = new TQHBox(mainWidget, "box");
@ -218,9 +218,9 @@ FetchDialog::FetchDialog(TQWidget* parent_, const char* name_)
m_statusBar->addWidget(m_progress, 0, true); m_statusBar->addWidget(m_progress, 0, true);
KPushButton* closeButton = new KPushButton(KStdGuiItem::close(), bottombox); KPushButton* closeButton = new KPushButton(KStdGuiItem::close(), bottombox);
connect(closeButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotClose())); connect(closeButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotClose()));
connect(m_timer, TQT_SIGNAL(timeout()), TQT_SLOT(slotMoveProgress())); connect(m_timer, TQ_SIGNAL(timeout()), TQ_SLOT(slotMoveProgress()));
setMinimumWidth(TQMAX(minimumWidth(), FETCH_MIN_WIDTH)); setMinimumWidth(TQMAX(minimumWidth(), FETCH_MIN_WIDTH));
setStatus(i18n("Ready.")); setStatus(i18n("Ready."));
@ -233,19 +233,19 @@ FetchDialog::FetchDialog(TQWidget* parent_, const char* name_)
split->setSizes(splitList); split->setSizes(splitList);
} }
connect(Fetch::Manager::self(), TQT_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)), connect(Fetch::Manager::self(), TQ_SIGNAL(signalResultFound(Tellico::Fetch::SearchResult*)),
TQT_SLOT(slotResultFound(Tellico::Fetch::SearchResult*))); TQ_SLOT(slotResultFound(Tellico::Fetch::SearchResult*)));
connect(Fetch::Manager::self(), TQT_SIGNAL(signalStatus(const TQString&)), connect(Fetch::Manager::self(), TQ_SIGNAL(signalStatus(const TQString&)),
TQT_SLOT(slotStatus(const TQString&))); TQ_SLOT(slotStatus(const TQString&)));
connect(Fetch::Manager::self(), TQT_SIGNAL(signalDone()), connect(Fetch::Manager::self(), TQ_SIGNAL(signalDone()),
TQT_SLOT(slotFetchDone())); TQ_SLOT(slotFetchDone()));
// make sure to delete results afterwards // make sure to delete results afterwards
m_results.setAutoDelete(true); m_results.setAutoDelete(true);
TDEAcceleratorManager::manage(this); TDEAcceleratorManager::manage(this);
// initialize combos // initialize combos
TQTimer::singleShot(0, this, TQT_SLOT(slotInit())); TQTimer::singleShot(0, this, TQ_SLOT(slotInit()));
#ifdef ENABLE_WEBCAM #ifdef ENABLE_WEBCAM
// barcode recognition // barcode recognition
@ -258,8 +258,8 @@ FetchDialog::FetchDialog(TQWidget* parent_, const char* name_)
} else { } else {
m_barcodePreview = 0; m_barcodePreview = 0;
} }
connect( m_barcodeRecognitionThread, TQT_SIGNAL(recognized(TQString)), this, TQT_SLOT(slotBarcodeRecognized(TQString)) ); connect( m_barcodeRecognitionThread, TQ_SIGNAL(recognized(TQString)), this, TQ_SLOT(slotBarcodeRecognized(TQString)) );
connect( m_barcodeRecognitionThread, TQT_SIGNAL(gotImage(TQImage&)), this, TQT_SLOT(slotBarcodeGotImage(TQImage&)) ); connect( m_barcodeRecognitionThread, TQ_SIGNAL(gotImage(TQImage&)), this, TQ_SLOT(slotBarcodeGotImage(TQImage&)) );
m_barcodeRecognitionThread->start(); m_barcodeRecognitionThread->start();
/* //DEBUG /* //DEBUG
TQImage img( "/home/sebastian/white.png", "PNG" ); TQImage img( "/home/sebastian/white.png", "PNG" );
@ -339,7 +339,7 @@ void FetchDialog::slotStatus(const TQString& status_) {
// if the queue was empty, start the timer // if the queue was empty, start the timer
if(m_statusMessages.count() == 1) { if(m_statusMessages.count() == 1) {
// wait 2 seconds // wait 2 seconds
TQTimer::singleShot(2000, this, TQT_SLOT(slotUpdateStatus())); TQTimer::singleShot(2000, this, TQ_SLOT(slotUpdateStatus()));
} }
} }
@ -351,7 +351,7 @@ void FetchDialog::slotUpdateStatus() {
m_statusMessages.pop_front(); m_statusMessages.pop_front();
if(!m_statusMessages.isEmpty()) { if(!m_statusMessages.isEmpty()) {
// wait 2 seconds // wait 2 seconds
TQTimer::singleShot(2000, this, TQT_SLOT(slotUpdateStatus())); TQTimer::singleShot(2000, this, TQ_SLOT(slotUpdateStatus()));
} }
} }
@ -417,7 +417,7 @@ void FetchDialog::slotFetchDone(bool checkISBN /* = true */) {
lay->addWidget(edit); lay->addWidget(edit);
edit->setText(values.join(TQChar('\n'))); edit->setText(values.join(TQChar('\n')));
TQWhatsThis::add(edit, s); TQWhatsThis::add(edit, s);
connect(dlg, TQT_SIGNAL(okClicked()), dlg, TQT_SLOT(deleteLater())); connect(dlg, TQ_SIGNAL(okClicked()), dlg, TQ_SLOT(deleteLater()));
dlg->setMainWidget(box); dlg->setMainWidget(box);
dlg->setMinimumWidth(TQMAX(dlg->minimumWidth(), FETCH_MIN_WIDTH*2/3)); dlg->setMinimumWidth(TQMAX(dlg->minimumWidth(), FETCH_MIN_WIDTH*2/3));
dlg->show(); dlg->show();
@ -556,7 +556,7 @@ void FetchDialog::slotKeyChanged(int idx_) {
m_valueLineEdit->setValidator(new ISBNValidator(this)); m_valueLineEdit->setValidator(new ISBNValidator(this));
} else { } else {
UPCValidator* upc = new UPCValidator(this); UPCValidator* upc = new UPCValidator(this);
connect(upc, TQT_SIGNAL(signalISBN()), TQT_SLOT(slotUPC2ISBN())); connect(upc, TQ_SIGNAL(signalISBN()), TQ_SLOT(slotUPC2ISBN()));
m_valueLineEdit->setValidator(upc); m_valueLineEdit->setValidator(upc);
// only want to convert to ISBN if ISBN is accepted by the fetcher // only want to convert to ISBN if ISBN is accepted by the fetcher
Fetch::KeyMap map = Fetch::Manager::self()->keyMap(m_sourceCombo->currentText()); Fetch::KeyMap map = Fetch::Manager::self()->keyMap(m_sourceCombo->currentText());
@ -610,7 +610,7 @@ void FetchDialog::slotEditMultipleISBN() {
KPushButton* fromFileBtn = new KPushButton(SmallIconSet(TQString::fromLatin1("document-open")), KPushButton* fromFileBtn = new KPushButton(SmallIconSet(TQString::fromLatin1("document-open")),
i18n("&Load From File..."), box); i18n("&Load From File..."), box);
TQWhatsThis::add(fromFileBtn, i18n("<qt>Load the list from a text file.</qt>")); TQWhatsThis::add(fromFileBtn, i18n("<qt>Load the list from a text file.</qt>"));
connect(fromFileBtn, TQT_SIGNAL(clicked()), TQT_SLOT(slotLoadISBNList())); connect(fromFileBtn, TQ_SIGNAL(clicked()), TQ_SLOT(slotLoadISBNList()));
dlg.setMainWidget(box); dlg.setMainWidget(box);
dlg.setMinimumWidth(TQMAX(dlg.minimumWidth(), FETCH_MIN_WIDTH*2/3)); dlg.setMinimumWidth(TQMAX(dlg.minimumWidth(), FETCH_MIN_WIDTH*2/3));

@ -88,7 +88,7 @@ void FetcherConfigDialog::init(Fetch::Type type_) {
m_nameEdit->setFocus(); m_nameEdit->setFocus();
TQWhatsThis::add(m_nameEdit, w); TQWhatsThis::add(m_nameEdit, w);
label->setBuddy(m_nameEdit); label->setBuddy(m_nameEdit);
connect(m_nameEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotNameChanged(const TQString&))); connect(m_nameEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotNameChanged(const TQString&)));
if(m_newSource) { if(m_newSource) {
label = new TQLabel(i18n("Source &type: "), widget); label = new TQLabel(i18n("Source &type: "), widget);
@ -121,7 +121,7 @@ void FetcherConfigDialog::init(Fetch::Type type_) {
if(m_newSource) { if(m_newSource) {
m_stack = new TQWidgetStack(widget); m_stack = new TQWidgetStack(widget);
vlay2->addWidget(m_stack); vlay2->addWidget(m_stack);
connect(m_typeCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotNewSourceSelected(int))); connect(m_typeCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotNewSourceSelected(int)));
int z3950_idx = 0; int z3950_idx = 0;
const Fetch::TypePairList typeList = Fetch::Manager::self()->typeList(); const Fetch::TypePairList typeList = Fetch::Manager::self()->typeList();
@ -141,7 +141,7 @@ void FetcherConfigDialog::init(Fetch::Type type_) {
// just add config widget and reparent // just add config widget and reparent
m_configWidget->reparent(widget, TQPoint()); m_configWidget->reparent(widget, TQPoint());
vlay2->addWidget(m_configWidget); vlay2->addWidget(m_configWidget);
connect(m_configWidget, TQT_SIGNAL(signalName(const TQString&)), TQT_SLOT(slotPossibleNewName(const TQString&))); connect(m_configWidget, TQ_SIGNAL(signalName(const TQString&)), TQ_SLOT(slotPossibleNewName(const TQString&)));
} }
setMainWidget(widget); setMainWidget(widget);
@ -200,7 +200,7 @@ void FetcherConfigDialog::slotNewSourceSelected(int idx_) {
slotNewSourceSelected(0); slotNewSourceSelected(0);
return; return;
} }
connect(cw, TQT_SIGNAL(signalName(const TQString&)), TQT_SLOT(slotPossibleNewName(const TQString&))); connect(cw, TQ_SIGNAL(signalName(const TQString&)), TQ_SLOT(slotPossibleNewName(const TQString&)));
m_configWidgets.insert(idx_, cw); m_configWidgets.insert(idx_, cw);
m_stack->addWidget(cw); m_stack->addWidget(cw);
m_stack->raiseWidget(cw); m_stack->raiseWidget(cw);

@ -39,7 +39,7 @@ class FileHandler::ItemDeleter : public TQObject {
public: public:
ItemDeleter(TDEIO::Job* job, KFileItem* item) : TQObject(), m_job(job), m_item(item) { ItemDeleter(TDEIO::Job* job, KFileItem* item) : TQObject(), m_job(job), m_item(item) {
FileHandler::s_deleterList.append(this); FileHandler::s_deleterList.append(this);
connect(job, TQT_SIGNAL(result(TDEIO::Job*)), TQT_SLOT(deleteLater())); connect(job, TQ_SIGNAL(result(TDEIO::Job*)), TQ_SLOT(deleteLater()));
} }
~ItemDeleter() { ~ItemDeleter() {
FileHandler::s_deleterList.removeRef(this); FileHandler::s_deleterList.removeRef(this);

@ -78,18 +78,18 @@ void FilterRuleWidget::initWidget() {
setSpacing(4); setSpacing(4);
m_ruleField = new KComboBox(this); m_ruleField = new KComboBox(this);
connect(m_ruleField, TQT_SIGNAL(activated(int)), TQT_SIGNAL(signalModified())); connect(m_ruleField, TQ_SIGNAL(activated(int)), TQ_SIGNAL(signalModified()));
connect(m_ruleField, TQT_SIGNAL(activated(int)), TQT_SLOT(slotRuleFieldChanged(int))); connect(m_ruleField, TQ_SIGNAL(activated(int)), TQ_SLOT(slotRuleFieldChanged(int)));
m_ruleFunc = new KComboBox(this); m_ruleFunc = new KComboBox(this);
connect(m_ruleFunc, TQT_SIGNAL(activated(int)), TQT_SIGNAL(signalModified())); connect(m_ruleFunc, TQ_SIGNAL(activated(int)), TQ_SIGNAL(signalModified()));
m_ruleValue = new KLineEdit(this); m_ruleValue = new KLineEdit(this);
connect(m_ruleValue, TQT_SIGNAL(textChanged(const TQString&)), TQT_SIGNAL(signalModified())); connect(m_ruleValue, TQ_SIGNAL(textChanged(const TQString&)), TQ_SIGNAL(signalModified()));
if(!TDETrader::self()->query(TQString::fromLatin1("KRegExpEditor/KRegExpEditor")).isEmpty()) { if(!TDETrader::self()->query(TQString::fromLatin1("KRegExpEditor/KRegExpEditor")).isEmpty()) {
m_editRegExp = new KPushButton(i18n("Edit..."), this); m_editRegExp = new KPushButton(i18n("Edit..."), this);
connect(m_editRegExp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotEditRegExp())); connect(m_editRegExp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEditRegExp()));
connect(m_ruleFunc, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotRuleFunctionChanged(int))); connect(m_ruleFunc, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotRuleFunctionChanged(int)));
slotRuleFunctionChanged(m_ruleFunc->currentItem()); slotRuleFunctionChanged(m_ruleFunc->currentItem());
} }
@ -101,10 +101,10 @@ void FilterRuleWidget::initWidget() {
m_ruleFunc->insertStringList(m_ruleFuncList); m_ruleFunc->insertStringList(m_ruleFuncList);
// m_ruleFunc->adjustSize(); // m_ruleFunc->adjustSize();
// connect(m_ruleField, TQT_SIGNAL(textChanged(const TQString &)), // connect(m_ruleField, TQ_SIGNAL(textChanged(const TQString &)),
// this, TQT_SIGNAL(fieldChanged(const TQString &))); // this, TQ_SIGNAL(fieldChanged(const TQString &)));
// connect(m_ruleValue, TQT_SIGNAL(textChanged(const TQString &)), // connect(m_ruleValue, TQ_SIGNAL(textChanged(const TQString &)),
// this, TQT_SIGNAL(contentsChanged(const TQString &))); // this, TQ_SIGNAL(contentsChanged(const TQString &)));
} }
void FilterRuleWidget::slotEditRegExp() { void FilterRuleWidget::slotEditRegExp() {
@ -255,7 +255,7 @@ void FilterRuleWidgetLister::setFocus() {
TQWidget* FilterRuleWidgetLister::createWidget(TQWidget* parent_) { TQWidget* FilterRuleWidgetLister::createWidget(TQWidget* parent_) {
TQWidget* w = new FilterRuleWidget(static_cast<Tellico::FilterRule*>(0), parent_); TQWidget* w = new FilterRuleWidget(static_cast<Tellico::FilterRule*>(0), parent_);
connect(w, TQT_SIGNAL(signalModified()), TQT_SIGNAL(signalModified())); connect(w, TQ_SIGNAL(signalModified()), TQ_SIGNAL(signalModified()));
return w; return w;
} }
@ -300,11 +300,11 @@ void FilterDialog::init() {
m_matchAll = new TQRadioButton(i18n("Match a&ll of the following"), bg); m_matchAll = new TQRadioButton(i18n("Match a&ll of the following"), bg);
m_matchAny = new TQRadioButton(i18n("Match an&y of the following"), bg); m_matchAny = new TQRadioButton(i18n("Match an&y of the following"), bg);
m_matchAll->setChecked(true); m_matchAll->setChecked(true);
connect(bg, TQT_SIGNAL(clicked(int)), TQT_SLOT(slotFilterChanged())); connect(bg, TQ_SIGNAL(clicked(int)), TQ_SLOT(slotFilterChanged()));
m_ruleLister = new FilterRuleWidgetLister(m_matchGroup); m_ruleLister = new FilterRuleWidgetLister(m_matchGroup);
connect(m_ruleLister, TQT_SIGNAL(widgetRemoved()), TQT_SLOT(slotShrink())); connect(m_ruleLister, TQ_SIGNAL(widgetRemoved()), TQ_SLOT(slotShrink()));
connect(m_ruleLister, TQT_SIGNAL(signalModified()), TQT_SLOT(slotFilterChanged())); connect(m_ruleLister, TQ_SIGNAL(signalModified()), TQ_SLOT(slotFilterChanged()));
m_ruleLister->setFocus(); m_ruleLister->setFocus();
TQHBoxLayout* blay = new TQHBoxLayout(topLayout); TQHBoxLayout* blay = new TQHBoxLayout(topLayout);
@ -312,14 +312,14 @@ void FilterDialog::init() {
m_filterName = new KLineEdit(page); m_filterName = new KLineEdit(page);
blay->addWidget(m_filterName); blay->addWidget(m_filterName);
connect(m_filterName, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotFilterChanged())); connect(m_filterName, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotFilterChanged()));
// only when creating a new filter can it be saved // only when creating a new filter can it be saved
if(m_mode == CreateFilter) { if(m_mode == CreateFilter) {
m_saveFilter = new KPushButton(SmallIconSet(TQString::fromLatin1("filter")), i18n("&Save Filter"), page); m_saveFilter = new KPushButton(SmallIconSet(TQString::fromLatin1("filter")), i18n("&Save Filter"), page);
blay->addWidget(m_saveFilter); blay->addWidget(m_saveFilter);
m_saveFilter->setEnabled(false); m_saveFilter->setEnabled(false);
connect(m_saveFilter, TQT_SIGNAL(clicked()), TQT_SLOT(slotSaveFilter())); connect(m_saveFilter, TQ_SIGNAL(clicked()), TQ_SLOT(slotSaveFilter()));
enableButtonApply(false); enableButtonApply(false);
} }
enableButtonOK(false); // disable at start enableButtonOK(false); // disable at start

@ -38,8 +38,8 @@ FilterView::FilterView(TQWidget* parent_, const char* name_) : GUI::ListView(par
setTreeStepSize(15); setTreeStepSize(15);
setFullWidth(true); setFullWidth(true);
connect(this, TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)), connect(this, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
TQT_SLOT(contextMenuRequested(TQListViewItem*, const TQPoint&, int))); TQ_SLOT(contextMenuRequested(TQListViewItem*, const TQPoint&, int)));
} }
bool FilterView::isSelectable(GUI::ListViewItem* item_) const { bool FilterView::isSelectable(GUI::ListViewItem* item_) const {
@ -65,9 +65,9 @@ void FilterView::contextMenuRequested(TQListViewItem* item_, const TQPoint& poin
if(item->isFilterItem()) { if(item->isFilterItem()) {
TDEPopupMenu menu(this); TDEPopupMenu menu(this);
menu.insertItem(SmallIconSet(TQString::fromLatin1("filter")), menu.insertItem(SmallIconSet(TQString::fromLatin1("filter")),
i18n("Modify Filter"), this, TQT_SLOT(slotModifyFilter())); i18n("Modify Filter"), this, TQ_SLOT(slotModifyFilter()));
menu.insertItem(SmallIconSet(TQString::fromLatin1("edit-delete")), menu.insertItem(SmallIconSet(TQString::fromLatin1("edit-delete")),
i18n("Delete Filter"), this, TQT_SLOT(slotDeleteFilter())); i18n("Delete Filter"), this, TQ_SLOT(slotDeleteFilter()));
menu.exec(point_); menu.exec(point_);
} }
} }

@ -48,14 +48,14 @@ GroupView::GroupView(TQWidget* parent_, const char* name_/*=0*/)
setTreeStepSize(15); setTreeStepSize(15);
setFullWidth(true); setFullWidth(true);
connect(this, TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)), connect(this, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
TQT_SLOT(contextMenuRequested(TQListViewItem*, const TQPoint&, int))); TQ_SLOT(contextMenuRequested(TQListViewItem*, const TQPoint&, int)));
connect(this, TQT_SIGNAL(expanded(TQListViewItem*)), connect(this, TQ_SIGNAL(expanded(TQListViewItem*)),
TQT_SLOT(slotExpanded(TQListViewItem*))); TQ_SLOT(slotExpanded(TQListViewItem*)));
connect(this, TQT_SIGNAL(collapsed(TQListViewItem*)), connect(this, TQ_SIGNAL(collapsed(TQListViewItem*)),
TQT_SLOT(slotCollapsed(TQListViewItem*))); TQ_SLOT(slotCollapsed(TQListViewItem*)));
m_groupOpenPixmap = SmallIcon(TQString::fromLatin1("folder_open")); m_groupOpenPixmap = SmallIcon(TQString::fromLatin1("folder_open"));
m_groupClosedPixmap = SmallIcon(TQString::fromLatin1("folder")); m_groupClosedPixmap = SmallIcon(TQString::fromLatin1("folder"));
@ -249,11 +249,11 @@ void GroupView::contextMenuRequested(TQListViewItem* item_, const TQPoint& point
GUI::ListViewItem* item = static_cast<GUI::ListViewItem*>(item_); GUI::ListViewItem* item = static_cast<GUI::ListViewItem*>(item_);
if(item->isEntryGroupItem()) { if(item->isEntryGroupItem()) {
menu.insertItem(SmallIconSet(TQString::fromLatin1("2downarrow")), menu.insertItem(SmallIconSet(TQString::fromLatin1("2downarrow")),
i18n("Expand All Groups"), this, TQT_SLOT(slotExpandAll())); i18n("Expand All Groups"), this, TQ_SLOT(slotExpandAll()));
menu.insertItem(SmallIconSet(TQString::fromLatin1("2uparrow")), menu.insertItem(SmallIconSet(TQString::fromLatin1("2uparrow")),
i18n("Collapse All Groups"), this, TQT_SLOT(slotCollapseAll())); i18n("Collapse All Groups"), this, TQ_SLOT(slotCollapseAll()));
menu.insertItem(SmallIconSet(TQString::fromLatin1("filter")), menu.insertItem(SmallIconSet(TQString::fromLatin1("filter")),
i18n("Filter by Group"), this, TQT_SLOT(slotFilterGroup())); i18n("Filter by Group"), this, TQ_SLOT(slotFilterGroup()));
} else if(item->isEntryItem()) { } else if(item->isEntryItem()) {
Controller::self()->plugEntryActions(&menu); Controller::self()->plugEntryActions(&menu);
} }

@ -25,7 +25,7 @@ BoolFieldWidget::BoolFieldWidget(Data::FieldPtr field_, TQWidget* parent_, const
: FieldWidget(field_, parent_, name_) { : FieldWidget(field_, parent_, name_) {
m_checkBox = new TQCheckBox(this); m_checkBox = new TQCheckBox(this);
connect(m_checkBox, TQT_SIGNAL(clicked()), TQT_SIGNAL(modified())); connect(m_checkBox, TQ_SIGNAL(clicked()), TQ_SIGNAL(modified()));
registerWidget(); registerWidget();
} }

@ -25,7 +25,7 @@ ChoiceFieldWidget::ChoiceFieldWidget(Data::FieldPtr field_, TQWidget* parent_, c
: FieldWidget(field_, parent_, name_), m_comboBox(0) { : FieldWidget(field_, parent_, name_), m_comboBox(0) {
m_comboBox = new KComboBox(this); m_comboBox = new KComboBox(this);
connect(m_comboBox, TQT_SIGNAL(activated(int)), TQT_SIGNAL(modified())); connect(m_comboBox, TQ_SIGNAL(activated(int)), TQ_SIGNAL(modified()));
// always have empty choice // always have empty choice
m_comboBox->insertItem(TQString()); m_comboBox->insertItem(TQString());
m_comboBox->insertStringList(field_->allowed()); m_comboBox->insertStringList(field_->allowed());

@ -21,7 +21,7 @@ DateFieldWidget::DateFieldWidget(Data::FieldPtr field_, TQWidget* parent_, const
: FieldWidget(field_, parent_, name_) { : FieldWidget(field_, parent_, name_) {
m_widget = new DateWidget(this); m_widget = new DateWidget(this);
connect(m_widget, TQT_SIGNAL(signalModified()), TQT_SIGNAL(modified())); connect(m_widget, TQ_SIGNAL(signalModified()), TQ_SIGNAL(modified()));
registerWidget(); registerWidget();
} }

@ -66,13 +66,13 @@ DateWidget::DateWidget(TQWidget* parent_, const char* name_) : TQWidget(parent_,
locale->calendar()->maxValidYear(), this); locale->calendar()->maxValidYear(), this);
l->addWidget(m_yearSpin, 1); l->addWidget(m_yearSpin, 1);
connect(m_daySpin, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotDateChanged())); connect(m_daySpin, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotDateChanged()));
connect(m_monthCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotDateChanged())); connect(m_monthCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotDateChanged()));
connect(m_yearSpin, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotDateChanged())); connect(m_yearSpin, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotDateChanged()));
m_dateButton = new KPushButton(this); m_dateButton = new KPushButton(this);
m_dateButton->setIconSet(SmallIconSet(TQString::fromLatin1("date"))); m_dateButton->setIconSet(SmallIconSet(TQString::fromLatin1("date")));
connect(m_dateButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotShowPicker())); connect(m_dateButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotShowPicker()));
l->addWidget(m_dateButton, 0); l->addWidget(m_dateButton, 0);
m_frame = new TQVBox(0, 0, WType_Popup); m_frame = new TQVBox(0, 0, WType_Popup);
@ -81,8 +81,8 @@ DateWidget::DateWidget(TQWidget* parent_, const char* name_) : TQWidget(parent_,
m_frame->hide(); m_frame->hide();
m_picker = new KDatePicker(m_frame, 0); // must include name to get correct constructor m_picker = new KDatePicker(m_frame, 0); // must include name to get correct constructor
connect(m_picker, TQT_SIGNAL(dateEntered(TQDate)), TQT_SLOT(slotDateEntered(TQDate))); connect(m_picker, TQ_SIGNAL(dateEntered(TQDate)), TQ_SLOT(slotDateEntered(TQDate)));
connect(m_picker, TQT_SIGNAL(dateSelected(TQDate)), TQT_SLOT(slotDateSelected(TQDate))); connect(m_picker, TQ_SIGNAL(dateSelected(TQDate)), TQ_SLOT(slotDateSelected(TQDate)));
} }
void DateWidget::slotDateChanged() { void DateWidget::slotDateChanged() {

@ -121,12 +121,12 @@ FieldWidget::FieldWidget(Data::FieldPtr field_, TQWidget* parent_, const char* n
m_editMultiple = new TQCheckBox(this); m_editMultiple = new TQCheckBox(this);
m_editMultiple->setChecked(true); m_editMultiple->setChecked(true);
m_editMultiple->setFixedWidth(m_editMultiple->sizeHint().width()); // don't let it have any extra space m_editMultiple->setFixedWidth(m_editMultiple->sizeHint().width()); // don't let it have any extra space
connect(m_editMultiple, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setEnabled(bool))); connect(m_editMultiple, TQ_SIGNAL(toggled(bool)), TQ_SLOT(setEnabled(bool)));
l->addWidget(m_editMultiple); l->addWidget(m_editMultiple);
TQWhatsThis::add(this, field_->description()); TQWhatsThis::add(this, field_->description());
// after letting the subclass get created, insert default value // after letting the subclass get created, insert default value
TQTimer::singleShot(0, this, TQT_SLOT(insertDefault())); TQTimer::singleShot(0, this, TQ_SLOT(insertDefault()));
} }
void FieldWidget::insertDefault() { void FieldWidget::insertDefault() {
@ -166,10 +166,10 @@ void FieldWidget::editMultiple(bool show_) {
// FIXME: maybe modified should only be signaled when the button is toggle on // FIXME: maybe modified should only be signaled when the button is toggle on
if(show_) { if(show_) {
m_editMultiple->show(); m_editMultiple->show();
connect(m_editMultiple, TQT_SIGNAL(clicked()), this, TQT_SIGNAL(modified())); connect(m_editMultiple, TQ_SIGNAL(clicked()), this, TQ_SIGNAL(modified()));
} else { } else {
m_editMultiple->hide(); m_editMultiple->hide();
disconnect(m_editMultiple, TQT_SIGNAL(clicked()), this, TQT_SIGNAL(modified())); disconnect(m_editMultiple, TQ_SIGNAL(clicked()), this, TQ_SIGNAL(modified()));
} }
// the widget length needs to be updated since it gets shorter // the widget length needs to be updated since it gets shorter
widget()->updateGeometry(); widget()->updateGeometry();

@ -23,7 +23,7 @@ ImageFieldWidget::ImageFieldWidget(Data::FieldPtr field_, TQWidget* parent_, con
m_widget = new ImageWidget(this); m_widget = new ImageWidget(this);
m_widget->setLinkOnlyChecked(field_->property(TQString::fromLatin1("link")) == Latin1Literal("true")); m_widget->setLinkOnlyChecked(field_->property(TQString::fromLatin1("link")) == Latin1Literal("true"));
connect(m_widget, TQT_SIGNAL(signalModified()), TQT_SIGNAL(modified())); connect(m_widget, TQ_SIGNAL(signalModified()), TQ_SIGNAL(modified()));
registerWidget(); registerWidget();
} }

@ -54,14 +54,14 @@ ImageWidget::ImageWidget(TQWidget* parent_, const char* name_) : TQWidget(parent
boxLayout->addStretch(1); boxLayout->addStretch(1);
KButtonBox* box = new KButtonBox(this,TQt::Vertical); KButtonBox* box = new KButtonBox(this,TQt::Vertical);
box->addButton(i18n("Select Image..."), this, TQT_SLOT(slotGetImage())); box->addButton(i18n("Select Image..."), this, TQ_SLOT(slotGetImage()));
box->addButton(i18n("Clear"), this, TQT_SLOT(slotClear())); box->addButton(i18n("Clear"), this, TQ_SLOT(slotClear()));
box->layout(); box->layout();
boxLayout->addWidget(box); boxLayout->addWidget(box);
boxLayout->addSpacing(8); boxLayout->addSpacing(8);
m_cbLinkOnly = new TQCheckBox(i18n("Save link only"), this); m_cbLinkOnly = new TQCheckBox(i18n("Save link only"), this);
connect(m_cbLinkOnly, TQT_SIGNAL(clicked()), TQT_SLOT(slotLinkOnlyClicked())); connect(m_cbLinkOnly, TQ_SIGNAL(clicked()), TQ_SLOT(slotLinkOnlyClicked()));
boxLayout->addWidget(m_cbLinkOnly); boxLayout->addWidget(m_cbLinkOnly);
boxLayout->addStretch(1); boxLayout->addStretch(1);

@ -71,12 +71,12 @@ KWidgetLister::KWidgetLister( int minWidgets, int maxWidgets, TQWidget *parent,
mButtonBox->setStretchFactor( mBtnClear, 0 ); mButtonBox->setStretchFactor( mBtnClear, 0 );
//---------- connect everything //---------- connect everything
connect( mBtnMore, TQT_SIGNAL(clicked()), connect( mBtnMore, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotMore()) ); this, TQ_SLOT(slotMore()) );
connect( mBtnFewer, TQT_SIGNAL(clicked()), connect( mBtnFewer, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotFewer()) ); this, TQ_SLOT(slotFewer()) );
connect( mBtnClear, TQT_SIGNAL(clicked()), connect( mBtnClear, TQ_SIGNAL(clicked()),
this, TQT_SLOT(slotClear()) ); this, TQ_SLOT(slotClear()) );
enableControls(); enableControls();
} }

@ -28,7 +28,7 @@ LineEdit::LineEdit(TQWidget* parent_, const char* name_) : KLineEdit(parent_, na
, m_allowSpellCheck(false) , m_allowSpellCheck(false)
, m_enableSpellCheck(true) , m_enableSpellCheck(true)
, m_spell(0) { , m_spell(0) {
m_spellAction = KStdAction::spelling(this, TQT_SLOT(slotCheckSpelling()), new TDEActionCollection(this)); m_spellAction = KStdAction::spelling(this, TQ_SLOT(slotCheckSpelling()), new TDEActionCollection(this));
} }
void LineEdit::clear() { void LineEdit::clear() {
@ -110,19 +110,19 @@ void LineEdit::slotCheckSpelling() {
delete m_spell; delete m_spell;
// re-use the action string to get translations // re-use the action string to get translations
m_spell = new KSpell(this, m_spellAction->text(), m_spell = new KSpell(this, m_spellAction->text(),
this, TQT_SLOT(slotSpellCheckReady(KSpell*)), 0, true, true); this, TQ_SLOT(slotSpellCheckReady(KSpell*)), 0, true, true);
connect(m_spell, TQT_SIGNAL(death()), connect(m_spell, TQ_SIGNAL(death()),
TQT_SLOT(spellCheckerFinished())); TQ_SLOT(spellCheckerFinished()));
connect(m_spell, TQT_SIGNAL(misspelling( const TQString &, const TQStringList &, unsigned int)), connect(m_spell, TQ_SIGNAL(misspelling( const TQString &, const TQStringList &, unsigned int)),
TQT_SLOT(spellCheckerMisspelling( const TQString &, const TQStringList &, unsigned int))); TQ_SLOT(spellCheckerMisspelling( const TQString &, const TQStringList &, unsigned int)));
connect(m_spell, TQT_SIGNAL(corrected(const TQString &, const TQString &, unsigned int)), connect(m_spell, TQ_SIGNAL(corrected(const TQString &, const TQString &, unsigned int)),
TQT_SLOT(spellCheckerCorrected(const TQString &, const TQString &, unsigned int))); TQ_SLOT(spellCheckerCorrected(const TQString &, const TQString &, unsigned int)));
} }
void LineEdit::slotSpellCheckReady(KSpell* spell) { void LineEdit::slotSpellCheckReady(KSpell* spell) {
spell->check(text()); spell->check(text());
connect(spell, TQT_SIGNAL(done(const TQString&)), TQT_SLOT(slotSpellCheckDone(const TQString&))); connect(spell, TQ_SIGNAL(done(const TQString&)), TQ_SLOT(slotSpellCheckDone(const TQString&)));
} }
void LineEdit::slotSpellCheckDone(const TQString& newText) { void LineEdit::slotSpellCheckDone(const TQString& newText) {

@ -27,7 +27,7 @@ LineFieldWidget::LineFieldWidget(Data::FieldPtr field_, TQWidget* parent_, const
m_lineEdit = new GUI::LineEdit(this); m_lineEdit = new GUI::LineEdit(this);
m_lineEdit->setAllowSpellCheck(true); m_lineEdit->setAllowSpellCheck(true);
m_lineEdit->setEnableSpellCheck(field_->formatFlag() != Data::Field::FormatName); m_lineEdit->setEnableSpellCheck(field_->formatFlag() != Data::Field::FormatName);
connect(m_lineEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SIGNAL(modified())); connect(m_lineEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SIGNAL(modified()));
registerWidget(); registerWidget();

@ -28,16 +28,16 @@ using Tellico::GUI::ListViewItem;
ListView::ListView(TQWidget* parent_, const char* name_) : TDEListView(parent_, name_/*=0*/), ListView::ListView(TQWidget* parent_, const char* name_) : TDEListView(parent_, name_/*=0*/),
m_sortStyle(SortByText), m_isClear(true) { m_sortStyle(SortByText), m_isClear(true) {
setSelectionMode(TQListView::Extended); setSelectionMode(TQListView::Extended);
connect(this, TQT_SIGNAL(selectionChanged()), connect(this, TQ_SIGNAL(selectionChanged()),
TQT_SLOT(slotSelectionChanged())); TQ_SLOT(slotSelectionChanged()));
connect(this, TQT_SIGNAL(doubleClicked(TQListViewItem*)), connect(this, TQ_SIGNAL(doubleClicked(TQListViewItem*)),
TQT_SLOT(slotDoubleClicked(TQListViewItem*))); TQ_SLOT(slotDoubleClicked(TQListViewItem*)));
#if !KDE_IS_VERSION(3,3,90) #if !KDE_IS_VERSION(3,3,90)
m_shadeSortColumn = false; m_shadeSortColumn = false;
// call it once to initialize // call it once to initialize
slotUpdateColors(); slotUpdateColors();
#endif #endif
connect(kapp, TQT_SIGNAL(tdedisplayPaletteChanged()), TQT_SLOT(slotUpdateColors())); connect(kapp, TQ_SIGNAL(tdedisplayPaletteChanged()), TQ_SLOT(slotUpdateColors()));
m_comparisons.setAutoDelete(true); m_comparisons.setAutoDelete(true);
} }

@ -36,8 +36,8 @@ NumberFieldWidget::NumberFieldWidget(Data::FieldPtr field_, TQWidget* parent_, c
void NumberFieldWidget::initLineEdit() { void NumberFieldWidget::initLineEdit() {
m_lineEdit = new KLineEdit(this); m_lineEdit = new KLineEdit(this);
connect(m_lineEdit, TQT_SIGNAL(textChanged(const TQString&)), TQT_SIGNAL(modified())); connect(m_lineEdit, TQ_SIGNAL(textChanged(const TQString&)), TQ_SIGNAL(modified()));
// connect(kl, TQT_SIGNAL(returnPressed(const TQString&)), this, TQT_SLOT(slotHandleReturn())); // connect(kl, TQ_SIGNAL(returnPressed(const TQString&)), this, TQ_SLOT(slotHandleReturn()));
// regexp is any number of digits followed optionally by any number of // regexp is any number of digits followed optionally by any number of
// groups of a semi-colon followed optionally by a space, followed by digits // groups of a semi-colon followed optionally by a space, followed by digits
@ -48,10 +48,10 @@ void NumberFieldWidget::initLineEdit() {
void NumberFieldWidget::initSpinBox() { void NumberFieldWidget::initSpinBox() {
// intentionally allow only positive numbers // intentionally allow only positive numbers
m_spinBox = new GUI::SpinBox(-1, INT_MAX, this); m_spinBox = new GUI::SpinBox(-1, INT_MAX, this);
connect(m_spinBox, TQT_SIGNAL(valueChanged(int)), TQT_SIGNAL(modified())); connect(m_spinBox, TQ_SIGNAL(valueChanged(int)), TQ_SIGNAL(modified()));
// TQSpinBox doesn't emit valueChanged if you edit the value with // TQSpinBox doesn't emit valueChanged if you edit the value with
// the lineEdit until you change the keyboard focus // the lineEdit until you change the keyboard focus
connect(m_spinBox->child("qt_spinbox_edit"), TQT_SIGNAL(textChanged(const TQString&)), TQT_SIGNAL(modified())); connect(m_spinBox->child("qt_spinbox_edit"), TQ_SIGNAL(textChanged(const TQString&)), TQ_SIGNAL(modified()));
// I want to allow no value, so set space as special text. Empty text is ignored // I want to allow no value, so set space as special text. Empty text is ignored
m_spinBox->setSpecialValueText(TQChar(' ')); m_spinBox->setSpecialValueText(TQChar(' '));
} }

@ -27,7 +27,7 @@ ParaFieldWidget::ParaFieldWidget(Data::FieldPtr field_, TQWidget* parent_, const
if(field_->property(TQString::fromLatin1("tools-check-spelling")) != Latin1Literal("false")) { if(field_->property(TQString::fromLatin1("tools-check-spelling")) != Latin1Literal("false")) {
m_textEdit->setCheckSpellingEnabled(true); m_textEdit->setCheckSpellingEnabled(true);
} }
connect(m_textEdit, TQT_SIGNAL(textChanged()), TQT_SIGNAL(modified())); connect(m_textEdit, TQ_SIGNAL(textChanged()), TQ_SIGNAL(modified()));
registerWidget(); registerWidget();
} }

@ -27,7 +27,7 @@ PreviewDialog::PreviewDialog(TQWidget* parent_)
i18n("Template Preview"), KDialogBase::Ok) i18n("Template Preview"), KDialogBase::Ok)
, m_tempDir(new KTempDir()) { , m_tempDir(new KTempDir()) {
m_tempDir->setAutoDelete(true); m_tempDir->setAutoDelete(true);
connect(this, TQT_SIGNAL(finished()), TQT_SLOT(delayedDestruct())); connect(this, TQ_SIGNAL(finished()), TQ_SLOT(delayedDestruct()));
m_view = new EntryView(this); m_view = new EntryView(this);
setMainWidget(m_view->view()); setMainWidget(m_view->view());

@ -20,7 +20,7 @@ using Tellico::GUI::RatingFieldWidget;
RatingFieldWidget::RatingFieldWidget(Data::FieldPtr field_, TQWidget* parent_, const char* name_/*=0*/) RatingFieldWidget::RatingFieldWidget(Data::FieldPtr field_, TQWidget* parent_, const char* name_/*=0*/)
: FieldWidget(field_, parent_, name_) { : FieldWidget(field_, parent_, name_) {
m_rating = new RatingWidget(field_, this); m_rating = new RatingWidget(field_, this);
connect(m_rating, TQT_SIGNAL(modified()), TQT_SIGNAL(modified())); connect(m_rating, TQ_SIGNAL(modified()), TQ_SIGNAL(modified()));
registerWidget(); registerWidget();
} }

@ -41,8 +41,8 @@ StringMapDialog::StringMapDialog(const TQMap<TQString, TQString>& map_, TQWidget
m_listView->setColumnWidthMode(0, TQListView::Maximum); m_listView->setColumnWidthMode(0, TQListView::Maximum);
m_listView->setColumnWidthMode(1, TQListView::Maximum); m_listView->setColumnWidthMode(1, TQListView::Maximum);
m_listView->setResizeMode(TQListView::AllColumns); m_listView->setResizeMode(TQListView::AllColumns);
connect(m_listView, TQT_SIGNAL(currentChanged(TQListViewItem*)), TQT_SLOT(slotUpdate(TQListViewItem*))); connect(m_listView, TQ_SIGNAL(currentChanged(TQListViewItem*)), TQ_SLOT(slotUpdate(TQListViewItem*)));
connect(m_listView, TQT_SIGNAL(clicked(TQListViewItem*)), TQT_SLOT(slotUpdate(TQListViewItem*))); connect(m_listView, TQ_SIGNAL(clicked(TQListViewItem*)), TQ_SLOT(slotUpdate(TQListViewItem*)));
l->addWidget(m_listView); l->addWidget(m_listView);
TQHBox* box = new TQHBox(page); TQHBox* box = new TQHBox(page);
@ -54,9 +54,9 @@ StringMapDialog::StringMapDialog(const TQMap<TQString, TQString>& map_, TQWidget
m_edit2 = new KLineEdit(box); m_edit2 = new KLineEdit(box);
KButtonBox* bb = new KButtonBox(box); KButtonBox* bb = new KButtonBox(box);
bb->addStretch(); bb->addStretch();
TQPushButton* btn = bb->addButton(i18n("&Set"), this, TQT_SLOT(slotAdd())); TQPushButton* btn = bb->addButton(i18n("&Set"), this, TQ_SLOT(slotAdd()));
btn->setIconSet(BarIcon(TQString::fromLatin1("document-new"), TDEIcon::SizeSmall)); btn->setIconSet(BarIcon(TQString::fromLatin1("document-new"), TDEIcon::SizeSmall));
btn = bb->addButton(i18n("&Delete"), this, TQT_SLOT(slotDelete())); btn = bb->addButton(i18n("&Delete"), this, TQ_SLOT(slotDelete()));
btn->setIconSet(BarIcon(TQString::fromLatin1("edit-delete"), TDEIcon::SizeSmall)); btn->setIconSet(BarIcon(TQString::fromLatin1("edit-delete"), TDEIcon::SizeSmall));
l->addWidget(box); l->addWidget(box);

@ -49,7 +49,7 @@ TableFieldWidget::TableFieldWidget(Data::FieldPtr field_, TQWidget* parent_, con
m_table->verticalHeader()->setClickEnabled(true); m_table->verticalHeader()->setClickEnabled(true);
m_table->verticalHeader()->installEventFilter(this); m_table->verticalHeader()->installEventFilter(this);
connect(m_table->verticalHeader(), TQT_SIGNAL(indexChange(int, int, int)), TQT_SIGNAL(modified())); connect(m_table->verticalHeader(), TQ_SIGNAL(indexChange(int, int, int)), TQ_SIGNAL(modified()));
m_table->setDragEnabled(false); m_table->setDragEnabled(false);
m_table->setFocusStyle(TQTable::FollowStyle); m_table->setFocusStyle(TQTable::FollowStyle);
@ -61,10 +61,10 @@ TableFieldWidget::TableFieldWidget(Data::FieldPtr field_, TQWidget* parent_, con
m_table->setSelectionMode(TQTable::NoSelection); m_table->setSelectionMode(TQTable::NoSelection);
m_table->setHScrollBarMode(TQScrollView::AlwaysOff); m_table->setHScrollBarMode(TQScrollView::AlwaysOff);
connect(m_table, TQT_SIGNAL(valueChanged(int, int)), TQT_SIGNAL(modified())); connect(m_table, TQ_SIGNAL(valueChanged(int, int)), TQ_SIGNAL(modified()));
connect(m_table, TQT_SIGNAL(currentChanged(int, int)), TQT_SLOT(slotCheckRows(int, int))); connect(m_table, TQ_SIGNAL(currentChanged(int, int)), TQ_SLOT(slotCheckRows(int, int)));
connect(m_table, TQT_SIGNAL(valueChanged(int, int)), TQT_SLOT(slotResizeColumn(int, int))); connect(m_table, TQ_SIGNAL(valueChanged(int, int)), TQ_SLOT(slotResizeColumn(int, int)));
connect(m_table, TQT_SIGNAL(contextMenuRequested(int, int, const TQPoint&)), TQT_SLOT(contextMenu(int, int, const TQPoint&))); connect(m_table, TQ_SIGNAL(contextMenuRequested(int, int, const TQPoint&)), TQ_SLOT(contextMenu(int, int, const TQPoint&)));
registerWidget(); registerWidget();
} }
@ -239,7 +239,7 @@ bool TableFieldWidget::eventFilter(TQObject* obj_, TQEvent* ev_) {
m_col = col; m_col = col;
TDEPopupMenu menu(this); TDEPopupMenu menu(this);
menu.insertItem(SmallIconSet(TQString::fromLatin1("edit")), i18n("Rename Column..."), menu.insertItem(SmallIconSet(TQString::fromLatin1("edit")), i18n("Rename Column..."),
this, TQT_SLOT(slotRenameColumn())); this, TQ_SLOT(slotRenameColumn()));
menu.exec(ev->globalPos()); menu.exec(ev->globalPos());
return true; return true;
} else if(obj_ == m_table->verticalHeader()) { } else if(obj_ == m_table->verticalHeader()) {
@ -272,28 +272,28 @@ void TableFieldWidget::contextMenu(int row_, int col_, const TQPoint& p_) {
int id; int id;
TDEPopupMenu menu(this); TDEPopupMenu menu(this);
menu.insertItem(SmallIconSet(TQString::fromLatin1("insrow")), i18n("Insert Row"), menu.insertItem(SmallIconSet(TQString::fromLatin1("insrow")), i18n("Insert Row"),
this, TQT_SLOT(slotInsertRow())); this, TQ_SLOT(slotInsertRow()));
menu.insertItem(SmallIconSet(TQString::fromLatin1("remrow")), i18n("Remove Row"), menu.insertItem(SmallIconSet(TQString::fromLatin1("remrow")), i18n("Remove Row"),
this, TQT_SLOT(slotRemoveRow())); this, TQ_SLOT(slotRemoveRow()));
id = menu.insertItem(SmallIconSet(TQString::fromLatin1("1uparrow")), i18n("Move Row Up"), id = menu.insertItem(SmallIconSet(TQString::fromLatin1("1uparrow")), i18n("Move Row Up"),
this, TQT_SLOT(slotMoveRowUp())); this, TQ_SLOT(slotMoveRowUp()));
if(m_row == 0) { if(m_row == 0) {
menu.setItemEnabled(id, false); menu.setItemEnabled(id, false);
} }
id = menu.insertItem(SmallIconSet(TQString::fromLatin1("1downarrow")), i18n("Move Row Down"), id = menu.insertItem(SmallIconSet(TQString::fromLatin1("1downarrow")), i18n("Move Row Down"),
this, TQT_SLOT(slotMoveRowDown())); this, TQ_SLOT(slotMoveRowDown()));
if(m_row == m_table->numRows()-1) { if(m_row == m_table->numRows()-1) {
menu.setItemEnabled(id, false); menu.setItemEnabled(id, false);
} }
menu.insertSeparator(); menu.insertSeparator();
id = menu.insertItem(SmallIconSet(TQString::fromLatin1("edit")), i18n("Rename Column..."), id = menu.insertItem(SmallIconSet(TQString::fromLatin1("edit")), i18n("Rename Column..."),
this, TQT_SLOT(slotRenameColumn())); this, TQ_SLOT(slotRenameColumn()));
if(m_col < 0 || m_col > m_columns-1) { if(m_col < 0 || m_col > m_columns-1) {
menu.setItemEnabled(id, false); menu.setItemEnabled(id, false);
} }
menu.insertSeparator(); menu.insertSeparator();
menu.insertItem(SmallIconSet(TQString::fromLatin1("locationbar_erase")), i18n("Clear Table"), menu.insertItem(SmallIconSet(TQString::fromLatin1("locationbar_erase")), i18n("Clear Table"),
this, TQT_SLOT(clear())); this, TQ_SLOT(clear()));
menu.exec(p_); menu.exec(p_);
} }

@ -38,9 +38,9 @@ URLFieldWidget::URLFieldWidget(Data::FieldPtr field_, TQWidget* parent_, const c
m_requester = new KURLRequester(this); m_requester = new KURLRequester(this);
m_requester->lineEdit()->setCompletionObject(new URLCompletion()); m_requester->lineEdit()->setCompletionObject(new URLCompletion());
m_requester->lineEdit()->setAutoDeleteCompletionObject(true); m_requester->lineEdit()->setAutoDeleteCompletionObject(true);
connect(m_requester, TQT_SIGNAL(textChanged(const TQString&)), TQT_SIGNAL(modified())); connect(m_requester, TQ_SIGNAL(textChanged(const TQString&)), TQ_SIGNAL(modified()));
connect(m_requester, TQT_SIGNAL(textChanged(const TQString&)), label(), TQT_SLOT(setURL(const TQString&))); connect(m_requester, TQ_SIGNAL(textChanged(const TQString&)), label(), TQ_SLOT(setURL(const TQString&)));
connect(label(), TQT_SIGNAL(leftClickedURL(const TQString&)), TQT_SLOT(slotOpenURL(const TQString&))); connect(label(), TQ_SIGNAL(leftClickedURL(const TQString&)), TQ_SLOT(slotOpenURL(const TQString&)));
registerWidget(); registerWidget();
// special case, remember if it's a relative url // special case, remember if it's a relative url

@ -86,7 +86,7 @@ ImportDialog::ImportDialog(Import::Format format_, const KURL::List& urls_, TQWi
topLayout->addWidget(w, 0); topLayout->addWidget(w, 0);
} }
connect(bg, TQT_SIGNAL(clicked(int)), m_importer, TQT_SLOT(slotActionChanged(int))); connect(bg, TQ_SIGNAL(clicked(int)), m_importer, TQ_SLOT(slotActionChanged(int)));
topLayout->addStretch(); topLayout->addStretch();
setMainWidget(widget); setMainWidget(widget);
@ -97,7 +97,7 @@ ImportDialog::ImportDialog(Import::Format format_, const KURL::List& urls_, TQWi
// want to grab default button action, too // want to grab default button action, too
// since the importer might do something with widgets, don't just call it, do it after layout is done // since the importer might do something with widgets, don't just call it, do it after layout is done
TQTimer::singleShot(0, this, TQT_SLOT(slotUpdateAction())); TQTimer::singleShot(0, this, TQ_SLOT(slotUpdateAction()));
} }
ImportDialog::~ImportDialog() { ImportDialog::~ImportDialog() {

@ -99,11 +99,11 @@ void LoanDialog::init() {
m_borrowerEdit = new KLineEdit(hbox); m_borrowerEdit = new KLineEdit(hbox);
l->setBuddy(m_borrowerEdit); l->setBuddy(m_borrowerEdit);
m_borrowerEdit->completionObject()->setIgnoreCase(true); m_borrowerEdit->completionObject()->setIgnoreCase(true);
connect(m_borrowerEdit, TQT_SIGNAL(textChanged(const TQString&)), connect(m_borrowerEdit, TQ_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotBorrowerNameChanged(const TQString&))); TQ_SLOT(slotBorrowerNameChanged(const TQString&)));
actionButton(Ok)->setEnabled(false); // disable until a name is entered actionButton(Ok)->setEnabled(false); // disable until a name is entered
KPushButton* pb = new KPushButton(SmallIconSet(TQString::fromLatin1("kaddressbook")), TQString(), hbox); KPushButton* pb = new KPushButton(SmallIconSet(TQString::fromLatin1("kaddressbook")), TQString(), hbox);
connect(pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotGetBorrower())); connect(pb, TQ_SIGNAL(clicked()), TQ_SLOT(slotGetBorrower()));
TQString whats = i18n("Enter the name of the person borrowing the items from you. " TQString whats = i18n("Enter the name of the person borrowing the items from you. "
"Clicking the button allows you to select from your address book."); "Clicking the button allows you to select from your address book.");
TQWhatsThis::add(l, whats); TQWhatsThis::add(l, whats);
@ -135,7 +135,7 @@ void LoanDialog::init() {
l->setBuddy(m_dueDate); l->setBuddy(m_dueDate);
topLayout->addWidget(m_dueDate, 3, 1); topLayout->addWidget(m_dueDate, 3, 1);
// valid due dates will enable the calendar adding checkbox // valid due dates will enable the calendar adding checkbox
connect(m_dueDate, TQT_SIGNAL(signalModified()), TQT_SLOT(slotDueDateChanged())); connect(m_dueDate, TQ_SIGNAL(signalModified()), TQ_SLOT(slotDueDateChanged()));
whats = i18n("The due date is when the items are due to be returned. The due date " whats = i18n("The due date is when the items are due to be returned. The due date "
"is not required, unless you want to add the loan to your active calendar."); "is not required, unless you want to add the loan to your active calendar.");
TQWhatsThis::add(l, whats); TQWhatsThis::add(l, whats);
@ -161,10 +161,10 @@ void LoanDialog::init() {
resize(configDialogSize(TQString::fromLatin1("Loan Dialog Options"))); resize(configDialogSize(TQString::fromLatin1("Loan Dialog Options")));
TDEABC::AddressBook* abook = TDEABC::StdAddressBook::self(true); TDEABC::AddressBook* abook = TDEABC::StdAddressBook::self(true);
connect(abook, TQT_SIGNAL(addressBookChanged(AddressBook*)), connect(abook, TQ_SIGNAL(addressBookChanged(AddressBook*)),
TQT_SLOT(slotLoadAddressBook())); TQ_SLOT(slotLoadAddressBook()));
connect(abook, TQT_SIGNAL(loadingFinished(Resource*)), connect(abook, TQ_SIGNAL(loadingFinished(Resource*)),
TQT_SLOT(slotLoadAddressBook())); TQ_SLOT(slotLoadAddressBook()));
slotLoadAddressBook(); slotLoadAddressBook();
} }

@ -38,14 +38,14 @@ LoanView::LoanView(TQWidget* parent_, const char* name_) : GUI::ListView(parent_
setTreeStepSize(15); setTreeStepSize(15);
setFullWidth(true); setFullWidth(true);
connect(this, TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)), connect(this, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
TQT_SLOT(contextMenuRequested(TQListViewItem*, const TQPoint&, int))); TQ_SLOT(contextMenuRequested(TQListViewItem*, const TQPoint&, int)));
connect(this, TQT_SIGNAL(expanded(TQListViewItem*)), connect(this, TQ_SIGNAL(expanded(TQListViewItem*)),
TQT_SLOT(slotExpanded(TQListViewItem*))); TQ_SLOT(slotExpanded(TQListViewItem*)));
connect(this, TQT_SIGNAL(collapsed(TQListViewItem*)), connect(this, TQ_SIGNAL(collapsed(TQListViewItem*)),
TQT_SLOT(slotCollapsed(TQListViewItem*))); TQ_SLOT(slotCollapsed(TQListViewItem*)));
} }
bool LoanView::isSelectable(GUI::ListViewItem* item_) const { bool LoanView::isSelectable(GUI::ListViewItem* item_) const {
@ -71,9 +71,9 @@ void LoanView::contextMenuRequested(TQListViewItem* item_, const TQPoint& point_
if(item->isLoanItem()) { if(item->isLoanItem()) {
TDEPopupMenu menu(this); TDEPopupMenu menu(this);
menu.insertItem(SmallIconSet(TQString::fromLatin1("2downarrow")), menu.insertItem(SmallIconSet(TQString::fromLatin1("2downarrow")),
i18n("Check-in"), this, TQT_SLOT(slotCheckIn())); i18n("Check-in"), this, TQ_SLOT(slotCheckIn()));
menu.insertItem(SmallIconSet(TQString::fromLatin1("2downarrow")), menu.insertItem(SmallIconSet(TQString::fromLatin1("2downarrow")),
i18n("Modify Loan..."), this, TQT_SLOT(slotModifyLoan())); i18n("Modify Loan..."), this, TQ_SLOT(slotModifyLoan()));
menu.exec(point_); menu.exec(point_);
} }
} }

@ -151,7 +151,7 @@ MainWindow::MainWindow(TQWidget* parent_/*=0*/, const char* name_/*=0*/) : TDEMa
installEventFilter(drophandler); installEventFilter(drophandler);
MARK_LINE; MARK_LINE;
TQTimer::singleShot(0, this, TQT_SLOT(slotInit())); TQTimer::singleShot(0, this, TQ_SLOT(slotInit()));
} }
void MainWindow::slotInit() { void MainWindow::slotInit() {
@ -183,8 +183,8 @@ void MainWindow::initActions() {
* File->New menu * File->New menu
*************************************************/ *************************************************/
TQSignalMapper* collectionMapper = new TQSignalMapper(this); TQSignalMapper* collectionMapper = new TQSignalMapper(this);
connect(collectionMapper, TQT_SIGNAL(mapped(int)), connect(collectionMapper, TQ_SIGNAL(mapped(int)),
this, TQT_SLOT(slotFileNew(int))); this, TQ_SLOT(slotFileNew(int)));
TDEActionMenu* fileNewMenu = new TDEActionMenu(actionCollection(), "file_new_collection"); TDEActionMenu* fileNewMenu = new TDEActionMenu(actionCollection(), "file_new_collection");
fileNewMenu->setText(i18n("New")); fileNewMenu->setText(i18n("New"));
@ -198,7 +198,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("book"))); action->setIconSet(UserIconSet(TQString::fromLatin1("book")));
action->setToolTip(i18n("Create a new book collection")); action->setToolTip(i18n("Create a new book collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Book); collectionMapper->setMapping(action, Data::Collection::Book);
action = new TDEAction(actionCollection(), "new_bibtex_collection"); action = new TDEAction(actionCollection(), "new_bibtex_collection");
@ -206,7 +206,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("bibtex"))); action->setIconSet(UserIconSet(TQString::fromLatin1("bibtex")));
action->setToolTip(i18n("Create a new bibtex bibliography")); action->setToolTip(i18n("Create a new bibtex bibliography"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Bibtex); collectionMapper->setMapping(action, Data::Collection::Bibtex);
action = new TDEAction(actionCollection(), "new_comic_book_collection"); action = new TDEAction(actionCollection(), "new_comic_book_collection");
@ -214,7 +214,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("comic"))); action->setIconSet(UserIconSet(TQString::fromLatin1("comic")));
action->setToolTip(i18n("Create a new comic book collection")); action->setToolTip(i18n("Create a new comic book collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::ComicBook); collectionMapper->setMapping(action, Data::Collection::ComicBook);
action = new TDEAction(actionCollection(), "new_video_collection"); action = new TDEAction(actionCollection(), "new_video_collection");
@ -222,7 +222,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("video-x-generic"))); action->setIconSet(UserIconSet(TQString::fromLatin1("video-x-generic")));
action->setToolTip(i18n("Create a new video collection")); action->setToolTip(i18n("Create a new video collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Video); collectionMapper->setMapping(action, Data::Collection::Video);
action = new TDEAction(actionCollection(), "new_music_collection"); action = new TDEAction(actionCollection(), "new_music_collection");
@ -230,7 +230,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("album"))); action->setIconSet(UserIconSet(TQString::fromLatin1("album")));
action->setToolTip(i18n("Create a new music collection")); action->setToolTip(i18n("Create a new music collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Album); collectionMapper->setMapping(action, Data::Collection::Album);
action = new TDEAction(actionCollection(), "new_coin_collection"); action = new TDEAction(actionCollection(), "new_coin_collection");
@ -238,7 +238,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("coin"))); action->setIconSet(UserIconSet(TQString::fromLatin1("coin")));
action->setToolTip(i18n("Create a new coin collection")); action->setToolTip(i18n("Create a new coin collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Coin); collectionMapper->setMapping(action, Data::Collection::Coin);
action = new TDEAction(actionCollection(), "new_stamp_collection"); action = new TDEAction(actionCollection(), "new_stamp_collection");
@ -246,7 +246,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("stamp"))); action->setIconSet(UserIconSet(TQString::fromLatin1("stamp")));
action->setToolTip(i18n("Create a new stamp collection")); action->setToolTip(i18n("Create a new stamp collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Stamp); collectionMapper->setMapping(action, Data::Collection::Stamp);
action = new TDEAction(actionCollection(), "new_card_collection"); action = new TDEAction(actionCollection(), "new_card_collection");
@ -254,7 +254,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("card"))); action->setIconSet(UserIconSet(TQString::fromLatin1("card")));
action->setToolTip(i18n("Create a new trading card collection")); action->setToolTip(i18n("Create a new trading card collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Card); collectionMapper->setMapping(action, Data::Collection::Card);
action = new TDEAction(actionCollection(), "new_wine_collection"); action = new TDEAction(actionCollection(), "new_wine_collection");
@ -262,7 +262,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("wine"))); action->setIconSet(UserIconSet(TQString::fromLatin1("wine")));
action->setToolTip(i18n("Create a new wine collection")); action->setToolTip(i18n("Create a new wine collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Wine); collectionMapper->setMapping(action, Data::Collection::Wine);
action = new TDEAction(actionCollection(), "new_game_collection"); action = new TDEAction(actionCollection(), "new_game_collection");
@ -270,7 +270,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("game"))); action->setIconSet(UserIconSet(TQString::fromLatin1("game")));
action->setToolTip(i18n("Create a new game collection")); action->setToolTip(i18n("Create a new game collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Game); collectionMapper->setMapping(action, Data::Collection::Game);
action = new TDEAction(actionCollection(), "new_boardgame_collection"); action = new TDEAction(actionCollection(), "new_boardgame_collection");
@ -278,7 +278,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("boardgame"))); action->setIconSet(UserIconSet(TQString::fromLatin1("boardgame")));
action->setToolTip(i18n("Create a new board game collection")); action->setToolTip(i18n("Create a new board game collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::BoardGame); collectionMapper->setMapping(action, Data::Collection::BoardGame);
action = new TDEAction(actionCollection(), "new_file_catalog"); action = new TDEAction(actionCollection(), "new_file_catalog");
@ -286,7 +286,7 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("file"))); action->setIconSet(UserIconSet(TQString::fromLatin1("file")));
action->setToolTip(i18n("Create a new file catalog")); action->setToolTip(i18n("Create a new file catalog"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::File); collectionMapper->setMapping(action, Data::Collection::File);
action = new TDEAction(actionCollection(), "new_custom_collection"); action = new TDEAction(actionCollection(), "new_custom_collection");
@ -294,30 +294,30 @@ void MainWindow::initActions() {
action->setIconSet(UserIconSet(TQString::fromLatin1("document-new"))); action->setIconSet(UserIconSet(TQString::fromLatin1("document-new")));
action->setToolTip(i18n("Create a new custom collection")); action->setToolTip(i18n("Create a new custom collection"));
fileNewMenu->insert(action); fileNewMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), collectionMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), collectionMapper, TQ_SLOT(map()));
collectionMapper->setMapping(action, Data::Collection::Base); collectionMapper->setMapping(action, Data::Collection::Base);
/************************************************* /*************************************************
* File menu * File menu
*************************************************/ *************************************************/
action = KStdAction::open(this, TQT_SLOT(slotFileOpen()), actionCollection()); action = KStdAction::open(this, TQ_SLOT(slotFileOpen()), actionCollection());
action->setToolTip(i18n("Open an existing document")); action->setToolTip(i18n("Open an existing document"));
m_fileOpenRecent = KStdAction::openRecent(this, TQT_SLOT(slotFileOpenRecent(const KURL&)), actionCollection()); m_fileOpenRecent = KStdAction::openRecent(this, TQ_SLOT(slotFileOpenRecent(const KURL&)), actionCollection());
m_fileOpenRecent->setToolTip(i18n("Open a recently used file")); m_fileOpenRecent->setToolTip(i18n("Open a recently used file"));
m_fileSave = KStdAction::save(this, TQT_SLOT(slotFileSave()), actionCollection()); m_fileSave = KStdAction::save(this, TQ_SLOT(slotFileSave()), actionCollection());
m_fileSave->setToolTip(i18n("Save the document")); m_fileSave->setToolTip(i18n("Save the document"));
action = KStdAction::saveAs(this, TQT_SLOT(slotFileSaveAs()), actionCollection()); action = KStdAction::saveAs(this, TQ_SLOT(slotFileSaveAs()), actionCollection());
action->setToolTip(i18n("Save the document as a different file...")); action->setToolTip(i18n("Save the document as a different file..."));
action = KStdAction::print(this, TQT_SLOT(slotFilePrint()), actionCollection()); action = KStdAction::print(this, TQ_SLOT(slotFilePrint()), actionCollection());
action->setToolTip(i18n("Print the contents of the document...")); action->setToolTip(i18n("Print the contents of the document..."));
action = KStdAction::quit(this, TQT_SLOT(slotFileQuit()), actionCollection()); action = KStdAction::quit(this, TQ_SLOT(slotFileQuit()), actionCollection());
action->setToolTip(i18n("Quit the application")); action->setToolTip(i18n("Quit the application"));
/**************** Import Menu ***************************/ /**************** Import Menu ***************************/
TQSignalMapper* importMapper = new TQSignalMapper(this); TQSignalMapper* importMapper = new TQSignalMapper(this);
connect(importMapper, TQT_SIGNAL(mapped(int)), connect(importMapper, TQ_SIGNAL(mapped(int)),
this, TQT_SLOT(slotFileImport(int))); this, TQ_SLOT(slotFileImport(int)));
TDEActionMenu* importMenu = new TDEActionMenu(actionCollection(), "file_import"); TDEActionMenu* importMenu = new TDEActionMenu(actionCollection(), "file_import");
importMenu->setText(i18n("&Import")); importMenu->setText(i18n("&Import"));
@ -330,7 +330,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import another Tellico data file")); action->setToolTip(i18n("Import another Tellico data file"));
action->setIcon(TQString::fromLatin1("tellico")); action->setIcon(TQString::fromLatin1("tellico"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::TellicoXML); importMapper->setMapping(action, Import::TellicoXML);
action = new TDEAction(actionCollection(), "file_import_csv"); action = new TDEAction(actionCollection(), "file_import_csv");
@ -338,7 +338,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import a CSV file")); action->setToolTip(i18n("Import a CSV file"));
action->setIcon(MIME_ICON("text/csv")); action->setIcon(MIME_ICON("text/csv"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::CSV); importMapper->setMapping(action, Import::CSV);
action = new TDEAction(actionCollection(), "file_import_mods"); action = new TDEAction(actionCollection(), "file_import_mods");
@ -346,7 +346,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import a MODS data file")); action->setToolTip(i18n("Import a MODS data file"));
action->setIcon(MIME_ICON("text/xml")); action->setIcon(MIME_ICON("text/xml"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::MODS); importMapper->setMapping(action, Import::MODS);
action = new TDEAction(actionCollection(), "file_import_alexandria"); action = new TDEAction(actionCollection(), "file_import_alexandria");
@ -354,7 +354,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import data from the Alexandria book collection manager")); action->setToolTip(i18n("Import data from the Alexandria book collection manager"));
action->setIcon(TQString::fromLatin1("alexandria")); action->setIcon(TQString::fromLatin1("alexandria"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::Alexandria); importMapper->setMapping(action, Import::Alexandria);
action = new TDEAction(actionCollection(), "file_import_delicious"); action = new TDEAction(actionCollection(), "file_import_delicious");
@ -362,7 +362,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import data from Delicious Library")); action->setToolTip(i18n("Import data from Delicious Library"));
action->setIcon(MIME_ICON("text/xml")); action->setIcon(MIME_ICON("text/xml"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::Delicious); importMapper->setMapping(action, Import::Delicious);
action = new TDEAction(actionCollection(), "file_import_referencer"); action = new TDEAction(actionCollection(), "file_import_referencer");
@ -370,7 +370,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import data from Referencer")); action->setToolTip(i18n("Import data from Referencer"));
action->setIcon(TQString::fromLatin1("referencer")); action->setIcon(TQString::fromLatin1("referencer"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::Referencer); importMapper->setMapping(action, Import::Referencer);
action = new TDEAction(actionCollection(), "file_import_bibtex"); action = new TDEAction(actionCollection(), "file_import_bibtex");
@ -378,7 +378,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import a bibtex bibliography file")); action->setToolTip(i18n("Import a bibtex bibliography file"));
action->setIcon(MIME_ICON("text/x-bibtex")); action->setIcon(MIME_ICON("text/x-bibtex"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::Bibtex); importMapper->setMapping(action, Import::Bibtex);
action = new TDEAction(actionCollection(), "file_import_bibtexml"); action = new TDEAction(actionCollection(), "file_import_bibtexml");
@ -386,7 +386,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import a Bibtexml bibliography file")); action->setToolTip(i18n("Import a Bibtexml bibliography file"));
action->setIcon(MIME_ICON("text/xml")); action->setIcon(MIME_ICON("text/xml"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::Bibtexml); importMapper->setMapping(action, Import::Bibtexml);
action = new TDEAction(actionCollection(), "file_import_ris"); action = new TDEAction(actionCollection(), "file_import_ris");
@ -394,7 +394,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import an RIS reference file")); action->setToolTip(i18n("Import an RIS reference file"));
action->setIcon(MIME_ICON("application/x-research-info-systems")); action->setIcon(MIME_ICON("application/x-research-info-systems"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::RIS); importMapper->setMapping(action, Import::RIS);
action = new TDEAction(actionCollection(), "file_import_pdf"); action = new TDEAction(actionCollection(), "file_import_pdf");
@ -402,7 +402,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import a PDF file")); action->setToolTip(i18n("Import a PDF file"));
action->setIcon(MIME_ICON("application/pdf")); action->setIcon(MIME_ICON("application/pdf"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::PDF); importMapper->setMapping(action, Import::PDF);
action = new TDEAction(actionCollection(), "file_import_audiofile"); action = new TDEAction(actionCollection(), "file_import_audiofile");
@ -410,7 +410,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import meta-data from audio files")); action->setToolTip(i18n("Import meta-data from audio files"));
action->setIcon(MIME_ICON("audio/x-mp3")); action->setIcon(MIME_ICON("audio/x-mp3"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::AudioFile); importMapper->setMapping(action, Import::AudioFile);
#ifndef HAVE_TAGLIB #ifndef HAVE_TAGLIB
action->setEnabled(false); action->setEnabled(false);
@ -421,7 +421,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import audio CD information")); action->setToolTip(i18n("Import audio CD information"));
action->setIcon(MIME_ICON("media/audiocd")); action->setIcon(MIME_ICON("media/audiocd"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::FreeDB); importMapper->setMapping(action, Import::FreeDB);
#ifndef HAVE_KCDDB #ifndef HAVE_KCDDB
action->setEnabled(false); action->setEnabled(false);
@ -432,7 +432,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import a GCstar data file")); action->setToolTip(i18n("Import a GCstar data file"));
action->setIcon(TQString::fromLatin1("gcstar")); action->setIcon(TQString::fromLatin1("gcstar"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::GCfilms); importMapper->setMapping(action, Import::GCfilms);
action = new TDEAction(actionCollection(), "file_import_griffith"); action = new TDEAction(actionCollection(), "file_import_griffith");
@ -440,7 +440,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import a Griffith database")); action->setToolTip(i18n("Import a Griffith database"));
action->setIcon(TQString::fromLatin1("griffith")); action->setIcon(TQString::fromLatin1("griffith"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::Griffith); importMapper->setMapping(action, Import::Griffith);
action = new TDEAction(actionCollection(), "file_import_amc"); action = new TDEAction(actionCollection(), "file_import_amc");
@ -448,7 +448,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import an Ant Movie Catalog data file")); action->setToolTip(i18n("Import an Ant Movie Catalog data file"));
action->setIcon(MIME_ICON("application/x-crossover-amc")); action->setIcon(MIME_ICON("application/x-crossover-amc"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::AMC); importMapper->setMapping(action, Import::AMC);
action = new TDEAction(actionCollection(), "file_import_filelisting"); action = new TDEAction(actionCollection(), "file_import_filelisting");
@ -456,7 +456,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import information about files in a folder")); action->setToolTip(i18n("Import information about files in a folder"));
action->setIcon(MIME_ICON("inode/directory")); action->setIcon(MIME_ICON("inode/directory"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::FileListing); importMapper->setMapping(action, Import::FileListing);
action = new TDEAction(actionCollection(), "file_import_xslt"); action = new TDEAction(actionCollection(), "file_import_xslt");
@ -464,14 +464,14 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Import using an XSL Transform")); action->setToolTip(i18n("Import using an XSL Transform"));
action->setIcon(MIME_ICON("text/x-xslt")); action->setIcon(MIME_ICON("text/x-xslt"));
importMenu->insert(action); importMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), importMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), importMapper, TQ_SLOT(map()));
importMapper->setMapping(action, Import::XSLT); importMapper->setMapping(action, Import::XSLT);
/**************** Export Menu ***************************/ /**************** Export Menu ***************************/
TQSignalMapper* exportMapper = new TQSignalMapper(this); TQSignalMapper* exportMapper = new TQSignalMapper(this);
connect(exportMapper, TQT_SIGNAL(mapped(int)), connect(exportMapper, TQ_SIGNAL(mapped(int)),
this, TQT_SLOT(slotFileExport(int))); this, TQ_SLOT(slotFileExport(int)));
TDEActionMenu* exportMenu = new TDEActionMenu(actionCollection(), "file_export"); TDEActionMenu* exportMenu = new TDEActionMenu(actionCollection(), "file_export");
exportMenu->setText(i18n("&Export")); exportMenu->setText(i18n("&Export"));
@ -484,7 +484,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to a Tellico XML file")); action->setToolTip(i18n("Export to a Tellico XML file"));
action->setIcon(TQString::fromLatin1("tellico")); action->setIcon(TQString::fromLatin1("tellico"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::TellicoXML); exportMapper->setMapping(action, Export::TellicoXML);
action = new TDEAction(actionCollection(), "file_export_zip"); action = new TDEAction(actionCollection(), "file_export_zip");
@ -492,7 +492,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to a Tellico Zip file")); action->setToolTip(i18n("Export to a Tellico Zip file"));
action->setIcon(TQString::fromLatin1("tellico")); action->setIcon(TQString::fromLatin1("tellico"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::TellicoZip); exportMapper->setMapping(action, Export::TellicoZip);
action = new TDEAction(actionCollection(), "file_export_html"); action = new TDEAction(actionCollection(), "file_export_html");
@ -500,7 +500,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to an HTML file")); action->setToolTip(i18n("Export to an HTML file"));
action->setIcon(MIME_ICON("text/html")); action->setIcon(MIME_ICON("text/html"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::HTML); exportMapper->setMapping(action, Export::HTML);
action = new TDEAction(actionCollection(), "file_export_csv"); action = new TDEAction(actionCollection(), "file_export_csv");
@ -508,7 +508,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to a comma-separated values file")); action->setToolTip(i18n("Export to a comma-separated values file"));
action->setIcon(MIME_ICON("text/csv")); action->setIcon(MIME_ICON("text/csv"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::CSV); exportMapper->setMapping(action, Export::CSV);
action = new TDEAction(actionCollection(), "file_export_pilotdb"); action = new TDEAction(actionCollection(), "file_export_pilotdb");
@ -516,7 +516,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to a PilotDB database")); action->setToolTip(i18n("Export to a PilotDB database"));
action->setIcon(MIME_ICON("application/vnd.palm")); action->setIcon(MIME_ICON("application/vnd.palm"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::PilotDB); exportMapper->setMapping(action, Export::PilotDB);
action = new TDEAction(actionCollection(), "file_export_alexandria"); action = new TDEAction(actionCollection(), "file_export_alexandria");
@ -524,7 +524,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to an Alexandria library")); action->setToolTip(i18n("Export to an Alexandria library"));
action->setIcon(TQString::fromLatin1("alexandria")); action->setIcon(TQString::fromLatin1("alexandria"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::Alexandria); exportMapper->setMapping(action, Export::Alexandria);
action = new TDEAction(actionCollection(), "file_export_bibtex"); action = new TDEAction(actionCollection(), "file_export_bibtex");
@ -532,7 +532,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to a bibtex file")); action->setToolTip(i18n("Export to a bibtex file"));
action->setIcon(MIME_ICON("text/x-bibtex")); action->setIcon(MIME_ICON("text/x-bibtex"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::Bibtex); exportMapper->setMapping(action, Export::Bibtex);
action = new TDEAction(actionCollection(), "file_export_bibtexml"); action = new TDEAction(actionCollection(), "file_export_bibtexml");
@ -540,7 +540,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to a Bibtexml file")); action->setToolTip(i18n("Export to a Bibtexml file"));
action->setIcon(MIME_ICON("text/xml")); action->setIcon(MIME_ICON("text/xml"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::Bibtexml); exportMapper->setMapping(action, Export::Bibtexml);
action = new TDEAction(actionCollection(), "file_export_onix"); action = new TDEAction(actionCollection(), "file_export_onix");
@ -548,7 +548,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to an ONIX file")); action->setToolTip(i18n("Export to an ONIX file"));
action->setIcon(MIME_ICON("text/xml")); action->setIcon(MIME_ICON("text/xml"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::ONIX); exportMapper->setMapping(action, Export::ONIX);
action = new TDEAction(actionCollection(), "file_export_gcfilms"); action = new TDEAction(actionCollection(), "file_export_gcfilms");
@ -556,7 +556,7 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export to a GCfilms data file")); action->setToolTip(i18n("Export to a GCfilms data file"));
action->setIcon(TQString::fromLatin1("gcstar")); action->setIcon(TQString::fromLatin1("gcstar"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::GCfilms); exportMapper->setMapping(action, Export::GCfilms);
#if 0 #if 0
@ -569,30 +569,30 @@ void MainWindow::initActions() {
action->setToolTip(i18n("Export using an XSL Transform")); action->setToolTip(i18n("Export using an XSL Transform"));
action->setIcon(MIME_ICON("text/x-xslt")); action->setIcon(MIME_ICON("text/x-xslt"));
exportMenu->insert(action); exportMenu->insert(action);
connect(action, TQT_SIGNAL(activated()), exportMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), exportMapper, TQ_SLOT(map()));
exportMapper->setMapping(action, Export::XSLT); exportMapper->setMapping(action, Export::XSLT);
/************************************************* /*************************************************
* Edit menu * Edit menu
*************************************************/ *************************************************/
action = KStdAction::cut(this, TQT_SLOT(slotEditCut()), actionCollection()); action = KStdAction::cut(this, TQ_SLOT(slotEditCut()), actionCollection());
action->setToolTip(i18n("Cut the selected text and puts it in the clipboard")); action->setToolTip(i18n("Cut the selected text and puts it in the clipboard"));
action = KStdAction::copy(this, TQT_SLOT(slotEditCopy()), actionCollection()); action = KStdAction::copy(this, TQ_SLOT(slotEditCopy()), actionCollection());
action->setToolTip(i18n("Copy the selected text to the clipboard")); action->setToolTip(i18n("Copy the selected text to the clipboard"));
action = KStdAction::paste(this, TQT_SLOT(slotEditPaste()), actionCollection()); action = KStdAction::paste(this, TQ_SLOT(slotEditPaste()), actionCollection());
action->setToolTip(i18n("Paste the clipboard contents")); action->setToolTip(i18n("Paste the clipboard contents"));
action = KStdAction::selectAll(this, TQT_SLOT(slotEditSelectAll()), actionCollection()); action = KStdAction::selectAll(this, TQ_SLOT(slotEditSelectAll()), actionCollection());
action->setToolTip(i18n("Select all the entries in the collection")); action->setToolTip(i18n("Select all the entries in the collection"));
action = KStdAction::deselect(this, TQT_SLOT(slotEditDeselect()), actionCollection()); action = KStdAction::deselect(this, TQ_SLOT(slotEditDeselect()), actionCollection());
action->setToolTip(i18n("Deselect all the entries in the collection")); action->setToolTip(i18n("Deselect all the entries in the collection"));
action = new TDEAction(i18n("Internet Search..."), TQString::fromLatin1("wizard"), CTRL + Key_M, action = new TDEAction(i18n("Internet Search..."), TQString::fromLatin1("wizard"), CTRL + Key_M,
this, TQT_SLOT(slotShowFetchDialog()), this, TQ_SLOT(slotShowFetchDialog()),
actionCollection(), "edit_search_internet"); actionCollection(), "edit_search_internet");
action->setToolTip(i18n("Search the internet...")); action->setToolTip(i18n("Search the internet..."));
action = new TDEAction(i18n("Advanced &Filter..."), TQString::fromLatin1("filter"), CTRL + Key_J, action = new TDEAction(i18n("Advanced &Filter..."), TQString::fromLatin1("filter"), CTRL + Key_J,
this, TQT_SLOT(slotShowFilterDialog()), this, TQ_SLOT(slotShowFilterDialog()),
actionCollection(), "filter_dialog"); actionCollection(), "filter_dialog");
action->setToolTip(i18n("Filter the collection")); action->setToolTip(i18n("Filter the collection"));
@ -600,86 +600,86 @@ void MainWindow::initActions() {
* Collection menu * Collection menu
*************************************************/ *************************************************/
m_newEntry = new TDEAction(i18n("&New Entry..."), TQString::fromLatin1("document-new"), CTRL + Key_N, m_newEntry = new TDEAction(i18n("&New Entry..."), TQString::fromLatin1("document-new"), CTRL + Key_N,
this, TQT_SLOT(slotNewEntry()), this, TQ_SLOT(slotNewEntry()),
actionCollection(), "coll_new_entry"); actionCollection(), "coll_new_entry");
m_newEntry->setToolTip(i18n("Create a new entry")); m_newEntry->setToolTip(i18n("Create a new entry"));
m_editEntry = new TDEAction(i18n("&Edit Entry..."), TQString::fromLatin1("edit"), CTRL + Key_E, m_editEntry = new TDEAction(i18n("&Edit Entry..."), TQString::fromLatin1("edit"), CTRL + Key_E,
this, TQT_SLOT(slotShowEntryEditor()), this, TQ_SLOT(slotShowEntryEditor()),
actionCollection(), "coll_edit_entry"); actionCollection(), "coll_edit_entry");
m_editEntry->setToolTip(i18n("Edit the selected entries")); m_editEntry->setToolTip(i18n("Edit the selected entries"));
m_copyEntry = new TDEAction(i18n("D&uplicate Entry"), TQString::fromLatin1("edit-copy"), CTRL + Key_Y, m_copyEntry = new TDEAction(i18n("D&uplicate Entry"), TQString::fromLatin1("edit-copy"), CTRL + Key_Y,
Controller::self(), TQT_SLOT(slotCopySelectedEntries()), Controller::self(), TQ_SLOT(slotCopySelectedEntries()),
actionCollection(), "coll_copy_entry"); actionCollection(), "coll_copy_entry");
m_copyEntry->setToolTip(i18n("Copy the selected entries")); m_copyEntry->setToolTip(i18n("Copy the selected entries"));
m_deleteEntry = new TDEAction(i18n("&Delete Entry"), TQString::fromLatin1("edit-delete"), CTRL + Key_D, m_deleteEntry = new TDEAction(i18n("&Delete Entry"), TQString::fromLatin1("edit-delete"), CTRL + Key_D,
Controller::self(), TQT_SLOT(slotDeleteSelectedEntries()), Controller::self(), TQ_SLOT(slotDeleteSelectedEntries()),
actionCollection(), "coll_delete_entry"); actionCollection(), "coll_delete_entry");
m_deleteEntry->setToolTip(i18n("Delete the selected entries")); m_deleteEntry->setToolTip(i18n("Delete the selected entries"));
m_mergeEntry = new TDEAction(i18n("&Merge Entries"), TQString::fromLatin1("edit-copy"), CTRL + Key_G, m_mergeEntry = new TDEAction(i18n("&Merge Entries"), TQString::fromLatin1("edit-copy"), CTRL + Key_G,
Controller::self(), TQT_SLOT(slotMergeSelectedEntries()), Controller::self(), TQ_SLOT(slotMergeSelectedEntries()),
actionCollection(), "coll_merge_entry"); actionCollection(), "coll_merge_entry");
m_mergeEntry->setToolTip(i18n("Merge the selected entries")); m_mergeEntry->setToolTip(i18n("Merge the selected entries"));
m_mergeEntry->setEnabled(false); // gets enabled when more than 1 entry is selected m_mergeEntry->setEnabled(false); // gets enabled when more than 1 entry is selected
action = new TDEAction(i18n("&Generate Reports..."), TQString::fromLatin1("text-x-generic"), 0, this, action = new TDEAction(i18n("&Generate Reports..."), TQString::fromLatin1("text-x-generic"), 0, this,
TQT_SLOT(slotShowReportDialog()), TQ_SLOT(slotShowReportDialog()),
actionCollection(), "coll_reports"); actionCollection(), "coll_reports");
action->setToolTip(i18n("Generate collection reports")); action->setToolTip(i18n("Generate collection reports"));
m_checkOutEntry = new TDEAction(i18n("Check-&out..."), TQString::fromLatin1("2uparrow"), 0, m_checkOutEntry = new TDEAction(i18n("Check-&out..."), TQString::fromLatin1("2uparrow"), 0,
Controller::self(), TQT_SLOT(slotCheckOut()), Controller::self(), TQ_SLOT(slotCheckOut()),
actionCollection(), "coll_checkout"); actionCollection(), "coll_checkout");
m_checkOutEntry->setToolTip(i18n("Check-out the selected items")); m_checkOutEntry->setToolTip(i18n("Check-out the selected items"));
m_checkInEntry = new TDEAction(i18n("Check-&in"), TQString::fromLatin1("2downarrow"), 0, m_checkInEntry = new TDEAction(i18n("Check-&in"), TQString::fromLatin1("2downarrow"), 0,
Controller::self(), TQT_SLOT(slotCheckIn()), Controller::self(), TQ_SLOT(slotCheckIn()),
actionCollection(), "coll_checkin"); actionCollection(), "coll_checkin");
m_checkInEntry->setToolTip(i18n("Check-in the selected items")); m_checkInEntry->setToolTip(i18n("Check-in the selected items"));
action = new TDEAction(i18n("&Rename Collection..."), TQString::fromLatin1("edit-clear"), CTRL + Key_R, action = new TDEAction(i18n("&Rename Collection..."), TQString::fromLatin1("edit-clear"), CTRL + Key_R,
this, TQT_SLOT(slotRenameCollection()), this, TQ_SLOT(slotRenameCollection()),
actionCollection(), "coll_rename_collection"); actionCollection(), "coll_rename_collection");
action->setToolTip(i18n("Rename the collection")); action->setToolTip(i18n("Rename the collection"));
action = new TDEAction(i18n("Collection &Fields..."), TQString::fromLatin1("edit"), CTRL + Key_U, action = new TDEAction(i18n("Collection &Fields..."), TQString::fromLatin1("edit"), CTRL + Key_U,
this, TQT_SLOT(slotShowCollectionFieldsDialog()), this, TQ_SLOT(slotShowCollectionFieldsDialog()),
actionCollection(), "coll_fields"); actionCollection(), "coll_fields");
action->setToolTip(i18n("Modify the collection fields")); action->setToolTip(i18n("Modify the collection fields"));
action = new TDEAction(i18n("Convert to &Bibliography"), 0, action = new TDEAction(i18n("Convert to &Bibliography"), 0,
this, TQT_SLOT(slotConvertToBibliography()), this, TQ_SLOT(slotConvertToBibliography()),
actionCollection(), "coll_convert_bibliography"); actionCollection(), "coll_convert_bibliography");
action->setToolTip(i18n("Convert a book collection to a bibliography")); action->setToolTip(i18n("Convert a book collection to a bibliography"));
action->setIconSet(UserIconSet(TQString::fromLatin1("bibtex"))); action->setIconSet(UserIconSet(TQString::fromLatin1("bibtex")));
action = new TDEAction(i18n("String &Macros..."), TQString::fromLatin1("view_text"), 0, action = new TDEAction(i18n("String &Macros..."), TQString::fromLatin1("view_text"), 0,
this, TQT_SLOT(slotShowStringMacroDialog()), this, TQ_SLOT(slotShowStringMacroDialog()),
actionCollection(), "coll_string_macros"); actionCollection(), "coll_string_macros");
action->setToolTip(i18n("Edit the bibtex string macros")); action->setToolTip(i18n("Edit the bibtex string macros"));
TQSignalMapper* citeMapper = new TQSignalMapper(this); TQSignalMapper* citeMapper = new TQSignalMapper(this);
connect(citeMapper, TQT_SIGNAL(mapped(int)), connect(citeMapper, TQ_SIGNAL(mapped(int)),
this, TQT_SLOT(slotCiteEntry(int))); this, TQ_SLOT(slotCiteEntry(int)));
action = new TDEAction(actionCollection(), "cite_clipboard"); action = new TDEAction(actionCollection(), "cite_clipboard");
action->setText(i18n("Copy Bibtex to Cli&pboard")); action->setText(i18n("Copy Bibtex to Cli&pboard"));
action->setToolTip(i18n("Copy bibtex citations to the clipboard")); action->setToolTip(i18n("Copy bibtex citations to the clipboard"));
action->setIcon(TQString::fromLatin1("edit-paste")); action->setIcon(TQString::fromLatin1("edit-paste"));
connect(action, TQT_SIGNAL(activated()), citeMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), citeMapper, TQ_SLOT(map()));
citeMapper->setMapping(action, Cite::CiteClipboard); citeMapper->setMapping(action, Cite::CiteClipboard);
action = new TDEAction(actionCollection(), "cite_lyxpipe"); action = new TDEAction(actionCollection(), "cite_lyxpipe");
action->setText(i18n("Cite Entry in &LyX")); action->setText(i18n("Cite Entry in &LyX"));
action->setToolTip(i18n("Cite the selected entries in LyX")); action->setToolTip(i18n("Cite the selected entries in LyX"));
action->setIcon(TQString::fromLatin1("lyx")); action->setIcon(TQString::fromLatin1("lyx"));
connect(action, TQT_SIGNAL(activated()), citeMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), citeMapper, TQ_SLOT(map()));
citeMapper->setMapping(action, Cite::CiteLyxpipe); citeMapper->setMapping(action, Cite::CiteLyxpipe);
action = new TDEAction(actionCollection(), "cite_openoffice"); action = new TDEAction(actionCollection(), "cite_openoffice");
action->setText(i18n("Ci&te Entry in OpenOffice.org")); action->setText(i18n("Ci&te Entry in OpenOffice.org"));
action->setToolTip(i18n("Cite the selected entries in OpenOffice.org")); action->setToolTip(i18n("Cite the selected entries in OpenOffice.org"));
action->setIcon(TQString::fromLatin1("ooo-writer")); action->setIcon(TQString::fromLatin1("ooo-writer"));
connect(action, TQT_SIGNAL(activated()), citeMapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), citeMapper, TQ_SLOT(map()));
citeMapper->setMapping(action, Cite::CiteOpenOffice); citeMapper->setMapping(action, Cite::CiteOpenOffice);
TQSignalMapper* updateMapper = new TQSignalMapper(this, "update_mapper"); TQSignalMapper* updateMapper = new TQSignalMapper(this, "update_mapper");
connect(updateMapper, TQT_SIGNAL(mapped(const TQString&)), connect(updateMapper, TQ_SIGNAL(mapped(const TQString&)),
Controller::self(), TQT_SLOT(slotUpdateSelectedEntries(const TQString&))); Controller::self(), TQ_SLOT(slotUpdateSelectedEntries(const TQString&)));
m_updateEntryMenu = new TDEActionMenu(i18n("&Update Entry"), actionCollection(), "coll_update_entry"); m_updateEntryMenu = new TDEActionMenu(i18n("&Update Entry"), actionCollection(), "coll_update_entry");
// m_updateEntryMenu->setIconSet(BarIconSet(TQString::fromLatin1("fileexport"))); // m_updateEntryMenu->setIconSet(BarIconSet(TQString::fromLatin1("fileexport")));
@ -689,7 +689,7 @@ void MainWindow::initActions() {
m_updateAll->setText(i18n("All Sources")); m_updateAll->setText(i18n("All Sources"));
m_updateAll->setToolTip(i18n("Update entry data from all available sources")); m_updateAll->setToolTip(i18n("Update entry data from all available sources"));
// m_updateEntryMenu->insert(action); // m_updateEntryMenu->insert(action);
connect(m_updateAll, TQT_SIGNAL(activated()), updateMapper, TQT_SLOT(map())); connect(m_updateAll, TQ_SIGNAL(activated()), updateMapper, TQ_SLOT(map()));
updateMapper->setMapping(m_updateAll, TQString::fromLatin1("_all")); updateMapper->setMapping(m_updateAll, TQString::fromLatin1("_all"));
/************************************************* /*************************************************
@ -697,50 +697,50 @@ void MainWindow::initActions() {
*************************************************/ *************************************************/
setStandardToolBarMenuEnabled(true); setStandardToolBarMenuEnabled(true);
createStandardStatusBarAction(); createStandardStatusBarAction();
KStdAction::configureToolbars(this, TQT_SLOT(slotConfigToolbar()), actionCollection()); KStdAction::configureToolbars(this, TQ_SLOT(slotConfigToolbar()), actionCollection());
KStdAction::keyBindings(this, TQT_SLOT(slotConfigKeys()), actionCollection()); KStdAction::keyBindings(this, TQ_SLOT(slotConfigKeys()), actionCollection());
m_toggleGroupWidget = new TDEToggleAction(i18n("Show Grou&p View"), 0, m_toggleGroupWidget = new TDEToggleAction(i18n("Show Grou&p View"), 0,
this, TQT_SLOT(slotToggleGroupWidget()), this, TQ_SLOT(slotToggleGroupWidget()),
actionCollection(), "toggle_group_widget"); actionCollection(), "toggle_group_widget");
m_toggleGroupWidget->setToolTip(i18n("Enable/disable the group view")); m_toggleGroupWidget->setToolTip(i18n("Enable/disable the group view"));
m_toggleGroupWidget->setCheckedState(i18n("Hide Grou&p View")); m_toggleGroupWidget->setCheckedState(i18n("Hide Grou&p View"));
m_toggleEntryEditor = new TDEToggleAction(i18n("Show Entry &Editor"), 0, m_toggleEntryEditor = new TDEToggleAction(i18n("Show Entry &Editor"), 0,
this, TQT_SLOT(slotToggleEntryEditor()), this, TQ_SLOT(slotToggleEntryEditor()),
actionCollection(), "toggle_edit_widget"); actionCollection(), "toggle_edit_widget");
m_toggleEntryEditor->setToolTip(i18n("Enable/disable the editor")); m_toggleEntryEditor->setToolTip(i18n("Enable/disable the editor"));
m_toggleEntryEditor->setCheckedState(i18n("Hide Entry &Editor")); m_toggleEntryEditor->setCheckedState(i18n("Hide Entry &Editor"));
m_toggleEntryView = new TDEToggleAction(i18n("Show Entry &View"), 0, m_toggleEntryView = new TDEToggleAction(i18n("Show Entry &View"), 0,
this, TQT_SLOT(slotToggleEntryView()), this, TQ_SLOT(slotToggleEntryView()),
actionCollection(), "toggle_entry_view"); actionCollection(), "toggle_entry_view");
m_toggleEntryView->setToolTip(i18n("Enable/disable the entry view")); m_toggleEntryView->setToolTip(i18n("Enable/disable the entry view"));
m_toggleEntryView->setCheckedState(i18n("Hide Entry &View")); m_toggleEntryView->setCheckedState(i18n("Hide Entry &View"));
KStdAction::preferences(this, TQT_SLOT(slotShowConfigDialog()), actionCollection()); KStdAction::preferences(this, TQ_SLOT(slotShowConfigDialog()), actionCollection());
/************************************************* /*************************************************
* Help menu * Help menu
*************************************************/ *************************************************/
KStdAction::tipOfDay(this, TQT_SLOT(slotShowTipOfDay()), actionCollection(), "tipOfDay"); KStdAction::tipOfDay(this, TQ_SLOT(slotShowTipOfDay()), actionCollection(), "tipOfDay");
/************************************************* /*************************************************
* Collection Toolbar * Collection Toolbar
*************************************************/ *************************************************/
(void) new TDEAction(i18n("Change Grouping"), CTRL + Key_G, (void) new TDEAction(i18n("Change Grouping"), CTRL + Key_G,
this, TQT_SLOT(slotGroupLabelActivated()), this, TQ_SLOT(slotGroupLabelActivated()),
actionCollection(), "change_entry_grouping_accel"); actionCollection(), "change_entry_grouping_accel");
m_entryGrouping = new TDESelectAction(i18n("&Group Selection"), 0, this, m_entryGrouping = new TDESelectAction(i18n("&Group Selection"), 0, this,
TQT_SLOT(slotChangeGrouping()), TQ_SLOT(slotChangeGrouping()),
actionCollection(), "change_entry_grouping"); actionCollection(), "change_entry_grouping");
m_entryGrouping->setToolTip(i18n("Change the grouping of the collection")); m_entryGrouping->setToolTip(i18n("Change the grouping of the collection"));
(void) new TDEAction(i18n("Filter"), CTRL + Key_F, (void) new TDEAction(i18n("Filter"), CTRL + Key_F,
this, TQT_SLOT(slotFilterLabelActivated()), this, TQ_SLOT(slotFilterLabelActivated()),
actionCollection(), "quick_filter_accel"); actionCollection(), "quick_filter_accel");
(void) new TDEAction(i18n("Clear Filter"), TQString::fromLatin1("locationbar_erase"), 0, (void) new TDEAction(i18n("Clear Filter"), TQString::fromLatin1("locationbar_erase"), 0,
this, TQT_SLOT(slotClearFilter()), this, TQ_SLOT(slotClearFilter()),
actionCollection(), "quick_filter_clear"); actionCollection(), "quick_filter_clear");
m_quickFilter = new GUI::LineEdit(); m_quickFilter = new GUI::LineEdit();
@ -748,8 +748,8 @@ void MainWindow::initActions() {
// about 10 characters wide // about 10 characters wide
m_quickFilter->setFixedWidth(m_quickFilter->fontMetrics().maxWidth()*10); m_quickFilter->setFixedWidth(m_quickFilter->fontMetrics().maxWidth()*10);
// want to update every time the filter text changes // want to update every time the filter text changes
connect(m_quickFilter, TQT_SIGNAL(textChanged(const TQString&)), connect(m_quickFilter, TQ_SIGNAL(textChanged(const TQString&)),
this, TQT_SLOT(slotQueueFilter())); this, TQ_SLOT(slotQueueFilter()));
m_quickFilter->installEventFilter(this); // intercept keyEvents m_quickFilter->installEventFilter(this); // intercept keyEvents
KWidgetAction* wAction = new KWidgetAction(m_quickFilter, i18n("Filter"), 0, 0, 0, KWidgetAction* wAction = new KWidgetAction(m_quickFilter, i18n("Filter"), 0, 0, 0,
@ -760,10 +760,10 @@ void MainWindow::initActions() {
// show tool tips in status bar // show tool tips in status bar
actionCollection()->setHighlightingEnabled(true); actionCollection()->setHighlightingEnabled(true);
connect(actionCollection(), TQT_SIGNAL(actionStatusText(const TQString &)), connect(actionCollection(), TQ_SIGNAL(actionStatusText(const TQString &)),
TQT_SLOT(slotStatusMsg(const TQString &))); TQ_SLOT(slotStatusMsg(const TQString &)));
connect(actionCollection(), TQT_SIGNAL(clearStatusText()), connect(actionCollection(), TQ_SIGNAL(clearStatusText()),
TQT_SLOT(slotClearStatus())); TQ_SLOT(slotClearStatus()));
#ifdef UIFILE #ifdef UIFILE
kdWarning() << "MainWindow::initActions() - change createGUI() call!" << endl; kdWarning() << "MainWindow::initActions() - change createGUI() call!" << endl;
@ -781,17 +781,17 @@ void MainWindow::initDocument() {
doc->setLoadAllImages(config.readBoolEntry("Load All Images", false)); doc->setLoadAllImages(config.readBoolEntry("Load All Images", false));
// allow status messages from the document // allow status messages from the document
connect(doc, TQT_SIGNAL(signalStatusMsg(const TQString&)), connect(doc, TQ_SIGNAL(signalStatusMsg(const TQString&)),
TQT_SLOT(slotStatusMsg(const TQString&))); TQ_SLOT(slotStatusMsg(const TQString&)));
// do stuff that changes when the doc is modified // do stuff that changes when the doc is modified
connect(doc, TQT_SIGNAL(signalModified(bool)), connect(doc, TQ_SIGNAL(signalModified(bool)),
TQT_SLOT(slotEnableModifiedActions(bool))); TQ_SLOT(slotEnableModifiedActions(bool)));
connect(Kernel::self()->commandHistory(), TQT_SIGNAL(commandExecuted()), connect(Kernel::self()->commandHistory(), TQ_SIGNAL(commandExecuted()),
doc, TQT_SLOT(slotSetModified())); doc, TQ_SLOT(slotSetModified()));
connect(Kernel::self()->commandHistory(), TQT_SIGNAL(documentRestored()), connect(Kernel::self()->commandHistory(), TQ_SIGNAL(documentRestored()),
doc, TQT_SLOT(slotDocumentRestored())); doc, TQ_SLOT(slotDocumentRestored()));
} }
void MainWindow::initView() { void MainWindow::initView() {
@ -813,25 +813,25 @@ void MainWindow::initView() {
Controller::self()->addObserver(m_detailedView); Controller::self()->addObserver(m_detailedView);
TQWhatsThis::add(m_detailedView, i18n("<qt>The <i>Column View</i> shows the value of multiple fields " TQWhatsThis::add(m_detailedView, i18n("<qt>The <i>Column View</i> shows the value of multiple fields "
"for each entry.</qt>")); "for each entry.</qt>"));
connect(Data::Document::self(), TQT_SIGNAL(signalCollectionImagesLoaded(Tellico::Data::CollPtr)), connect(Data::Document::self(), TQ_SIGNAL(signalCollectionImagesLoaded(Tellico::Data::CollPtr)),
m_detailedView, TQT_SLOT(slotRefreshImages())); m_detailedView, TQ_SLOT(slotRefreshImages()));
m_viewStack = new ViewStack(m_rightSplit, "viewstack"); m_viewStack = new ViewStack(m_rightSplit, "viewstack");
Controller::self()->addObserver(m_viewStack->iconView()); Controller::self()->addObserver(m_viewStack->iconView());
connect(m_viewStack->entryView(), TQT_SIGNAL(signalAction(const KURL&)), connect(m_viewStack->entryView(), TQ_SIGNAL(signalAction(const KURL&)),
TQT_SLOT(slotURLAction(const KURL&))); TQ_SLOT(slotURLAction(const KURL&)));
setMinimumWidth(MAIN_WINDOW_MIN_WIDTH); setMinimumWidth(MAIN_WINDOW_MIN_WIDTH);
} }
void MainWindow::initConnections() { void MainWindow::initConnections() {
// have to toggle the menu item if the dialog gets closed // have to toggle the menu item if the dialog gets closed
connect(m_editDialog, TQT_SIGNAL(finished()), connect(m_editDialog, TQ_SIGNAL(finished()),
this, TQT_SLOT(slotEditDialogFinished())); this, TQ_SLOT(slotEditDialogFinished()));
// let the group view call filters, too // let the group view call filters, too
connect(m_groupView, TQT_SIGNAL(signalUpdateFilter(Tellico::FilterPtr)), connect(m_groupView, TQ_SIGNAL(signalUpdateFilter(Tellico::FilterPtr)),
Controller::self(), TQT_SLOT(slotUpdateFilter(Tellico::FilterPtr))); Controller::self(), TQ_SLOT(slotUpdateFilter(Tellico::FilterPtr)));
} }
void MainWindow::initFileOpen(bool nofile_) { void MainWindow::initFileOpen(bool nofile_) {
@ -1018,7 +1018,7 @@ void MainWindow::readOptions() {
m_viewStack->iconView()->setMaxAllowedIconWidth(Config::maxIconSize()); m_viewStack->iconView()->setMaxAllowedIconWidth(Config::maxIconSize());
connect(toolBar("collectionToolBar"), TQT_SIGNAL(modechange()), TQT_SLOT(slotUpdateToolbarIcons())); connect(toolBar("collectionToolBar"), TQ_SIGNAL(modechange()), TQ_SLOT(slotUpdateToolbarIcons()));
m_toggleGroupWidget->setChecked(Config::showGroupWidget()); m_toggleGroupWidget->setChecked(Config::showGroupWidget());
slotToggleGroupWidget(); slotToggleGroupWidget();
@ -1405,15 +1405,15 @@ void MainWindow::slotFileQuit() {
} }
void MainWindow::slotEditCut() { void MainWindow::slotEditCut() {
activateEditSlot(TQT_SLOT(cut())); activateEditSlot(TQ_SLOT(cut()));
} }
void MainWindow::slotEditCopy() { void MainWindow::slotEditCopy() {
activateEditSlot(TQT_SLOT(copy())); activateEditSlot(TQ_SLOT(copy()));
} }
void MainWindow::slotEditPaste() { void MainWindow::slotEditPaste() {
activateEditSlot(TQT_SLOT(paste())); activateEditSlot(TQ_SLOT(paste()));
} }
void MainWindow::activateEditSlot(const char* slot_) { void MainWindow::activateEditSlot(const char* slot_) {
@ -1450,7 +1450,7 @@ void MainWindow::slotConfigToolbar() {
#else #else
KEditToolbar dlg(actionCollection()); KEditToolbar dlg(actionCollection());
#endif #endif
connect(&dlg, TQT_SIGNAL(newToolbarConfig()), this, TQT_SLOT(slotNewToolbarConfig())); connect(&dlg, TQ_SIGNAL(newToolbarConfig()), this, TQ_SLOT(slotNewToolbarConfig()));
dlg.exec(); dlg.exec();
} }
@ -1496,10 +1496,10 @@ void MainWindow::slotShowConfigDialog() {
m_configDlg = new ConfigDialog(this); m_configDlg = new ConfigDialog(this);
m_configDlg->show(); m_configDlg->show();
m_configDlg->readConfiguration(); m_configDlg->readConfiguration();
connect(m_configDlg, TQT_SIGNAL(signalConfigChanged()), connect(m_configDlg, TQ_SIGNAL(signalConfigChanged()),
TQT_SLOT(slotHandleConfigChange())); TQ_SLOT(slotHandleConfigChange()));
connect(m_configDlg, TQT_SIGNAL(finished()), connect(m_configDlg, TQ_SIGNAL(finished()),
TQT_SLOT(slotHideConfigDialog())); TQ_SLOT(slotHideConfigDialog()));
} else { } else {
KWin::activateWindow(m_configDlg->winId()); KWin::activateWindow(m_configDlg->winId());
m_configDlg->show(); m_configDlg->show();
@ -1680,8 +1680,8 @@ void MainWindow::slotShowReportDialog() {
// myDebug() << "MainWindow::slotShowReport()" << endl; // myDebug() << "MainWindow::slotShowReport()" << endl;
if(!m_reportDlg) { if(!m_reportDlg) {
m_reportDlg = new ReportDialog(this); m_reportDlg = new ReportDialog(this);
connect(m_reportDlg, TQT_SIGNAL(finished()), connect(m_reportDlg, TQ_SIGNAL(finished()),
TQT_SLOT(slotHideReportDialog())); TQ_SLOT(slotHideReportDialog()));
} else { } else {
KWin::activateWindow(m_reportDlg->winId()); KWin::activateWindow(m_reportDlg->winId());
} }
@ -1783,14 +1783,14 @@ void MainWindow::slotShowFilterDialog() {
m_filterDlg = new FilterDialog(FilterDialog::CreateFilter, this); // allow saving m_filterDlg = new FilterDialog(FilterDialog::CreateFilter, this); // allow saving
m_filterDlg->setFilter(m_detailedView->filter()); m_filterDlg->setFilter(m_detailedView->filter());
m_quickFilter->setEnabled(false); m_quickFilter->setEnabled(false);
connect(m_filterDlg, TQT_SIGNAL(signalCollectionModified()), connect(m_filterDlg, TQ_SIGNAL(signalCollectionModified()),
Data::Document::self(), TQT_SLOT(slotSetModified())); Data::Document::self(), TQ_SLOT(slotSetModified()));
connect(m_filterDlg, TQT_SIGNAL(signalUpdateFilter(Tellico::FilterPtr)), connect(m_filterDlg, TQ_SIGNAL(signalUpdateFilter(Tellico::FilterPtr)),
m_quickFilter, TQT_SLOT(clear())); m_quickFilter, TQ_SLOT(clear()));
connect(m_filterDlg, TQT_SIGNAL(signalUpdateFilter(Tellico::FilterPtr)), connect(m_filterDlg, TQ_SIGNAL(signalUpdateFilter(Tellico::FilterPtr)),
Controller::self(), TQT_SLOT(slotUpdateFilter(Tellico::FilterPtr))); Controller::self(), TQ_SLOT(slotUpdateFilter(Tellico::FilterPtr)));
connect(m_filterDlg, TQT_SIGNAL(finished()), connect(m_filterDlg, TQ_SIGNAL(finished()),
TQT_SLOT(slotHideFilterDialog())); TQ_SLOT(slotHideFilterDialog()));
} else { } else {
KWin::activateWindow(m_filterDlg->winId()); KWin::activateWindow(m_filterDlg->winId());
} }
@ -1808,7 +1808,7 @@ void MainWindow::slotHideFilterDialog() {
void MainWindow::slotQueueFilter() { void MainWindow::slotQueueFilter() {
m_queuedFilters++; m_queuedFilters++;
TQTimer::singleShot(200, this, TQT_SLOT(slotUpdateFilter())); TQTimer::singleShot(200, this, TQ_SLOT(slotUpdateFilter()));
} }
void MainWindow::slotUpdateFilter() { void MainWindow::slotUpdateFilter() {
@ -1872,8 +1872,8 @@ void MainWindow::setFilter(const TQString& text_) {
void MainWindow::slotShowCollectionFieldsDialog() { void MainWindow::slotShowCollectionFieldsDialog() {
if(!m_collFieldsDlg) { if(!m_collFieldsDlg) {
m_collFieldsDlg = new CollectionFieldsDialog(Data::Document::self()->collection(), this); m_collFieldsDlg = new CollectionFieldsDialog(Data::Document::self()->collection(), this);
connect(m_collFieldsDlg, TQT_SIGNAL(finished()), connect(m_collFieldsDlg, TQ_SIGNAL(finished()),
TQT_SLOT(slotHideCollectionFieldsDialog())); TQ_SLOT(slotHideCollectionFieldsDialog()));
} else { } else {
KWin::activateWindow(m_collFieldsDlg->winId()); KWin::activateWindow(m_collFieldsDlg->winId());
} }
@ -1976,8 +1976,8 @@ void MainWindow::slotShowStringMacroDialog() {
m_stringMacroDlg = new StringMapDialog(c->macroList(), this, "StringMacroDialog", false); m_stringMacroDlg = new StringMapDialog(c->macroList(), this, "StringMacroDialog", false);
m_stringMacroDlg->setCaption(i18n("String Macros")); m_stringMacroDlg->setCaption(i18n("String Macros"));
m_stringMacroDlg->setLabels(i18n("Macro"), i18n("String")); m_stringMacroDlg->setLabels(i18n("Macro"), i18n("String"));
connect(m_stringMacroDlg, TQT_SIGNAL(finished()), TQT_SLOT(slotHideStringMacroDialog())); connect(m_stringMacroDlg, TQ_SIGNAL(finished()), TQ_SLOT(slotHideStringMacroDialog()));
connect(m_stringMacroDlg, TQT_SIGNAL(okClicked()), TQT_SLOT(slotStringMacroDialogOk())); connect(m_stringMacroDlg, TQ_SIGNAL(okClicked()), TQ_SLOT(slotStringMacroDialogOk()));
} else { } else {
KWin::activateWindow(m_stringMacroDlg->winId()); KWin::activateWindow(m_stringMacroDlg->winId());
} }
@ -2046,8 +2046,8 @@ void MainWindow::slotCiteEntry(int action_) {
void MainWindow::slotShowFetchDialog() { void MainWindow::slotShowFetchDialog() {
if(!m_fetchDlg) { if(!m_fetchDlg) {
m_fetchDlg = new FetchDialog(this); m_fetchDlg = new FetchDialog(this);
connect(m_fetchDlg, TQT_SIGNAL(finished()), TQT_SLOT(slotHideFetchDialog())); connect(m_fetchDlg, TQ_SIGNAL(finished()), TQ_SLOT(slotHideFetchDialog()));
connect(Controller::self(), TQT_SIGNAL(collectionAdded(int)), m_fetchDlg, TQT_SLOT(slotResetCollection())); connect(Controller::self(), TQ_SIGNAL(collectionAdded(int)), m_fetchDlg, TQ_SLOT(slotResetCollection()));
} else { } else {
KWin::activateWindow(m_fetchDlg->winId()); KWin::activateWindow(m_fetchDlg->winId());
} }
@ -2296,7 +2296,7 @@ void MainWindow::updateEntrySources() {
action->setText(it->source()); action->setText(it->source());
action->setToolTip(i18n("Update entry data from %1").arg(it->source())); action->setToolTip(i18n("Update entry data from %1").arg(it->source()));
action->setIconSet(Fetch::Manager::fetcherIcon(it.data())); action->setIconSet(Fetch::Manager::fetcherIcon(it.data()));
connect(action, TQT_SIGNAL(activated()), mapper, TQT_SLOT(map())); connect(action, TQ_SIGNAL(activated()), mapper, TQ_SLOT(map()));
mapper->setMapping(action, it->source()); mapper->setMapping(action, it->source());
m_fetchActions.append(action); m_fetchActions.append(action);
} }

@ -122,7 +122,7 @@ Dialog::Dialog(NewStuff::DataType type_, TQWidget* parent_)
m_listView->addColumn(i18n("Release Date")); m_listView->addColumn(i18n("Release Date"));
m_listView->setSorting(2, false); m_listView->setSorting(2, false);
m_listView->setResizeMode(TQListView::AllColumns); m_listView->setResizeMode(TQListView::AllColumns);
connect(m_listView, TQT_SIGNAL(clicked(TQListViewItem*)), TQT_SLOT(slotSelected(TQListViewItem*))); connect(m_listView, TQ_SIGNAL(clicked(TQListViewItem*)), TQ_SLOT(slotSelected(TQListViewItem*)));
TQWhatsThis::add(m_listView, i18n("This is a list of all the items available for download. " TQWhatsThis::add(m_listView, i18n("This is a list of all the items available for download. "
"Previously installed items have a checkmark icon, while " "Previously installed items have a checkmark icon, while "
"items with new version available have an update icon")); "items with new version available have an update icon"));
@ -147,7 +147,7 @@ Dialog::Dialog(NewStuff::DataType type_, TQWidget* parent_)
m_install = new KPushButton(i18n("Install"), widget); m_install = new KPushButton(i18n("Install"), widget);
m_install->setIconSet(SmallIconSet(TQString::fromLatin1("knewstuff"))); m_install->setIconSet(SmallIconSet(TQString::fromLatin1("knewstuff")));
m_install->setEnabled(false); m_install->setEnabled(false);
connect(m_install, TQT_SIGNAL(clicked()), TQT_SLOT(slotInstall())); connect(m_install, TQ_SIGNAL(clicked()), TQ_SLOT(slotInstall()));
// the button's text changes later // the button's text changes later
// I don't want it resizing, so figure out the maximum size and set that // I don't want it resizing, so figure out the maximum size and set that
@ -211,10 +211,10 @@ Dialog::Dialog(NewStuff::DataType type_, TQWidget* parent_)
m_statusBar->addWidget(m_progress, 0, true); m_statusBar->addWidget(m_progress, 0, true);
KPushButton* closeButton = new KPushButton(KStdGuiItem::close(), box); KPushButton* closeButton = new KPushButton(KStdGuiItem::close(), box);
connect(closeButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotClose())); connect(closeButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotClose()));
closeButton->setFocus(); closeButton->setFocus();
connect(m_timer, TQT_SIGNAL(timeout()), TQT_SLOT(slotMoveProgress())); connect(m_timer, TQ_SIGNAL(timeout()), TQ_SLOT(slotMoveProgress()));
setMinimumWidth(TQMAX(minimumWidth(), NEW_STUFF_MIN_WIDTH)); setMinimumWidth(TQMAX(minimumWidth(), NEW_STUFF_MIN_WIDTH));
setMinimumHeight(TQMAX(minimumHeight(), NEW_STUFF_MIN_HEIGHT)); setMinimumHeight(TQMAX(minimumHeight(), NEW_STUFF_MIN_HEIGHT));
@ -229,9 +229,9 @@ Dialog::Dialog(NewStuff::DataType type_, TQWidget* parent_)
setStatus(i18n("Downloading information...")); setStatus(i18n("Downloading information..."));
KNS::ProviderLoader* loader = new KNS::ProviderLoader(this); KNS::ProviderLoader* loader = new KNS::ProviderLoader(this);
connect(loader, TQT_SIGNAL(providersLoaded(Provider::List*)), this, TQT_SLOT(slotProviders(Provider::List*))); connect(loader, TQ_SIGNAL(providersLoaded(Provider::List*)), this, TQ_SLOT(slotProviders(Provider::List*)));
connect(loader, TQT_SIGNAL(percent(TDEIO::Job*, unsigned long)), this, TQT_SLOT(slotShowPercent(TDEIO::Job*, unsigned long))); connect(loader, TQ_SIGNAL(percent(TDEIO::Job*, unsigned long)), this, TQ_SLOT(slotShowPercent(TDEIO::Job*, unsigned long)));
connect(loader, TQT_SIGNAL(error()), this, TQT_SLOT(slotProviderError())); connect(loader, TQ_SIGNAL(error()), this, TQ_SLOT(slotProviderError()));
TDEConfigGroup config(TDEGlobal::config(), "TDENewStuff"); TDEConfigGroup config(TDEGlobal::config(), "TDENewStuff");
TQString prov = config.readEntry("ProvidersUrl"); TQString prov = config.readEntry("ProvidersUrl");
@ -271,11 +271,11 @@ void Dialog::slotProviders(Provider::List* list_) {
for(KNS::Provider* prov = list_->first(); prov; prov = list_->next()) { for(KNS::Provider* prov = list_->first(); prov; prov = list_->next()) {
TDEIO::TransferJob* job = TDEIO::get(prov->downloadUrl()); TDEIO::TransferJob* job = TDEIO::get(prov->downloadUrl());
m_jobs[job] = prov; m_jobs[job] = prov;
connect(job, TQT_SIGNAL(data(TDEIO::Job*, const TQByteArray&)), connect(job, TQ_SIGNAL(data(TDEIO::Job*, const TQByteArray&)),
TQT_SLOT(slotData(TDEIO::Job*, const TQByteArray&))); TQ_SLOT(slotData(TDEIO::Job*, const TQByteArray&)));
connect(job, TQT_SIGNAL(result(TDEIO::Job*)), TQT_SLOT(slotResult(TDEIO::Job*))); connect(job, TQ_SIGNAL(result(TDEIO::Job*)), TQ_SLOT(slotResult(TDEIO::Job*)));
connect(job, TQT_SIGNAL(percent(TDEIO::Job*, unsigned long)), connect(job, TQ_SIGNAL(percent(TDEIO::Job*, unsigned long)),
TQT_SLOT(slotShowPercent(TDEIO::Job*, unsigned long))); TQ_SLOT(slotShowPercent(TDEIO::Job*, unsigned long)));
} }
} }
@ -375,9 +375,9 @@ void Dialog::slotSelected(TQListViewItem* item_) {
KURL dest; KURL dest;
dest.setPath(m_tempPreviewImage->name()); dest.setPath(m_tempPreviewImage->name());
TDEIO::FileCopyJob* job = TDEIO::file_copy(preview, dest, -1, true, false, false); TDEIO::FileCopyJob* job = TDEIO::file_copy(preview, dest, -1, true, false, false);
connect(job, TQT_SIGNAL(result(TDEIO::Job*)), TQT_SLOT(slotPreviewResult(TDEIO::Job*))); connect(job, TQ_SIGNAL(result(TDEIO::Job*)), TQ_SLOT(slotPreviewResult(TDEIO::Job*)));
connect(job, TQT_SIGNAL(percent(TDEIO::Job*, unsigned long)), connect(job, TQ_SIGNAL(percent(TDEIO::Job*, unsigned long)),
TQT_SLOT(slotShowPercent(TDEIO::Job*, unsigned long))); TQ_SLOT(slotShowPercent(TDEIO::Job*, unsigned long)));
m_lastPreviewItem = item_; m_lastPreviewItem = item_;
} }
TQPixmap pix = m_type == EntryTemplate TQPixmap pix = m_type == EntryTemplate
@ -423,7 +423,7 @@ void Dialog::slotInstall() {
setStatus(i18n("Installing item...")); setStatus(i18n("Installing item..."));
m_progress->show(); m_progress->show();
m_timer->start(100); m_timer->start(100);
connect(m_manager, TQT_SIGNAL(signalInstalled(KNS::Entry*)), TQT_SLOT(slotDoneInstall(KNS::Entry*))); connect(m_manager, TQ_SIGNAL(signalInstalled(KNS::Entry*)), TQ_SLOT(slotDoneInstall(KNS::Entry*)));
mJobEntry = entry; mJobEntry = entry;
// OpenDesktop.org broke the basic functionality of TDEHNS by forcing // OpenDesktop.org broke the basic functionality of TDEHNS by forcing
@ -437,10 +437,10 @@ void Dialog::slotInstall() {
// in the direct download ability for this to even be considered. // in the direct download ability for this to even be considered.
if (entry->payload().url().contains(OPENDESKTOP_REDIRECT_URL)) { if (entry->payload().url().contains(OPENDESKTOP_REDIRECT_URL)) {
TDEIO::TransferJob *job = TDEIO::get( KURL( entry->payload() ), false, false ); TDEIO::TransferJob *job = TDEIO::get( KURL( entry->payload() ), false, false );
connect( job, TQT_SIGNAL( result( TDEIO::Job * ) ), connect( job, TQ_SIGNAL( result( TDEIO::Job * ) ),
TQT_SLOT( slotJobResult( TDEIO::Job * ) ) ); TQ_SLOT( slotJobResult( TDEIO::Job * ) ) );
connect( job, TQT_SIGNAL( data( TDEIO::Job *, const TQByteArray & ) ), connect( job, TQ_SIGNAL( data( TDEIO::Job *, const TQByteArray & ) ),
TQT_SLOT( slotJobData( TDEIO::Job *, const TQByteArray & ) ) ); TQ_SLOT( slotJobData( TDEIO::Job *, const TQByteArray & ) ) );
} }
else { else {
slotInstallPhase2(); slotInstallPhase2();

@ -347,7 +347,7 @@ void Manager::install(DataType type_, KNS::Entry* entry_) {
KURL destination; KURL destination;
destination.setPath(m_tempFile->name()); destination.setPath(m_tempFile->name());
TDEIO::FileCopyJob* job = TDEIO::file_copy(entry_->payload(), destination, -1, true); TDEIO::FileCopyJob* job = TDEIO::file_copy(entry_->payload(), destination, -1, true);
connect(job, TQT_SIGNAL(result(TDEIO::Job*)), TQT_SLOT(slotDownloadJobResult(TDEIO::Job*))); connect(job, TQ_SIGNAL(result(TDEIO::Job*)), TQ_SLOT(slotDownloadJobResult(TDEIO::Job*)));
m_jobMap.insert(job, EntryPair(entry_, type_)); m_jobMap.insert(job, EntryPair(entry_, type_));
} }
@ -377,7 +377,7 @@ void Manager::slotDownloadJobResult(TDEIO::Job* job_) {
#if KDE_IS_VERSION(3,3,90) #if KDE_IS_VERSION(3,3,90)
// needed so the GPG signature can be checked // needed so the GPG signature can be checked
NewScript* newScript = new NewScript(this, Kernel::self()->widget()); NewScript* newScript = new NewScript(this, Kernel::self()->widget());
connect(newScript, TQT_SIGNAL(installFinished()), this, TQT_SLOT(slotInstallFinished())); connect(newScript, TQ_SIGNAL(installFinished()), this, TQ_SLOT(slotInstallFinished()));
// need to delete temp file if install was not a success // need to delete temp file if install was not a success
// if it was a success, it gets deleted later // if it was a success, it gets deleted later
deleteTempFile = !newScript->install(job->destURL().path()); deleteTempFile = !newScript->install(job->destURL().path());

@ -56,7 +56,7 @@ void ProgressItem::setDone() {
} }
emit signalDone(this); emit signalDone(this);
// make sure the deleting doesn't interfere with anything // make sure the deleting doesn't interfere with anything
TQTimer::singleShot(3000, this, TQT_SLOT(deleteLater())); TQTimer::singleShot(3000, this, TQ_SLOT(deleteLater()));
} }
void ProgressItem::cancel() { void ProgressItem::cancel() {
@ -131,12 +131,12 @@ ProgressItem& ProgressManager::newProgressItemImpl(const TQObject* owner_,
ProgressItem* item = new ProgressItem(label_, canCancel_); ProgressItem* item = new ProgressItem(label_, canCancel_);
m_items.insert(owner_, item); m_items.insert(owner_, item);
connect(item, TQT_SIGNAL(signalTotalSteps(ProgressItem*)), TQT_SLOT(slotUpdateTotalProgress())); connect(item, TQ_SIGNAL(signalTotalSteps(ProgressItem*)), TQ_SLOT(slotUpdateTotalProgress()));
connect(item, TQT_SIGNAL(signalProgress(ProgressItem*)), TQT_SLOT(slotUpdateTotalProgress())); connect(item, TQ_SIGNAL(signalProgress(ProgressItem*)), TQ_SLOT(slotUpdateTotalProgress()));
connect(item, TQT_SIGNAL(signalDone(ProgressItem*)), TQT_SLOT(slotUpdateTotalProgress())); connect(item, TQ_SIGNAL(signalDone(ProgressItem*)), TQ_SLOT(slotUpdateTotalProgress()));
connect(item, TQT_SIGNAL(signalDone(ProgressItem*)), TQT_SLOT(slotItemDone(ProgressItem*))); connect(item, TQ_SIGNAL(signalDone(ProgressItem*)), TQ_SLOT(slotItemDone(ProgressItem*)));
// connect(item, TQT_SIGNAL(signalProgress(ProgressItem*)), TQT_SIGNAL(signalItemProgress(ProgressItem*))); // connect(item, TQ_SIGNAL(signalProgress(ProgressItem*)), TQ_SIGNAL(signalItemProgress(ProgressItem*)));
// emit signalItemAdded(item); // emit signalItemAdded(item);
return *item; return *item;
} }

@ -82,17 +82,17 @@ ReportDialog::ReportDialog(TQWidget* parent_, const char* name_/*=0*/)
KPushButton* pb1 = new KPushButton(SmallIconSet(TQString::fromLatin1("application-x-executable")), i18n("&Generate"), mainWidget); KPushButton* pb1 = new KPushButton(SmallIconSet(TQString::fromLatin1("application-x-executable")), i18n("&Generate"), mainWidget);
hlay->addWidget(pb1); hlay->addWidget(pb1);
connect(pb1, TQT_SIGNAL(clicked()), TQT_SLOT(slotGenerate())); connect(pb1, TQ_SIGNAL(clicked()), TQ_SLOT(slotGenerate()));
hlay->addStretch(); hlay->addStretch();
KPushButton* pb2 = new KPushButton(KStdGuiItem::saveAs(), mainWidget); KPushButton* pb2 = new KPushButton(KStdGuiItem::saveAs(), mainWidget);
hlay->addWidget(pb2); hlay->addWidget(pb2);
connect(pb2, TQT_SIGNAL(clicked()), TQT_SLOT(slotSaveAs())); connect(pb2, TQ_SIGNAL(clicked()), TQ_SLOT(slotSaveAs()));
KPushButton* pb3 = new KPushButton(KStdGuiItem::print(), mainWidget); KPushButton* pb3 = new KPushButton(KStdGuiItem::print(), mainWidget);
hlay->addWidget(pb3); hlay->addWidget(pb3);
connect(pb3, TQT_SIGNAL(clicked()), TQT_SLOT(slotPrint())); connect(pb3, TQ_SIGNAL(clicked()), TQ_SLOT(slotPrint()));
m_HTMLPart = new TDEHTMLPart(mainWidget); m_HTMLPart = new TDEHTMLPart(mainWidget);
m_HTMLPart->setJScriptEnabled(false); m_HTMLPart->setJScriptEnabled(false);

@ -54,8 +54,8 @@ StatusBar::StatusBar(TQWidget* parent_) : KStatusBar(parent_) {
m_cancelButton->hide(); m_cancelButton->hide();
ProgressManager* pm = ProgressManager::self(); ProgressManager* pm = ProgressManager::self();
connect(pm, TQT_SIGNAL(signalTotalProgress(uint)), TQT_SLOT(slotProgress(uint))); connect(pm, TQ_SIGNAL(signalTotalProgress(uint)), TQ_SLOT(slotProgress(uint)));
connect(m_cancelButton, TQT_SIGNAL(clicked()), pm, TQT_SLOT(slotCancelAll())); connect(m_cancelButton, TQ_SIGNAL(clicked()), pm, TQ_SLOT(slotCancelAll()));
} }
void StatusBar::polish() { void StatusBar::polish() {
@ -110,10 +110,10 @@ void StatusBar::slotUpdate() {
/* /*
myDebug() << "StatusBar::slotUpdate() - " << m_progress->isShown() << endl; myDebug() << "StatusBar::slotUpdate() - " << m_progress->isShown() << endl;
if(m_progressBox->isEmpty()) { if(m_progressBox->isEmpty()) {
TQTimer::singleShot(0, m_progress, TQT_SLOT(hide())); TQTimer::singleShot(0, m_progress, TQ_SLOT(hide()));
// m_progressBox->hide(); // m_progressBox->hide();
} else { } else {
TQTimer::singleShot(0, m_progress, TQT_SLOT(show())); TQTimer::singleShot(0, m_progress, TQ_SLOT(show()));
// m_progressBox->show(); // m_progressBox->show();
} }
*/ */

@ -65,7 +65,7 @@ Tellico::Data::CollPtr AlexandriaImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(numFiles); item.setTotalSteps(numFiles);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
TQStringList covers; TQStringList covers;

@ -72,7 +72,7 @@ Tellico::Data::CollPtr AMCImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(f->size()); item.setTotalSteps(f->size());
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
m_coll = new Data::VideoCollection(true); m_coll = new Data::VideoCollection(true);

@ -70,7 +70,7 @@ Tellico::Data::CollPtr AudioFileImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, i18n("Scanning audio files..."), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, i18n("Scanning audio files..."), true);
item.setTotalSteps(100); item.setTotalSteps(100);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
// TODO: allow remote audio file importing // TODO: allow remote audio file importing
@ -350,7 +350,7 @@ TQWidget* AudioFileImporter::widget(TQWidget* parent_, const char* name_) {
m_addFilePath = new TQCheckBox(i18n("Include file &location"), box); m_addFilePath = new TQCheckBox(i18n("Include file &location"), box);
TQWhatsThis::add(m_addFilePath, i18n("If checked, the file names for each track are added to the entries.")); TQWhatsThis::add(m_addFilePath, i18n("If checked, the file names for each track are added to the entries."));
m_addFilePath->setChecked(false); m_addFilePath->setChecked(false);
connect(m_addFilePath, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotAddFileToggled(bool))); connect(m_addFilePath, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotAddFileToggled(bool)));
m_addBitrate = new TQCheckBox(i18n("Include &bitrate"), box); m_addBitrate = new TQCheckBox(i18n("Include &bitrate"), box);
TQWhatsThis::add(m_addBitrate, i18n("If checked, the bitrate for each track is added to the entries.")); TQWhatsThis::add(m_addBitrate, i18n("If checked, the bitrate for each track is added to the entries."));

@ -62,7 +62,7 @@ Tellico::Data::CollPtr BibtexImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(urls().count() * 100); item.setTotalSteps(urls().count() * 100);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
bool useUTF8 = m_widget && m_readUTF8->isChecked(); bool useUTF8 = m_widget && m_readUTF8->isChecked();

@ -56,7 +56,7 @@ void BibtexmlImporter::loadDomDocument() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(count); item.setTotalSteps(count);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
for(uint j = 0; !m_cancelled && j < entryelems.count(); ++j) { for(uint j = 0; !m_cancelled && j < entryelems.count(); ++j) {

@ -145,8 +145,8 @@ TQWidget* CSVExporter::widget(TQWidget* parent_, const char* name_/*=0*/) {
m_editOther->setEnabled(m_radioOther->isChecked()); m_editOther->setEnabled(m_radioOther->isChecked());
TQWhatsThis::add(m_editOther, i18n("A custom string, such as a colon, may be used as a delimiter.")); TQWhatsThis::add(m_editOther, i18n("A custom string, such as a colon, may be used as a delimiter."));
m_delimiterGroupLayout->addWidget(m_editOther, 1, 2); m_delimiterGroupLayout->addWidget(m_editOther, 1, 2);
TQObject::connect(m_radioOther, TQT_SIGNAL(toggled(bool)), TQObject::connect(m_radioOther, TQ_SIGNAL(toggled(bool)),
m_editOther, TQT_SLOT(setEnabled(bool))); m_editOther, TQ_SLOT(setEnabled(bool)));
if(m_delimiter == TQChar(',')) { if(m_delimiter == TQChar(',')) {
m_radioComma->setChecked(true); m_radioComma->setChecked(true);

@ -189,7 +189,7 @@ Tellico::Data::CollPtr CSVImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(numLines); item.setTotalSteps(numLines);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
uint j = 0; uint j = 0;
@ -253,14 +253,14 @@ TQWidget* CSVImporter::widget(TQWidget* parent_, const char* name_) {
m_comboColl = new GUI::CollectionTypeCombo(box); m_comboColl = new GUI::CollectionTypeCombo(box);
lab->setBuddy(m_comboColl); lab->setBuddy(m_comboColl);
TQWhatsThis::add(m_comboColl, i18n("Select the type of collection being imported.")); TQWhatsThis::add(m_comboColl, i18n("Select the type of collection being imported."));
connect(m_comboColl, TQT_SIGNAL(activated(int)), TQT_SLOT(slotTypeChanged())); connect(m_comboColl, TQ_SIGNAL(activated(int)), TQ_SLOT(slotTypeChanged()));
// need a spacer // need a spacer
TQWidget* w = new TQWidget(box); TQWidget* w = new TQWidget(box);
box->setStretchFactor(w, 1); box->setStretchFactor(w, 1);
m_checkFirstRowHeader = new TQCheckBox(i18n("&First row contains field titles"), group); m_checkFirstRowHeader = new TQCheckBox(i18n("&First row contains field titles"), group);
TQWhatsThis::add(m_checkFirstRowHeader, i18n("If checked, the first row is used as field titles.")); TQWhatsThis::add(m_checkFirstRowHeader, i18n("If checked, the first row is used as field titles."));
connect(m_checkFirstRowHeader, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotFirstRowHeader(bool))); connect(m_checkFirstRowHeader, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotFirstRowHeader(bool)));
TQHBox* hbox2 = new TQHBox(group); TQHBox* hbox2 = new TQHBox(group);
m_delimiterGroup = new TQButtonGroup(0, TQt::Vertical, i18n("Delimiter"), hbox2); m_delimiterGroup = new TQButtonGroup(0, TQt::Vertical, i18n("Delimiter"), hbox2);
@ -268,7 +268,7 @@ TQWidget* CSVImporter::widget(TQWidget* parent_, const char* name_) {
m_delimiterGroupLayout->setAlignment(TQt::AlignTop); m_delimiterGroupLayout->setAlignment(TQt::AlignTop);
TQWhatsThis::add(m_delimiterGroup, i18n("In addition to a comma, other characters may be used as " TQWhatsThis::add(m_delimiterGroup, i18n("In addition to a comma, other characters may be used as "
"a delimiter, separating each value in the file.")); "a delimiter, separating each value in the file."));
connect(m_delimiterGroup, TQT_SIGNAL(clicked(int)), TQT_SLOT(slotDelimiter())); connect(m_delimiterGroup, TQ_SIGNAL(clicked(int)), TQ_SLOT(slotDelimiter()));
m_radioComma = new TQRadioButton(m_delimiterGroup); m_radioComma = new TQRadioButton(m_delimiterGroup);
m_radioComma->setText(i18n("&Comma")); m_radioComma->setText(i18n("&Comma"));
@ -297,9 +297,9 @@ TQWidget* CSVImporter::widget(TQWidget* parent_, const char* name_) {
m_editOther->setMaxLength(1); m_editOther->setMaxLength(1);
TQWhatsThis::add(m_editOther, i18n("A custom string, such as a colon, may be used as a delimiter.")); TQWhatsThis::add(m_editOther, i18n("A custom string, such as a colon, may be used as a delimiter."));
m_delimiterGroupLayout->addWidget(m_editOther, 2, 2); m_delimiterGroupLayout->addWidget(m_editOther, 2, 2);
connect(m_radioOther, TQT_SIGNAL(toggled(bool)), connect(m_radioOther, TQ_SIGNAL(toggled(bool)),
m_editOther, TQT_SLOT(setEnabled(bool))); m_editOther, TQ_SLOT(setEnabled(bool)));
connect(m_editOther, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotDelimiter())); connect(m_editOther, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotDelimiter()));
w = new TQWidget(hbox2); w = new TQWidget(hbox2);
hbox2->setStretchFactor(w, 1); hbox2->setStretchFactor(w, 1);
@ -313,8 +313,8 @@ TQWidget* CSVImporter::widget(TQWidget* parent_, const char* name_) {
m_table->setReadOnly(true); m_table->setReadOnly(true);
m_table->setMinimumHeight(m_widget->fontMetrics().lineSpacing() * 8); m_table->setMinimumHeight(m_widget->fontMetrics().lineSpacing() * 8);
TQWhatsThis::add(m_table, i18n("The table shows up to the first five lines of the CSV file.")); TQWhatsThis::add(m_table, i18n("The table shows up to the first five lines of the CSV file."));
connect(m_table, TQT_SIGNAL(currentChanged(int, int)), TQT_SLOT(slotCurrentChanged(int, int))); connect(m_table, TQ_SIGNAL(currentChanged(int, int)), TQ_SLOT(slotCurrentChanged(int, int)));
connect(m_table->horizontalHeader(), TQT_SIGNAL(clicked(int)), TQT_SLOT(slotHeaderClicked(int))); connect(m_table->horizontalHeader(), TQ_SIGNAL(clicked(int)), TQ_SLOT(slotHeaderClicked(int)));
TQWidget* hbox = new TQWidget(group); TQWidget* hbox = new TQWidget(group);
TQHBoxLayout* hlay = new TQHBoxLayout(hbox, 5); TQHBoxLayout* hlay = new TQHBoxLayout(hbox, 5);
@ -326,7 +326,7 @@ TQWidget* CSVImporter::widget(TQWidget* parent_, const char* name_) {
m_colSpinBox = new KIntSpinBox(hbox); m_colSpinBox = new KIntSpinBox(hbox);
hlay->addWidget(m_colSpinBox); hlay->addWidget(m_colSpinBox);
m_colSpinBox->setMinValue(1); m_colSpinBox->setMinValue(1);
connect(m_colSpinBox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotSelectColumn(int))); connect(m_colSpinBox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotSelectColumn(int)));
lab->setBuddy(m_colSpinBox); lab->setBuddy(m_colSpinBox);
hlay->addSpacing(10); hlay->addSpacing(10);
@ -334,14 +334,14 @@ TQWidget* CSVImporter::widget(TQWidget* parent_, const char* name_) {
hlay->addWidget(lab); hlay->addWidget(lab);
m_comboField = new KComboBox(hbox); m_comboField = new KComboBox(hbox);
hlay->addWidget(m_comboField); hlay->addWidget(m_comboField);
connect(m_comboField, TQT_SIGNAL(activated(int)), TQT_SLOT(slotFieldChanged(int))); connect(m_comboField, TQ_SIGNAL(activated(int)), TQ_SLOT(slotFieldChanged(int)));
lab->setBuddy(m_comboField); lab->setBuddy(m_comboField);
hlay->addSpacing(10); hlay->addSpacing(10);
m_setColumnBtn = new KPushButton(i18n("&Assign Field"), hbox); m_setColumnBtn = new KPushButton(i18n("&Assign Field"), hbox);
hlay->addWidget(m_setColumnBtn); hlay->addWidget(m_setColumnBtn);
m_setColumnBtn->setIconSet(SmallIconSet(TQString::fromLatin1("apply"))); m_setColumnBtn->setIconSet(SmallIconSet(TQString::fromLatin1("apply")));
connect(m_setColumnBtn, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetColumnTitle())); connect(m_setColumnBtn, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetColumnTitle()));
hlay->addStretch(10); hlay->addStretch(10);
l->addStretch(1); l->addStretch(1);

@ -62,7 +62,7 @@ Tellico::Data::CollPtr FileListingImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, i18n("Scanning files..."), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, i18n("Scanning files..."), true);
item.setTotalSteps(100); item.setTotalSteps(100);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
// going to assume only one volume will ever be imported // going to assume only one volume will ever be imported
@ -71,8 +71,8 @@ Tellico::Data::CollPtr FileListingImporter::collection() {
m_job = m_recursive->isChecked() m_job = m_recursive->isChecked()
? TDEIO::listRecursive(url(), true, false) ? TDEIO::listRecursive(url(), true, false)
: TDEIO::listDir(url(), true, false); : TDEIO::listDir(url(), true, false);
connect(m_job, TQT_SIGNAL(entries(TDEIO::Job*, const TDEIO::UDSEntryList&)), connect(m_job, TQ_SIGNAL(entries(TDEIO::Job*, const TDEIO::UDSEntryList&)),
TQT_SLOT(slotEntries(TDEIO::Job*, const TDEIO::UDSEntryList&))); TQ_SLOT(slotEntries(TDEIO::Job*, const TDEIO::UDSEntryList&)));
if(!TDEIO::NetAccess::synchronousRun(m_job, Kernel::self()->widget()) || m_cancelled) { if(!TDEIO::NetAccess::synchronousRun(m_job, Kernel::self()->widget()) || m_cancelled) {
return 0; return 0;

@ -340,7 +340,7 @@ void FreeDBImporter::readCache() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(numFiles); item.setTotalSteps(numFiles);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
uint step = 1; uint step = 1;
@ -509,7 +509,7 @@ TQWidget* FreeDBImporter::widget(TQWidget* parent_, const char* name_/*=0*/) {
m_buttonGroup->setExclusive(true); m_buttonGroup->setExclusive(true);
m_buttonGroup->insert(m_radioCDROM); m_buttonGroup->insert(m_radioCDROM);
m_buttonGroup->insert(m_radioCache); m_buttonGroup->insert(m_radioCache);
connect(m_buttonGroup, TQT_SIGNAL(clicked(int)), TQT_SLOT(slotClicked(int))); connect(m_buttonGroup, TQ_SIGNAL(clicked(int)), TQ_SLOT(slotClicked(int)));
l->addWidget(bigbox); l->addWidget(bigbox);
l->addStretch(1); l->addStretch(1);

@ -49,7 +49,7 @@ Tellico::Data::CollPtr GCfilmsImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(100); item.setTotalSteps(100);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
TQString str = text(); TQString str = text();

@ -53,9 +53,9 @@ Tellico::Data::CollPtr GriffithImporter::collection() {
} }
m_process = new TDEProcess(); m_process = new TDEProcess();
connect(m_process, TQT_SIGNAL(receivedStdout(TDEProcess*, char*, int)), TQT_SLOT(slotData(TDEProcess*, char*, int))); connect(m_process, TQ_SIGNAL(receivedStdout(TDEProcess*, char*, int)), TQ_SLOT(slotData(TDEProcess*, char*, int)));
connect(m_process, TQT_SIGNAL(receivedStderr(TDEProcess*, char*, int)), TQT_SLOT(slotError(TDEProcess*, char*, int))); connect(m_process, TQ_SIGNAL(receivedStderr(TDEProcess*, char*, int)), TQ_SLOT(slotError(TDEProcess*, char*, int)));
connect(m_process, TQT_SIGNAL(processExited(TDEProcess*)), TQT_SLOT(slotProcessExited(TDEProcess*))); connect(m_process, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(slotProcessExited(TDEProcess*)));
*m_process << python << griffith; *m_process << python << griffith;
if(!m_process->start(TDEProcess::Block, TDEProcess::AllOutput)) { if(!m_process->start(TDEProcess::Block, TDEProcess::AllOutput)) {
myDebug() << "ExecExternalFetcher::startSearch() - process failed to start" << endl; myDebug() << "ExecExternalFetcher::startSearch() - process failed to start" << endl;

@ -121,7 +121,7 @@ bool HTMLExporter::exec() {
if(options() & ExportProgress) { if(options() & ExportProgress) {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, TQString(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, TQString(), true);
item.setTotalSteps(100); item.setTotalSteps(100);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
} }
// ok if not ExportProgress, no worries // ok if not ExportProgress, no worries
ProgressItem::Done done(this); ProgressItem::Done done(this);

@ -56,7 +56,7 @@ Tellico::Data::CollPtr PDFImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(urls().count()); item.setTotalSteps(urls().count());
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
const bool showProgress = options() & ImportProgress; const bool showProgress = options() & ImportProgress;

@ -150,7 +150,7 @@ Tellico::Data::CollPtr RISImporter::collection() {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(urls().count() * 100); item.setTotalSteps(urls().count() * 100);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
int count = 0; int count = 0;

@ -97,7 +97,7 @@ Tellico::Data::CollPtr TellicoImporter::collection() {
void TellicoImporter::loadXMLData(const TQByteArray& data_, bool loadImages_) { void TellicoImporter::loadXMLData(const TQByteArray& data_, bool loadImages_) {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(100); item.setTotalSteps(100);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
TQDomDocument dom; TQDomDocument dom;
@ -872,7 +872,7 @@ void TellicoImporter::loadZipData() {
if(m_images.isEmpty()) { if(m_images.isEmpty()) {
// give it some time // give it some time
TQTimer::singleShot(3000, this, TQT_SLOT(deleteLater())); TQTimer::singleShot(3000, this, TQ_SLOT(deleteLater()));
} }
} }
@ -890,7 +890,7 @@ bool TellicoImporter::loadImage(const TQString& id_) {
m_images.remove(id_); m_images.remove(id_);
if(m_images.isEmpty()) { if(m_images.isEmpty()) {
// give it some time // give it some time
TQTimer::singleShot(3000, this, TQT_SLOT(deleteLater())); TQTimer::singleShot(3000, this, TQ_SLOT(deleteLater()));
} }
return !newID.isEmpty(); return !newID.isEmpty();
} }

@ -98,7 +98,7 @@ Tellico::Data::CollPtr TellicoSaxImporter::collection() {
void TellicoSaxImporter::loadXMLData(const TQByteArray& data_, bool loadImages_) { void TellicoSaxImporter::loadXMLData(const TQByteArray& data_, bool loadImages_) {
ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, progressLabel(), true);
item.setTotalSteps(data_.size()); item.setTotalSteps(data_.size());
connect(&item, SIGNAL(signalCancelled(ProgressItem*)), SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
const bool showProgress = options() & ImportProgress; const bool showProgress = options() & ImportProgress;
@ -258,7 +258,7 @@ void TellicoSaxImporter::loadZipData() {
if(m_images.isEmpty()) { if(m_images.isEmpty()) {
// give it some time // give it some time
TQTimer::singleShot(3000, this, SLOT(deleteLater())); TQTimer::singleShot(3000, this, TQ_SLOT(deleteLater()));
} }
} }
@ -280,7 +280,7 @@ bool TellicoSaxImporter::loadImage(const TQString& id_) {
m_images.remove(id_); m_images.remove(id_);
if(m_images.isEmpty()) { if(m_images.isEmpty()) {
// give it some time // give it some time
TQTimer::singleShot(3000, this, SLOT(deleteLater())); TQTimer::singleShot(3000, this, TQ_SLOT(deleteLater()));
} }
return !newID.isEmpty(); return !newID.isEmpty();
} }

@ -49,7 +49,7 @@ bool TellicoZipExporter::exec() {
// TODO: maybe need label? // TODO: maybe need label?
ProgressItem& item = ProgressManager::self()->newProgressItem(this, TQString(), true); ProgressItem& item = ProgressManager::self()->newProgressItem(this, TQString(), true);
item.setTotalSteps(100); item.setTotalSteps(100);
connect(&item, TQT_SIGNAL(signalCancelled(ProgressItem*)), TQT_SLOT(slotCancel())); connect(&item, TQ_SIGNAL(signalCancelled(ProgressItem*)), TQ_SLOT(slotCancel()));
ProgressItem::Done done(this); ProgressItem::Done done(this);
TellicoXMLExporter exp; TellicoXMLExporter exp;

Loading…
Cancel
Save