TDE
/
krusader
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/krusader
0
0
Fork 0
Code Issues Releases Wiki Activity

Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Browse Source 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 184496dac0)
r14.1.x
Michele Calgaro 10 months ago
parent 2c9c9759a5
commit 1570bf7f37
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF
97 changed files with 987 additions and 987 deletions
Show Stats Download Patch File Download Diff File

8
krArc/krarc.cpp
Unescape View File

@ -314,8 +314,8 @@ void tdeio_krarcProtocol::get(const KURL& url, int tries ){
emit mimeType( mt->name() );
proc << getCmd << convertName( arcFile->url().path() )+" ";
if( arcType != "gzip" && arcType != "bzip2" && arcType != "xz") proc << convertFileName( file );
connect(&proc,TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
this,TQT_SLOT(receivedData(TDEProcess*,char*,int)) );
connect(&proc,TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
this,TQ_SLOT(receivedData(TDEProcess*,char*,int)) );
}
infoMessage(i18n("Unpacking %1 ...").arg( url.fileName() ) );
// change the working directory to our arcTempDir
@ -1531,8 +1531,8 @@ TQString tdeio_krarcProtocol::detectArchive( bool &encrypted, TQString fileName
KrShellProcess proc;
proc << testCmd << convertName( fileName );
connect( &proc, TQT_SIGNAL( receivedStdout(TDEProcess*,char*,int) ),
this, TQT_SLOT( checkOutputForPassword( TDEProcess*,char*,int ) ) );
connect( &proc, TQ_SIGNAL( receivedStdout(TDEProcess*,char*,int) ),
this, TQ_SLOT( checkOutputForPassword( TDEProcess*,char*,int ) ) );
proc.start(TDEProcess::Block,TDEProcess::AllOutput);
encrypted = this->encrypted;

8
krArc/krarc.h
Unescape View File

@ -109,10 +109,10 @@ class KrShellProcess : public KShellProcess {
public:
KrShellProcess() : KShellProcess(), errorMsg( TQString() ), outputMsg( TQString() ) {
connect(this,TQT_SIGNAL(receivedStderr(TDEProcess*,char*,int)),
this,TQT_SLOT(receivedErrorMsg(TDEProcess*,char*,int)) );
connect(this,TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
this,TQT_SLOT(receivedOutputMsg(TDEProcess*,char*,int)) );
connect(this,TQ_SIGNAL(receivedStderr(TDEProcess*,char*,int)),
this,TQ_SLOT(receivedErrorMsg(TDEProcess*,char*,int)) );
connect(this,TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
this,TQ_SLOT(receivedOutputMsg(TDEProcess*,char*,int)) );
}
TQString getErrorMsg() {

4
krusader/ActionMan/actionman.cpp
Unescape View File

@ -28,8 +28,8 @@ ActionMan::ActionMan( TQWidget * parent )
userActionPage = new UserActionPage( this );
setMainWidget( userActionPage );
connect( userActionPage, TQT_SIGNAL( changed() ), TQT_SLOT( slotEnableApplyButton() ) );
connect( userActionPage, TQT_SIGNAL( applied() ), TQT_SLOT( slotDisableApplyButton() ) );
connect( userActionPage, TQ_SIGNAL( changed() ), TQ_SLOT( slotEnableApplyButton() ) );
connect( userActionPage, TQ_SIGNAL( applied() ), TQ_SLOT( slotDisableApplyButton() ) );
enableButtonApply( false );
exec();

60
krusader/ActionMan/actionproperty.cpp
Unescape View File

@ -49,37 +49,37 @@ ActionProperty::ActionProperty( TQWidget *parent, const char *name, KrAction *ac
// fill with all existing categories
cbCategory->insertStringList( krUserAction->allCategories() );
connect( ButtonAddPlaceholder, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addPlaceholder() ) );
connect( ButtonAddStartpath, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addStartpath() ) );
connect( ButtonNewProtocol, TQT_SIGNAL( clicked() ), this, TQT_SLOT( newProtocol() ) );
connect( ButtonEditProtocol, TQT_SIGNAL( clicked() ), this, TQT_SLOT( editProtocol() ) );
connect( ButtonRemoveProtocol, TQT_SIGNAL( clicked() ), this, TQT_SLOT( removeProtocol() ) );
connect( ButtonAddPath, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addPath() ) );
connect( ButtonEditPath, TQT_SIGNAL( clicked() ), this, TQT_SLOT( editPath() ) );
connect( ButtonRemovePath, TQT_SIGNAL( clicked() ), this, TQT_SLOT( removePath() ) );
connect( ButtonAddMime, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addMime() ) );
connect( ButtonEditMime, TQT_SIGNAL( clicked() ), this, TQT_SLOT( editMime() ) );
connect( ButtonRemoveMime, TQT_SIGNAL( clicked() ), this, TQT_SLOT( removeMime() ) );
connect( ButtonNewFile, TQT_SIGNAL( clicked() ), this, TQT_SLOT( newFile() ) );
connect( ButtonEditFile, TQT_SIGNAL( clicked() ), this, TQT_SLOT( editFile() ) );
connect( ButtonRemoveFile, TQT_SIGNAL( clicked() ), this, TQT_SLOT( removeFile() ) );
connect( KeyButtonShortcut, TQT_SIGNAL( capturedShortcut(const TDEShortcut&) ), this, TQT_SLOT( changedShortcut(const TDEShortcut&) ) );
connect( ButtonAddPlaceholder, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addPlaceholder() ) );
connect( ButtonAddStartpath, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addStartpath() ) );
connect( ButtonNewProtocol, TQ_SIGNAL( clicked() ), this, TQ_SLOT( newProtocol() ) );
connect( ButtonEditProtocol, TQ_SIGNAL( clicked() ), this, TQ_SLOT( editProtocol() ) );
connect( ButtonRemoveProtocol, TQ_SIGNAL( clicked() ), this, TQ_SLOT( removeProtocol() ) );
connect( ButtonAddPath, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addPath() ) );
connect( ButtonEditPath, TQ_SIGNAL( clicked() ), this, TQ_SLOT( editPath() ) );
connect( ButtonRemovePath, TQ_SIGNAL( clicked() ), this, TQ_SLOT( removePath() ) );
connect( ButtonAddMime, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addMime() ) );
connect( ButtonEditMime, TQ_SIGNAL( clicked() ), this, TQ_SLOT( editMime() ) );
connect( ButtonRemoveMime, TQ_SIGNAL( clicked() ), this, TQ_SLOT( removeMime() ) );
connect( ButtonNewFile, TQ_SIGNAL( clicked() ), this, TQ_SLOT( newFile() ) );
connect( ButtonEditFile, TQ_SIGNAL( clicked() ), this, TQ_SLOT( editFile() ) );
connect( ButtonRemoveFile, TQ_SIGNAL( clicked() ), this, TQ_SLOT( removeFile() ) );
connect( KeyButtonShortcut, TQ_SIGNAL( capturedShortcut(const TDEShortcut&) ), this, TQ_SLOT( changedShortcut(const TDEShortcut&) ) );
// track modifications:
connect( leDistinctName, TQT_SIGNAL( textChanged(const TQString&) ), TQT_SLOT( setModified() ) );
connect( leTitle, TQT_SIGNAL( textChanged(const TQString&) ), TQT_SLOT( setModified() ) );
connect( ButtonIcon, TQT_SIGNAL( iconChanged(TQString) ), TQT_SLOT( setModified() ) );
connect( cbCategory, TQT_SIGNAL( textChanged(const TQString&) ), TQT_SLOT( setModified() ) );
connect( leTooltip, TQT_SIGNAL( textChanged(const TQString&) ), TQT_SLOT( setModified() ) );
connect( textDescription, TQT_SIGNAL( textChanged() ), TQT_SLOT( setModified() ) );
connect( leDistinctName, TQT_SIGNAL( textChanged(const TQString&) ), TQT_SLOT( setModified() ) );
connect( leCommandline, TQT_SIGNAL( textChanged(const TQString&) ), TQT_SLOT( setModified() ) );
connect( leStartpath, TQT_SIGNAL( textChanged(const TQString&) ), TQT_SLOT( setModified() ) );
connect( bgExecType, TQT_SIGNAL( clicked(int) ), TQT_SLOT( setModified() ) );
connect( bgAccept, TQT_SIGNAL( clicked(int) ), TQT_SLOT( setModified() ) );
connect( KeyButtonShortcut, TQT_SIGNAL( capturedShortcut(const TDEShortcut&) ), TQT_SLOT( setModified() ) );
connect( leDifferentUser, TQT_SIGNAL( textChanged(const TQString&) ), TQT_SLOT( setModified() ) );
connect( chkDifferentUser, TQT_SIGNAL( clicked() ), TQT_SLOT( setModified() ) );
connect( chkConfirmExecution, TQT_SIGNAL( clicked() ), TQT_SLOT( setModified() ) );
connect( leDistinctName, TQ_SIGNAL( textChanged(const TQString&) ), TQ_SLOT( setModified() ) );
connect( leTitle, TQ_SIGNAL( textChanged(const TQString&) ), TQ_SLOT( setModified() ) );
connect( ButtonIcon, TQ_SIGNAL( iconChanged(TQString) ), TQ_SLOT( setModified() ) );
connect( cbCategory, TQ_SIGNAL( textChanged(const TQString&) ), TQ_SLOT( setModified() ) );
connect( leTooltip, TQ_SIGNAL( textChanged(const TQString&) ), TQ_SLOT( setModified() ) );
connect( textDescription, TQ_SIGNAL( textChanged() ), TQ_SLOT( setModified() ) );
connect( leDistinctName, TQ_SIGNAL( textChanged(const TQString&) ), TQ_SLOT( setModified() ) );
connect( leCommandline, TQ_SIGNAL( textChanged(const TQString&) ), TQ_SLOT( setModified() ) );
connect( leStartpath, TQ_SIGNAL( textChanged(const TQString&) ), TQ_SLOT( setModified() ) );
connect( bgExecType, TQ_SIGNAL( clicked(int) ), TQ_SLOT( setModified() ) );
connect( bgAccept, TQ_SIGNAL( clicked(int) ), TQ_SLOT( setModified() ) );
connect( KeyButtonShortcut, TQ_SIGNAL( capturedShortcut(const TDEShortcut&) ), TQ_SLOT( setModified() ) );
connect( leDifferentUser, TQ_SIGNAL( textChanged(const TQString&) ), TQ_SLOT( setModified() ) );
connect( chkDifferentUser, TQ_SIGNAL( clicked() ), TQ_SLOT( setModified() ) );
connect( chkConfirmExecution, TQ_SIGNAL( clicked() ), TQ_SLOT( setModified() ) );
// The modified-state of the ShowOnly-lists is tracked in the access-functions below
}

4
krusader/ActionMan/actionpropertybase.cpp
Unescape View File

@ -365,8 +365,8 @@ ActionPropertyBase::ActionPropertyBase( TQWidget* parent, const char* name, WFla
clearWState( WState_Polished );
// signals and slots connections
connect( radioCollectOutput, TQT_SIGNAL( toggled(bool) ), chkSeparateStdError, TQT_SLOT( setEnabled(bool) ) );
connect( chkDifferentUser, TQT_SIGNAL( toggled(bool) ), leDifferentUser, TQT_SLOT( setEnabled(bool) ) );
connect( radioCollectOutput, TQ_SIGNAL( toggled(bool) ), chkSeparateStdError, TQ_SLOT( setEnabled(bool) ) );
connect( chkDifferentUser, TQ_SIGNAL( toggled(bool) ), leDifferentUser, TQ_SLOT( setEnabled(bool) ) );
}
/*

10
krusader/ActionMan/addplaceholderpopup.cpp
Unescape View File

@ -173,7 +173,7 @@ ParameterDialog::ParameterDialog( const exp_placeholder* currentPlaceholder, TQW
line->setFrameShape( TQFrame::HLine );
line->setFrameShadow( TQFrame::Sunken );
connect( this, TQT_SIGNAL(defaultClicked()), this, TQT_SLOT(reset()) );
connect( this, TQ_SIGNAL(defaultClicked()), this, TQ_SLOT(reset()) );
}
TQString ParameterDialog::getParameter() {
@ -257,7 +257,7 @@ ParameterPlaceholder::ParameterPlaceholder( const exp_parameter& parameter, TQWi
_lineEdit = new KLineEdit( hbox );
_button = new TQToolButton( hbox);
_button->setText( i18n("add") );
connect( _button, TQT_SIGNAL(clicked()), this, TQT_SLOT(addPlaceholder()) );
connect( _button, TQ_SIGNAL(clicked()), this, TQ_SLOT(addPlaceholder()) );
}
TQString ParameterPlaceholder::text() {
@ -347,7 +347,7 @@ ParameterFile::ParameterFile( const exp_parameter& parameter, TQWidget* parent )
_button = new TQToolButton( hbox);
TDEIconLoader *iconLoader = new TDEIconLoader();
_button->setPixmap( iconLoader->loadIcon( "document-open", TDEIcon::Toolbar, 16 ) );
connect( _button, TQT_SIGNAL(clicked()), this, TQT_SLOT(addFile()) );
connect( _button, TQ_SIGNAL(clicked()), this, TQ_SLOT(addFile()) );
}
TQString ParameterFile::text() {
@ -440,10 +440,10 @@ ParameterGoto::ParameterGoto( const exp_parameter& parameter, TQWidget* parent )
_dirButton = new TQToolButton( hbox );
TDEIconLoader *iconLoader = new TDEIconLoader();
_dirButton->setPixmap( iconLoader->loadIcon( "document-open", TDEIcon::Toolbar, 16 ) );
connect( _dirButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(setDir()) );
connect( _dirButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(setDir()) );
_placeholderButton = new TQToolButton( hbox);
_placeholderButton->setText( i18n("add") );
connect( _placeholderButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(addPlaceholder()) );
connect( _placeholderButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(addPlaceholder()) );
}
TQString ParameterGoto::text() {

24
krusader/ActionMan/useractionpage.cpp
Unescape View File

@ -99,16 +99,16 @@ UserActionPage::UserActionPage( TQWidget* parent )
actionProperties = new ActionProperty( split, "actionProperties" );
actionProperties->setEnabled( false ); // if there are any actions in the list, the first is displayed and this widget is enabled
connect( actionTree, TQT_SIGNAL( currentChanged(TQListViewItem*) ), TQT_SLOT( slotChangeCurrent() ) );
connect( newButton, TQT_SIGNAL( clicked() ), TQT_SLOT( slotNewAction() ) );
connect( removeButton, TQT_SIGNAL( clicked() ), TQT_SLOT( slotRemoveAction() ) );
connect( importButton, TQT_SIGNAL( clicked() ), TQT_SLOT( slotImport() ) );
connect( exportButton, TQT_SIGNAL( clicked() ), TQT_SLOT( slotExport() ) );
connect( copyButton, TQT_SIGNAL( clicked() ), TQT_SLOT( slotToClip() ) );
connect( pasteButton, TQT_SIGNAL( clicked() ), TQT_SLOT( slotFromClip() ) );
connect( actionTree, TQ_SIGNAL( currentChanged(TQListViewItem*) ), TQ_SLOT( slotChangeCurrent() ) );
connect( newButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotNewAction() ) );
connect( removeButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotRemoveAction() ) );
connect( importButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotImport() ) );
connect( exportButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotExport() ) );
connect( copyButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotToClip() ) );
connect( pasteButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotFromClip() ) );
// forwards the changed signal of the properties
connect ( actionProperties, TQT_SIGNAL( changed() ), TQT_SIGNAL( changed() ) );
connect ( actionProperties, TQ_SIGNAL( changed() ), TQ_SIGNAL( changed() ) );
actionTree->setFirstActionCurrent();
actionTree->setFocus();
@ -126,16 +126,16 @@ bool UserActionPage::continueInSpiteOfChanges() {
i18n("The current action has been modified. Do you want to apply these changes?")
);
if ( answer == KMessageBox::Cancel ) {
disconnect( actionTree, TQT_SIGNAL( currentChanged(TQListViewItem*) ), this, TQT_SLOT( slotChangeCurrent() ) );
disconnect( actionTree, TQ_SIGNAL( currentChanged(TQListViewItem*) ), this, TQ_SLOT( slotChangeCurrent() ) );
actionTree->setCurrentAction( actionProperties->action() );
connect( actionTree, TQT_SIGNAL( currentChanged(TQListViewItem*) ), TQT_SLOT( slotChangeCurrent() ) );
connect( actionTree, TQ_SIGNAL( currentChanged(TQListViewItem*) ), TQ_SLOT( slotChangeCurrent() ) );
return false;
}
if ( answer == KMessageBox::Yes ) {
if ( ! actionProperties->validProperties() ) {
disconnect( actionTree, TQT_SIGNAL( currentChanged(TQListViewItem*) ), this, TQT_SLOT( slotChangeCurrent() ) );
disconnect( actionTree, TQ_SIGNAL( currentChanged(TQListViewItem*) ), this, TQ_SLOT( slotChangeCurrent() ) );
actionTree->setCurrentAction( actionProperties->action() );
connect( actionTree, TQT_SIGNAL( currentChanged(TQListViewItem*) ), TQT_SLOT( slotChangeCurrent() ) );
connect( actionTree, TQ_SIGNAL( currentChanged(TQListViewItem*) ), TQ_SLOT( slotChangeCurrent() ) );
return false;
}
slotUpdateAction();

6
krusader/BookMan/kraddbookmarkdlg.cpp
Unescape View File

@ -15,7 +15,7 @@ KrAddBookmarkDlg::KrAddBookmarkDlg(TQWidget *parent, KURL url):
// create the 'new folder' button
setButtonText(KDialogBase::User1, i18n("New Folder"));
showButton(KDialogBase::User1, false); // hide it until _createIn is shown
connect(this, TQT_SIGNAL(user1Clicked()), this, TQT_SLOT(newFolder()));
connect(this, TQ_SIGNAL(user1Clicked()), this, TQ_SLOT(newFolder()));
// create the main widget
TQWidget *page = new TQWidget(this);
@ -46,7 +46,7 @@ KrAddBookmarkDlg::KrAddBookmarkDlg(TQWidget *parent, KURL url):
_createInBtn = new TQToolButton(page);
_createInBtn->setPixmap(krLoader->loadIcon("go-down", TDEIcon::Small));
_createInBtn->setToggleButton(true);
connect(_createInBtn, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(toggleCreateIn(bool )));
connect(_createInBtn, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleCreateIn(bool )));
layout->addWidget(_createInBtn, 2, 2);
setDetailsWidget(createInWidget());
@ -76,7 +76,7 @@ TQWidget *KrAddBookmarkDlg::createInWidget() {
populateCreateInWidget(krBookMan->_root, item);
_createIn->setCurrentItem(item);
createInSelection(item);
connect(_createIn, TQT_SIGNAL(selectionChanged(TQListViewItem*)), this, TQT_SLOT(createInSelection(TQListViewItem*)));
connect(_createIn, TQ_SIGNAL(selectionChanged(TQListViewItem*)), this, TQ_SLOT(createInSelection(TQListViewItem*)));
return _createIn;
}

2
krusader/BookMan/krbookmark.cpp
Unescape View File

@ -19,7 +19,7 @@ static const char* NAME_LAN = I18N_NOOP("Local Network");
KrBookmark::KrBookmark(TQString name, KURL url, TDEActionCollection *parent, TQString icon, TQString actionName ):
TDEAction(name, 0, 0, 0, parent, actionName.isNull() ? BM_NAME(name).latin1() : BM_NAME(actionName).latin1()),
_url(url), _folder(false), _separator(false) {
connect(this, TQT_SIGNAL(activated()), this, TQT_SLOT(activatedProxy()));
connect(this, TQ_SIGNAL(activated()), this, TQ_SLOT(activatedProxy()));
// do we have an icon?
if (!icon.isEmpty())
setIcon(icon);

2
krusader/BookMan/krbookmarkbutton.cpp
Unescape View File

@ -22,7 +22,7 @@ KrBookmarkButton::KrBookmarkButton(TQWidget *parent): TQToolButton(parent) {
acmBookmarks->popupMenu()->setKeyboardShortcutsExecute(true);
setPopup(acmBookmarks->popupMenu());
connect(this, TQT_SIGNAL(pressed()), this, TQT_SLOT(populate()));
connect(this, TQ_SIGNAL(pressed()), this, TQ_SLOT(populate()));
populate();
}

16
krusader/BookMan/krbookmarkhandler.cpp
Unescape View File

@ -19,7 +19,7 @@
// ------------------------ for internal use
#define BOOKMARKS_FILE "krusader/krbookmarks.xml"
#define CONNECT_BM(X) { disconnect(X, TQT_SIGNAL(activated(const KURL&)), 0, 0); connect(X, TQT_SIGNAL(activated(const KURL&)), this, TQT_SLOT(slotActivated(const KURL&))); }
#define CONNECT_BM(X) { disconnect(X, TQ_SIGNAL(activated(const KURL&)), 0, 0); connect(X, TQ_SIGNAL(activated(const KURL&)), this, TQ_SLOT(slotActivated(const KURL&))); }
KrBookmarkHandler::KrBookmarkHandler(): TQObject(0), _middleClick(false), _mainBookmarkPopup( 0 ), _specialBookmarkIDs(), _bookmarkIDTable() {
// create our own action collection and make the shortcuts apply only to parent
@ -36,7 +36,7 @@ KrBookmarkHandler::KrBookmarkHandler(): TQObject(0), _middleClick(false), _mainB
// hack
manager = KBookmarkManager::managerForFile(locateLocal( "data", BOOKMARKS_FILE ), false);
connect(manager, TQT_SIGNAL(changed(const TQString&, const TQString& )), this, TQT_SLOT(bookmarksChanged(const TQString&, const TQString& )));
connect(manager, TQ_SIGNAL(changed(const TQString&, const TQString& )), this, TQ_SLOT(bookmarksChanged(const TQString&, const TQString& )));
}
KrBookmarkHandler::~KrBookmarkHandler() {
@ -403,8 +403,8 @@ void KrBookmarkHandler::buildMenu(KrBookmark *parent, TDEPopupMenu *menu) {
_specialBookmarkIDs.append( itemIndex );
// make sure the menu is connected to us
disconnect(menu, TQT_SIGNAL(activated(int)), 0, 0);
connect(menu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(menuOperation(int)));
disconnect(menu, TQ_SIGNAL(activated(int)), 0, 0);
connect(menu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(menuOperation(int)));
}
menu->installEventFilter(this);
@ -493,8 +493,8 @@ void KrBookmarkHandler::rightClickOnSpecialBookmark() {
menu.insertItem( i18n( "Jump back" ), JUMP_BACK_ID );
menu.setItemChecked( JUMP_BACK_ID, hasJumpback );
connect( _mainBookmarkPopup, TQT_SIGNAL( highlighted( int ) ), &menu, TQT_SLOT( close() ) );
connect( _mainBookmarkPopup, TQT_SIGNAL( activated( int ) ), &menu, TQT_SLOT( close() ) );
connect( _mainBookmarkPopup, TQ_SIGNAL( highlighted( int ) ), &menu, TQ_SLOT( close() ) );
connect( _mainBookmarkPopup, TQ_SIGNAL( activated( int ) ), &menu, TQ_SLOT( close() ) );
int result = menu.exec( TQCursor::pos() );
bool doCloseMain = true;
@ -540,8 +540,8 @@ void KrBookmarkHandler::rightClicked( TQPopupMenu *menu, int /*id*/, KrBookmark
popup.insertSeparator();
popup.insertItem( krLoader->loadIcon( "edit-delete", TDEIcon::Panel ), i18n( "Delete" ), DELETE_ID );
connect( menu, TQT_SIGNAL( highlighted( int ) ), &popup, TQT_SLOT( close() ) );
connect( menu, TQT_SIGNAL( activated( int ) ), &popup, TQT_SLOT( close() ) );
connect( menu, TQ_SIGNAL( highlighted( int ) ), &popup, TQ_SLOT( close() ) );
connect( menu, TQ_SIGNAL( activated( int ) ), &popup, TQ_SLOT( close() ) );
int result = popup.exec( TQCursor::pos() );

8
krusader/Dialogs/checksumdlg.cpp
Unescape View File

@ -541,7 +541,7 @@ ChecksumResultsDlg::ChecksumResultsDlg(const TQStringList& stdOut, const TQStrin
hlayout2->addWidget(checksumFile, TQt::AlignLeft);
layout->addMultiCellLayout(hlayout2, row, row,0,1, TQt::AlignLeft);
++row;
connect(saveFileCb, TQT_SIGNAL(toggled(bool)), checksumFile, TQT_SLOT(setEnabled(bool)));
connect(saveFileCb, TQ_SIGNAL(toggled(bool)), checksumFile, TQ_SLOT(setEnabled(bool)));
checksumFile->setFocus();
}
@ -550,9 +550,9 @@ ChecksumResultsDlg::ChecksumResultsDlg(const TQStringList& stdOut, const TQStrin
onePerFile = new TQCheckBox(i18n("Checksum file for each source file"), plainPage());
onePerFile->setChecked(false);
// clicking this, disables the 'save as' part
connect(onePerFile, TQT_SIGNAL(toggled(bool)), saveFileCb, TQT_SLOT(toggle()));
connect(onePerFile, TQT_SIGNAL(toggled(bool)), saveFileCb, TQT_SLOT(setDisabled(bool)));
connect(onePerFile, TQT_SIGNAL(toggled(bool)), checksumFile, TQT_SLOT(setDisabled(bool)));
connect(onePerFile, TQ_SIGNAL(toggled(bool)), saveFileCb, TQ_SLOT(toggle()));
connect(onePerFile, TQ_SIGNAL(toggled(bool)), saveFileCb, TQ_SLOT(setDisabled(bool)));
connect(onePerFile, TQ_SIGNAL(toggled(bool)), checksumFile, TQ_SLOT(setDisabled(bool)));
layout->addMultiCellWidget(onePerFile, row, row,0,1, TQt::AlignLeft);
++row;
}

12
krusader/Dialogs/krdialogs.cpp
Unescape View File

@ -152,7 +152,7 @@ KURLRequesterDlgForCopy::KURLRequesterDlgForCopy( const TQString& urlName, const
line->setFrameStyle( TQFrame::HLine | TQFrame::Sunken );
topLayout->addWidget( line );
copyDirStructureCB = new TQCheckBox(i18n("Keep virtual directory structure"), plainPage());
connect( copyDirStructureCB, TQT_SIGNAL( toggled( bool ) ), this, TQT_SLOT( slotDirStructCBChanged() ) );
connect( copyDirStructureCB, TQ_SIGNAL( toggled( bool ) ), this, TQ_SLOT( slotDirStructCBChanged() ) );
copyDirStructureCB->setChecked( false );
topLayout->addWidget( copyDirStructureCB );
TQHBox * hbox = new TQHBox( plainPage(), "copyDirStructure" );
@ -173,12 +173,12 @@ KURLRequesterDlgForCopy::KURLRequesterDlgForCopy( const TQString& urlName, const
topLayout->addWidget( hbox );
}
urlRequester_->setFocus();
connect( urlRequester_->lineEdit(), TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotTextChanged(const TQString&)) );
connect( urlRequester_->lineEdit(), TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotTextChanged(const TQString&)) );
bool state = !urlName.isEmpty();
enableButtonOK( state );
enableButton( KDialogBase::User1, state );
connect( this, TQT_SIGNAL( user1Clicked() ), TQT_SLOT( slotClear() ) );
connect( this, TQ_SIGNAL( user1Clicked() ), TQ_SLOT( slotClear() ) );
}
KURLRequesterDlgForCopy::KURLRequesterDlgForCopy() {
@ -235,8 +235,8 @@ KRGetDate::KRGetDate(TQDate date, TQWidget *parent, const char *name) : KDialog(
setMinimumSize(dateWidget->sizeHint());
setMaximumSize(dateWidget->sizeHint());
resize(minimumSize());
connect(dateWidget, TQT_SIGNAL(dateSelected(TQDate)), this, TQT_SLOT(setDate(TQDate)));
connect(dateWidget, TQT_SIGNAL(dateEntered(TQDate)), this, TQT_SLOT(setDate(TQDate)));
connect(dateWidget, TQ_SIGNAL(dateSelected(TQDate)), this, TQ_SLOT(setDate(TQDate)));
connect(dateWidget, TQ_SIGNAL(dateEntered(TQDate)), this, TQ_SLOT(setDate(TQDate)));
// keep the original date - incase ESC is pressed
originalDate = date;

4
krusader/Dialogs/krkeydialog.cpp
Unescape View File

@ -41,12 +41,12 @@ KrKeyDialog::KrKeyDialog( TQWidget * parent ) : KKeyDialog( false /* allow lette
KPushButton* importButton = new KPushButton( i18n("Import shortcuts"), buttonBox );
TQWhatsThis::add( importButton, i18n( "Load a keybinding profile, e.g., total_commander.keymap" ) );
buttonBoxLayout->insertWidget( 1, importButton ); // the defaults-button should stay on position 0
connect( importButton, TQT_SIGNAL( clicked() ), TQT_SLOT( slotImportShortcuts() ) );
connect( importButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotImportShortcuts() ) );
KPushButton* exportButton = new KPushButton( i18n("Export shortcuts"), buttonBox );
TQWhatsThis::add( exportButton, i18n( "Save current keybindings in a keymap file." ) );
buttonBoxLayout->insertWidget( 2, exportButton );
connect( exportButton, TQT_SIGNAL( clicked() ), TQT_SLOT( slotExportShortcuts() ) );
connect( exportButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotExportShortcuts() ) );
// Also quite HACK 'isch but unfortunately KKeyDialog don't giveus access to this widget
_chooser = static_cast<KKeyChooser*>( mainWidget() );

20
krusader/Dialogs/krmaskchoice.cpp
Unescape View File

@ -136,16 +136,16 @@ KRMaskChoice::KRMaskChoice( TQWidget* parent, const char* name, bool modal, WFl
hbox_3->addWidget( PushButton3_2 );
// signals and slots connections
connect( PushButton3_2, TQT_SIGNAL( clicked() ), this, TQT_SLOT( reject() ) );
connect( PushButton3, TQT_SIGNAL( clicked() ), this, TQT_SLOT( accept() ) );
connect( PushButton7, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addSelection() ) );
connect( PushButton7_2, TQT_SIGNAL( clicked() ), this, TQT_SLOT( deleteSelection() ) );
connect( PushButton7_3, TQT_SIGNAL( clicked() ), this, TQT_SLOT( clearSelections() ) );
connect( selection, TQT_SIGNAL( activated(const TQString&) ), selection, TQT_SLOT( setEditText(const TQString &) ) );
connect( selection->lineEdit(), TQT_SIGNAL( returnPressed() ), this, TQT_SLOT( accept() ));
connect( preSelections, TQT_SIGNAL( doubleClicked(TQListBoxItem*) ), this, TQT_SLOT( acceptFromList(TQListBoxItem *) ) );
connect( preSelections, TQT_SIGNAL( highlighted(const TQString&) ), selection, TQT_SLOT( setEditText(const TQString &) ) );
connect( preSelections, TQT_SIGNAL( returnPressed(TQListBoxItem*) ), this, TQT_SLOT( acceptFromList(TQListBoxItem *) ) );
connect( PushButton3_2, TQ_SIGNAL( clicked() ), this, TQ_SLOT( reject() ) );
connect( PushButton3, TQ_SIGNAL( clicked() ), this, TQ_SLOT( accept() ) );
connect( PushButton7, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addSelection() ) );
connect( PushButton7_2, TQ_SIGNAL( clicked() ), this, TQ_SLOT( deleteSelection() ) );
connect( PushButton7_3, TQ_SIGNAL( clicked() ), this, TQ_SLOT( clearSelections() ) );
connect( selection, TQ_SIGNAL( activated(const TQString&) ), selection, TQ_SLOT( setEditText(const TQString &) ) );
connect( selection->lineEdit(), TQ_SIGNAL( returnPressed() ), this, TQ_SLOT( accept() ));
connect( preSelections, TQ_SIGNAL( doubleClicked(TQListBoxItem*) ), this, TQ_SLOT( acceptFromList(TQListBoxItem *) ) );
connect( preSelections, TQ_SIGNAL( highlighted(const TQString&) ), selection, TQ_SLOT( setEditText(const TQString &) ) );
connect( preSelections, TQ_SIGNAL( returnPressed(TQListBoxItem*) ), this, TQ_SLOT( acceptFromList(TQListBoxItem *) ) );
}
/*

6
krusader/Dialogs/krpleasewait.cpp
Unescape View File

@ -48,7 +48,7 @@ KRPleaseWait::KRPleaseWait( TQString msg, int count, bool cancel ):
setAutoClose(false);
setAutoReset(false);
connect( timer,TQT_SIGNAL(timeout()), this, TQT_SLOT(cycleProgress()));
connect( timer,TQ_SIGNAL(timeout()), this, TQ_SLOT(cycleProgress()));
TQProgressBar* progress = new TQProgressBar(count,this);
progress->setCenterIndicator(true);
@ -101,7 +101,7 @@ void KRPleaseWaitHandler::stopWait(){
void KRPleaseWaitHandler::startWaiting( TQString msg, int count , bool cancel){
if ( dlg == 0 ){
dlg = new KRPleaseWait( msg , count, cancel);
connect( dlg,TQT_SIGNAL(cancelled()),this,TQT_SLOT(killJob()) );
connect( dlg,TQ_SIGNAL(cancelled()),this,TQ_SLOT(killJob()) );
}
incMutex=cycleMutex=_wasCancelled=false;
dlg->setProgress(0);
@ -122,7 +122,7 @@ void KRPleaseWaitHandler::cycleProgress(){
if (cycleMutex) return;
cycleMutex=true;
if (dlg) dlg->cycleProgress();
if (cycle) TQTimer::singleShot(2000,this,TQT_SLOT(cycleProgress()));
if (cycle) TQTimer::singleShot(2000,this,TQ_SLOT(cycleProgress()));
cycleMutex=false;
}

22
krusader/Dialogs/krprogress.cpp
Unescape View File

@ -103,7 +103,7 @@ KrProgress::KrProgress( TDEIO::Job* job )
hBox->addStretch(1);
KPushButton *pb = new KPushButton( KStdGuiItem::cancel(), this );
connect( pb, TQT_SIGNAL( clicked() ), TQT_SLOT( slotStop() ) );
connect( pb, TQ_SIGNAL( clicked() ), TQ_SLOT( slotStop() ) );
hBox->addWidget( pb );
resize( sizeHint() );
@ -115,16 +115,16 @@ KrProgress::KrProgress( TDEIO::Job* job )
setOnlyClean(false);
setStopOnClose(true);
// Connect global progress info signals
connect( job, TQT_SIGNAL( percent( TDEIO::Job*, unsigned long ) ),
TQT_SLOT( slotPercent( TDEIO::Job*, unsigned long ) ) );
connect( job, TQT_SIGNAL( infoMessage( TDEIO::Job*, const TQString & ) ),
TQT_SLOT( slotInfoMessage( TDEIO::Job*, const TQString & ) ) );
connect( job, TQT_SIGNAL( totalSize( TDEIO::Job*, TDEIO::filesize_t ) ),
TQT_SLOT( slotTotalSize( TDEIO::Job*, TDEIO::filesize_t ) ) );
connect( job, TQT_SIGNAL( processedSize( TDEIO::Job*, TDEIO::filesize_t ) ),
TQT_SLOT( slotProcessedSize( TDEIO::Job*, TDEIO::filesize_t ) ) );
connect( job, TQT_SIGNAL( speed( TDEIO::Job*, unsigned long ) ),
TQT_SLOT( slotSpeed( TDEIO::Job*, unsigned long ) ) );
connect( job, TQ_SIGNAL( percent( TDEIO::Job*, unsigned long ) ),
TQ_SLOT( slotPercent( TDEIO::Job*, unsigned long ) ) );
connect( job, TQ_SIGNAL( infoMessage( TDEIO::Job*, const TQString & ) ),
TQ_SLOT( slotInfoMessage( TDEIO::Job*, const TQString & ) ) );
connect( job, TQ_SIGNAL( totalSize( TDEIO::Job*, TDEIO::filesize_t ) ),
TQ_SLOT( slotTotalSize( TDEIO::Job*, TDEIO::filesize_t ) ) );
connect( job, TQ_SIGNAL( processedSize( TDEIO::Job*, TDEIO::filesize_t ) ),
TQ_SLOT( slotProcessedSize( TDEIO::Job*, TDEIO::filesize_t ) ) );
connect( job, TQ_SIGNAL( speed( TDEIO::Job*, unsigned long ) ),
TQ_SLOT( slotSpeed( TDEIO::Job*, unsigned long ) ) );
// change to modal & move to Krusader's center
TQPoint center((krApp->width()-width())/2,(krApp->height()-height())/2);

10
krusader/Dialogs/kurllistrequester.cpp
Unescape View File

@ -77,11 +77,11 @@ KURLListRequester::KURLListRequester( TQWidget *parent, const char * name ) : TQ
// connection table
connect( urlAddBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotAdd() ) );
connect( urlBrowseBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotBrowse() ) );
connect( urlLineEdit, TQT_SIGNAL( returnPressed(const TQString&) ), this, TQT_SLOT( slotAdd() ) );
connect( urlListBox, TQT_SIGNAL( rightButtonClicked ( TQListBoxItem *, const TQPoint & ) ), this,
TQT_SLOT( slotRightClicked( TQListBoxItem * ) ) );
connect( urlAddBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotAdd() ) );
connect( urlBrowseBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotBrowse() ) );
connect( urlLineEdit, TQ_SIGNAL( returnPressed(const TQString&) ), this, TQ_SLOT( slotAdd() ) );
connect( urlListBox, TQ_SIGNAL( rightButtonClicked ( TQListBoxItem *, const TQPoint & ) ), this,
TQ_SLOT( slotRightClicked( TQListBoxItem * ) ) );
}
void KURLListRequester::slotAdd()

12
krusader/Dialogs/newftpgui.cpp
Unescape View File

@ -85,15 +85,15 @@ newFTPGUI::newFTPGUI( TQWidget* parent, const char* name, bool modal, WFlags fl
prefix->setAcceptDrops( FALSE );
prefix->setEnabled( TRUE );
prefix->setSizePolicy( SIZE_MINIMUM );
connect( prefix,TQT_SIGNAL(activated(const TQString& )),
this,TQT_SLOT(slotTextChanged(const TQString& )));
connect( prefix,TQ_SIGNAL(activated(const TQString& )),
this,TQ_SLOT(slotTextChanged(const TQString& )));
url = new KHistoryCombo( grid_host, "url" );
url->setMaximumHeight( 20 );
url->setMaxCount( 25 );
url->setDuplicatesEnabled( false );
connect( url, TQT_SIGNAL( activated( const TQString& )),
url, TQT_SLOT( addToHistory( const TQString& )));
connect( url, TQ_SIGNAL( activated( const TQString& )),
url, TQ_SLOT( addToHistory( const TQString& )));
// load the history and completion list after creating the history combo
krConfig->setGroup("Private");
TQStringList list = krConfig->readListEntry( "newFTP Completion list" );
@ -135,8 +135,8 @@ newFTPGUI::newFTPGUI( TQWidget* parent, const char* name, bool modal, WFlags fl
hbox->addWidget( cancelBtn );
// signals and slots connections
connect( connectBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( accept() ) );
connect( cancelBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( reject() ) );
connect( connectBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( accept() ) );
connect( cancelBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( reject() ) );
// tab order
setTabOrder( url, username );

20
krusader/Dialogs/packguibase.cpp
Unescape View File

@ -83,8 +83,8 @@ PackGUIBase::PackGUIBase( TQWidget* parent, const char* name, bool modal, WFlag
typeData = new TQComboBox( FALSE, this, "typeData" );
typeData->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)1, (TQSizePolicy::SizeType)0 ) );
connect( typeData, TQT_SIGNAL( activated( const TQString & ) ), this, TQT_SLOT( checkConsistency() ) );
connect( typeData, TQT_SIGNAL( highlighted( const TQString & ) ), this, TQT_SLOT( checkConsistency() ) );
connect( typeData, TQ_SIGNAL( activated( const TQString & ) ), this, TQ_SLOT( checkConsistency() ) );
connect( typeData, TQ_SIGNAL( highlighted( const TQString & ) ), this, TQ_SLOT( checkConsistency() ) );
hbox->addWidget( typeData );
grid->addLayout( hbox, 1, 0 );
@ -145,7 +145,7 @@ PackGUIBase::PackGUIBase( TQWidget* parent, const char* name, bool modal, WFlag
compressLayout->setMargin( 0 );
multipleVolume = new TQCheckBox( i18n( "Multiple volume archive" ), advancedWidget, "multipleVolume" );
connect( multipleVolume, TQT_SIGNAL( toggled( bool ) ), this, TQT_SLOT( checkConsistency() ) );
connect( multipleVolume, TQ_SIGNAL( toggled( bool ) ), this, TQ_SLOT( checkConsistency() ) );
compressLayout->addWidget( multipleVolume, 0, 0 );
TQHBoxLayout * volumeHbox = new TQHBoxLayout;
@ -172,7 +172,7 @@ PackGUIBase::PackGUIBase( TQWidget* parent, const char* name, bool modal, WFlag
compressLayout->addLayout ( volumeHbox );
setCompressionLevel = new TQCheckBox( i18n( "Set compression level" ), advancedWidget, "multipleVolume" );
connect( setCompressionLevel, TQT_SIGNAL( toggled( bool ) ), this, TQT_SLOT( checkConsistency() ) );
connect( setCompressionLevel, TQ_SIGNAL( toggled( bool ) ), this, TQ_SLOT( checkConsistency() ) );
compressLayout->addWidget( setCompressionLevel, 0, 0 );
TQHBoxLayout * sliderHbox = new TQHBoxLayout;
@ -213,7 +213,7 @@ PackGUIBase::PackGUIBase( TQWidget* parent, const char* name, bool modal, WFlag
password = new TQLineEdit( advancedWidget, "password" );
password->setEchoMode( TQLineEdit::Password );
connect( password, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( checkConsistency() ) );
connect( password, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( checkConsistency() ) );
passwordGrid->addWidget( password, 0, 1 );
@ -223,7 +223,7 @@ PackGUIBase::PackGUIBase( TQWidget* parent, const char* name, bool modal, WFlag
passwordAgain = new TQLineEdit( advancedWidget, "password" );
passwordAgain->setEchoMode( TQLineEdit::Password );
connect( passwordAgain, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( checkConsistency() ) );
connect( passwordAgain, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( checkConsistency() ) );
passwordGrid->addWidget( passwordAgain, 1, 1 );
@ -292,10 +292,10 @@ PackGUIBase::PackGUIBase( TQWidget* parent, const char* name, bool modal, WFlag
grid->addLayout( hbox_6, 6, 0 );
// signals and slots connections
connect( okButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( accept() ) );
connect( advancedButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( expand() ) );
connect( cancelButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( reject() ) );
connect( browseButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( browse() ) );
connect( okButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( accept() ) );
connect( advancedButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( expand() ) );
connect( cancelButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( reject() ) );
connect( browseButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( browse() ) );
}
/*

14
krusader/Dialogs/popularurls.cpp
Unescape View File

@ -253,13 +253,13 @@ PopularUrlsDlg::PopularUrlsDlg():
setTabOrder(search, urls);
setTabOrder(urls, actionButton(Close));
connect(urls, TQT_SIGNAL(executed(TQListViewItem*)),
this, TQT_SLOT(slotItemSelected(TQListViewItem*)));
connect(urls, TQT_SIGNAL(returnPressed(TQListViewItem*)),
this, TQT_SLOT(slotItemSelected(TQListViewItem*)));
connect(btn, TQT_SIGNAL(clicked()), search, TQT_SLOT(clear()));
connect(search, TQT_SIGNAL(returnPressed(const TQString&)),
this, TQT_SLOT(slotSearchReturnPressed(const TQString&)));
connect(urls, TQ_SIGNAL(executed(TQListViewItem*)),
this, TQ_SLOT(slotItemSelected(TQListViewItem*)));
connect(urls, TQ_SIGNAL(returnPressed(TQListViewItem*)),
this, TQ_SLOT(slotItemSelected(TQListViewItem*)));
connect(btn, TQ_SIGNAL(clicked()), search, TQ_SLOT(clear()));
connect(search, TQ_SIGNAL(returnPressed(const TQString&)),
this, TQ_SLOT(slotSearchReturnPressed(const TQString&)));
}
void PopularUrlsDlg::slotItemSelected(TQListViewItem *it) {

6
krusader/DiskUsage/diskusage.cpp
Unescape View File

@ -159,7 +159,7 @@ LoaderWidget::LoaderWidget( TQWidget *parent, const char *name ) : TQScrollView(
addChild( widget );
connect( cancelButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotCancelled() ) );
connect( cancelButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotCancelled() ) );
}
void LoaderWidget::resizeEvent ( TQResizeEvent *e )
@ -215,7 +215,7 @@ DiskUsage::DiskUsage( TQString confGroup, TQWidget *parent, char *name ) : TQWid
Filelight::Config::read();
propertyMap.setAutoDelete( true );
connect( &loadingTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( slotLoadDirectory() ) );
connect( &loadingTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( slotLoadDirectory() ) );
}
DiskUsage::~DiskUsage()
@ -646,7 +646,7 @@ int DiskUsage::del( File *file, bool calcPercents, int depth )
#else
job = new TDEIO::CopyJob( url,TDEGlobalSettings::trashPath(),TDEIO::CopyJob::Move,false,true );
#endif
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),krApp,TQT_SLOT(changeTrashIcon()));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),krApp,TQ_SLOT(changeTrashIcon()));
}
else
{

22
krusader/DiskUsage/diskusagegui.cpp
Unescape View File

@ -100,16 +100,16 @@ DiskUsageGUI::DiskUsageGUI( KURL openDir, TQWidget* parent, const char *name )
status->setFrameShadow( TQLabel::Sunken );
duGrid->addWidget( status, 2, 0 );
connect( diskUsage, TQT_SIGNAL( status( TQString ) ), this, TQT_SLOT( setStatus( TQString ) ) );
connect( diskUsage, TQT_SIGNAL( viewChanged( int ) ), this, TQT_SLOT( slotViewChanged( int ) ) );
connect( diskUsage, TQT_SIGNAL( newSearch() ), this, TQT_SLOT( newSearch() ) );
connect( diskUsage, TQT_SIGNAL( loadFinished( bool ) ), this, TQT_SLOT( slotLoadFinished( bool ) ) );
connect( btnNewSearch, TQT_SIGNAL( clicked() ), this, TQT_SLOT( newSearch() ) );
connect( btnRefresh, TQT_SIGNAL( clicked() ), this, TQT_SLOT( loadUsageInfo() ) );
connect( btnDirUp, TQT_SIGNAL( clicked() ), diskUsage, TQT_SLOT( dirUp() ) );
connect( btnLines, TQT_SIGNAL( clicked() ), this, TQT_SLOT( selectLinesView() ) );
connect( btnDetailed, TQT_SIGNAL( clicked() ), this, TQT_SLOT( selectListView() ) );
connect( btnFilelight, TQT_SIGNAL( clicked() ), this, TQT_SLOT( selectFilelightView() ) );
connect( diskUsage, TQ_SIGNAL( status( TQString ) ), this, TQ_SLOT( setStatus( TQString ) ) );
connect( diskUsage, TQ_SIGNAL( viewChanged( int ) ), this, TQ_SLOT( slotViewChanged( int ) ) );
connect( diskUsage, TQ_SIGNAL( newSearch() ), this, TQ_SLOT( newSearch() ) );
connect( diskUsage, TQ_SIGNAL( loadFinished( bool ) ), this, TQ_SLOT( slotLoadFinished( bool ) ) );
connect( btnNewSearch, TQ_SIGNAL( clicked() ), this, TQ_SLOT( newSearch() ) );
connect( btnRefresh, TQ_SIGNAL( clicked() ), this, TQ_SLOT( loadUsageInfo() ) );
connect( btnDirUp, TQ_SIGNAL( clicked() ), diskUsage, TQ_SLOT( dirUp() ) );
connect( btnLines, TQ_SIGNAL( clicked() ), this, TQ_SLOT( selectLinesView() ) );
connect( btnDetailed, TQ_SIGNAL( clicked() ), this, TQ_SLOT( selectListView() ) );
connect( btnFilelight, TQ_SIGNAL( clicked() ), this, TQ_SLOT( selectFilelightView() ) );
krConfig->setGroup( "DiskUsage" );
@ -220,7 +220,7 @@ bool DiskUsageGUI::newSearch()
if (tmp.isEmpty()) return false;
baseDirectory = tmp;
TQTimer::singleShot( 0, this, TQT_SLOT( loadUsageInfo() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( loadUsageInfo() ) );
return true;
}

36
krusader/DiskUsage/dufilelight.cpp
Unescape View File

@ -41,13 +41,13 @@ DUFilelight::DUFilelight( DiskUsage *usage, const char *name )
{
setFocusPolicy( TQWidget::StrongFocus );
connect( diskUsage, TQT_SIGNAL( enteringDirectory( Directory * ) ), this, TQT_SLOT( slotDirChanged( Directory * ) ) );
connect( diskUsage, TQT_SIGNAL( clearing() ), this, TQT_SLOT( clear() ) );
connect( diskUsage, TQT_SIGNAL( changed( File * ) ), this, TQT_SLOT( slotChanged( File * ) ) );
connect( diskUsage, TQT_SIGNAL( deleted( File * ) ), this, TQT_SLOT( slotChanged( File * ) ) );
connect( diskUsage, TQT_SIGNAL( changeFinished() ), this, TQT_SLOT( slotRefresh() ) );
connect( diskUsage, TQT_SIGNAL( deleteFinished() ), this, TQT_SLOT( slotRefresh() ) );
connect( diskUsage, TQT_SIGNAL( aboutToShow( TQWidget * ) ), this, TQT_SLOT( slotAboutToShow( TQWidget * ) ) );
connect( diskUsage, TQ_SIGNAL( enteringDirectory( Directory * ) ), this, TQ_SLOT( slotDirChanged( Directory * ) ) );
connect( diskUsage, TQ_SIGNAL( clearing() ), this, TQ_SLOT( clear() ) );
connect( diskUsage, TQ_SIGNAL( changed( File * ) ), this, TQ_SLOT( slotChanged( File * ) ) );
connect( diskUsage, TQ_SIGNAL( deleted( File * ) ), this, TQ_SLOT( slotChanged( File * ) ) );
connect( diskUsage, TQ_SIGNAL( changeFinished() ), this, TQ_SLOT( slotRefresh() ) );
connect( diskUsage, TQ_SIGNAL( deleteFinished() ), this, TQ_SLOT( slotRefresh() ) );
connect( diskUsage, TQ_SIGNAL( aboutToShow( TQWidget * ) ), this, TQ_SLOT( slotAboutToShow( TQWidget * ) ) );
}
void DUFilelight::slotDirChanged( Directory *dir )
@ -93,30 +93,30 @@ void DUFilelight::mousePressEvent( TQMouseEvent *event )
file = (File *)focus->file();
TDEPopupMenu filelightPopup;
filelightPopup.insertItem( i18n("Zoom In"), this, TQT_SLOT( zoomIn() ), Key_Plus );
filelightPopup.insertItem( i18n("Zoom Out"), this, TQT_SLOT( zoomOut() ), Key_Minus );
filelightPopup.insertItem( i18n("Zoom In"), this, TQ_SLOT( zoomIn() ), Key_Plus );
filelightPopup.insertItem( i18n("Zoom Out"), this, TQ_SLOT( zoomOut() ), Key_Minus );
TDEPopupMenu schemePopup;
schemePopup.insertItem( i18n("Rainbow"), this, TQT_SLOT( schemeRainbow() ) );
schemePopup.insertItem( i18n("High Contrast"), this, TQT_SLOT( schemeHighContrast() ) );
schemePopup.insertItem( i18n("TDE"), this, TQT_SLOT( schemeKDE() ) );
schemePopup.insertItem( i18n("Rainbow"), this, TQ_SLOT( schemeRainbow() ) );
schemePopup.insertItem( i18n("High Contrast"), this, TQ_SLOT( schemeHighContrast() ) );
schemePopup.insertItem( i18n("TDE"), this, TQ_SLOT( schemeKDE() ) );
filelightPopup.insertItem( TQPixmap(), &schemePopup, SCHEME_POPUP_ID );
filelightPopup.changeItem( SCHEME_POPUP_ID, i18n( "Scheme" ) );
filelightPopup.insertItem( i18n("Increase contrast"), this, TQT_SLOT( increaseContrast() ) );
filelightPopup.insertItem( i18n("Decrease contrast"), this, TQT_SLOT( decreaseContrast() ) );
filelightPopup.insertItem( i18n("Increase contrast"), this, TQ_SLOT( increaseContrast() ) );
filelightPopup.insertItem( i18n("Decrease contrast"), this, TQ_SLOT( decreaseContrast() ) );
int aid = filelightPopup.insertItem( i18n("Use anti-aliasing" ), this, TQT_SLOT( changeAntiAlias() ) );
int aid = filelightPopup.insertItem( i18n("Use anti-aliasing" ), this, TQ_SLOT( changeAntiAlias() ) );
filelightPopup.setItemChecked( aid, Filelight::Config::antiAliasFactor > 1 );
int sid = filelightPopup.insertItem( i18n("Show small files" ), this, TQT_SLOT( showSmallFiles() ) );
int sid = filelightPopup.insertItem( i18n("Show small files" ), this, TQ_SLOT( showSmallFiles() ) );
filelightPopup.setItemChecked( sid, Filelight::Config::showSmallFiles );
int vid = filelightPopup.insertItem( i18n("Vary label font sizes" ), this, TQT_SLOT( varyLabelFontSizes() ) );
int vid = filelightPopup.insertItem( i18n("Vary label font sizes" ), this, TQ_SLOT( varyLabelFontSizes() ) );
filelightPopup.setItemChecked( vid, Filelight::Config::varyLabelFontSizes );
filelightPopup.insertItem( i18n("Minimum font size"), this, TQT_SLOT( minFontSize() ) );
filelightPopup.insertItem( i18n("Minimum font size"), this, TQ_SLOT( minFontSize() ) );
diskUsage->rightClickMenu( file, &filelightPopup, i18n( "Filelight" ) );
return;

18
krusader/DiskUsage/dulines.cpp
Unescape View File

@ -248,15 +248,15 @@ DULines::DULines( DiskUsage *usage, const char *name )
toolTip = new DULinesToolTip( diskUsage, viewport(), this );
connect( diskUsage, TQT_SIGNAL( enteringDirectory( Directory * ) ), this, TQT_SLOT( slotDirChanged( Directory * ) ) );
connect( diskUsage, TQT_SIGNAL( clearing() ), this, TQT_SLOT( clear() ) );
connect( diskUsage, TQ_SIGNAL( enteringDirectory( Directory * ) ), this, TQ_SLOT( slotDirChanged( Directory * ) ) );
connect( diskUsage, TQ_SIGNAL( clearing() ), this, TQ_SLOT( clear() ) );
connect( header(), TQT_SIGNAL( sizeChange( int, int, int ) ), this, TQT_SLOT( sectionResized( int ) ) );
connect( header(), TQ_SIGNAL( sizeChange( int, int, int ) ), this, TQ_SLOT( sectionResized( int ) ) );
connect( this, TQT_SIGNAL(rightButtonPressed(TQListViewItem *, const TQPoint &, int)),
this, TQT_SLOT( slotRightClicked(TQListViewItem *) ) );
connect( diskUsage, TQT_SIGNAL( changed( File * ) ), this, TQT_SLOT( slotChanged( File * ) ) );
connect( diskUsage, TQT_SIGNAL( deleted( File * ) ), this, TQT_SLOT( slotDeleted( File * ) ) );
connect( this, TQ_SIGNAL(rightButtonPressed(TQListViewItem *, const TQPoint &, int)),
this, TQ_SLOT( slotRightClicked(TQListViewItem *) ) );
connect( diskUsage, TQ_SIGNAL( changed( File * ) ), this, TQ_SLOT( slotChanged( File * ) ) );
connect( diskUsage, TQ_SIGNAL( deleted( File * ) ), this, TQ_SLOT( slotDeleted( File * ) ) );
}
DULines::~DULines()
@ -457,7 +457,7 @@ void DULines::slotRightClicked( TQListViewItem *item )
file = ((DULinesItem *)item)->getFile();
TDEPopupMenu linesPopup;
int lid = linesPopup.insertItem( i18n("Show file sizes"), this, TQT_SLOT( slotShowFileSizes() ) );
int lid = linesPopup.insertItem( i18n("Show file sizes"), this, TQ_SLOT( slotShowFileSizes() ) );
linesPopup.setItemChecked( lid, showFileSize );
diskUsage->rightClickMenu( file, &linesPopup, i18n( "Lines" ) );
@ -493,7 +493,7 @@ void DULines::slotChanged( File * item )
if( !refreshNeeded )
{
refreshNeeded = true;
TQTimer::singleShot( 0, this, TQT_SLOT( slotRefresh() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( slotRefresh() ) );
}
break;
}

16
krusader/DiskUsage/dulistview.cpp
Unescape View File

@ -86,15 +86,15 @@ DUListView::DUListView( DiskUsage *usage, const char *name )
setSorting( 2 );
connect( diskUsage, TQT_SIGNAL( enteringDirectory( Directory * ) ), this, TQT_SLOT( slotDirChanged( Directory * ) ) );
connect( diskUsage, TQT_SIGNAL( clearing() ), this, TQT_SLOT( clear() ) );
connect( diskUsage, TQT_SIGNAL( changed( File * ) ), this, TQT_SLOT( slotChanged( File * ) ) );
connect( diskUsage, TQT_SIGNAL( deleted( File * ) ), this, TQT_SLOT( slotDeleted( File * ) ) );
connect( diskUsage, TQ_SIGNAL( enteringDirectory( Directory * ) ), this, TQ_SLOT( slotDirChanged( Directory * ) ) );
connect( diskUsage, TQ_SIGNAL( clearing() ), this, TQ_SLOT( clear() ) );
connect( diskUsage, TQ_SIGNAL( changed( File * ) ), this, TQ_SLOT( slotChanged( File * ) ) );
connect( diskUsage, TQ_SIGNAL( deleted( File * ) ), this, TQ_SLOT( slotDeleted( File * ) ) );
connect( this, TQT_SIGNAL(rightButtonPressed(TQListViewItem *, const TQPoint &, int)),
this, TQT_SLOT( slotRightClicked(TQListViewItem *) ) );
connect( this, TQT_SIGNAL( expanded ( TQListViewItem * ) ),
this, TQT_SLOT( slotExpanded( TQListViewItem * ) ) );
connect( this, TQ_SIGNAL(rightButtonPressed(TQListViewItem *, const TQPoint &, int)),
this, TQ_SLOT( slotRightClicked(TQListViewItem *) ) );
connect( this, TQ_SIGNAL( expanded ( TQListViewItem * ) ),
this, TQ_SLOT( slotExpanded( TQListViewItem * ) ) );
}
DUListView::~ DUListView()

6
krusader/DiskUsage/radialMap/widget.cpp
Unescape View File

@ -26,9 +26,9 @@ RadialMap::Widget::Widget( TQWidget *parent, const char *name )
{
setBackgroundColor( TQt::white );
connect( this, TQT_SIGNAL(created( const Directory* )), TQT_SLOT(sendFakeMouseEvent()) );
connect( this, TQT_SIGNAL(created( const Directory* )), TQT_SLOT(update()) );
connect( &m_timer, TQT_SIGNAL(timeout()), TQT_SLOT(resizeTimeout()) );
connect( this, TQ_SIGNAL(created( const Directory* )), TQ_SLOT(sendFakeMouseEvent()) );
connect( this, TQ_SIGNAL(created( const Directory* )), TQ_SLOT(update()) );
connect( &m_timer, TQ_SIGNAL(timeout()), TQ_SLOT(resizeTimeout()) );
}
TQString

2
krusader/DiskUsage/radialMap/widgetEvents.cpp
Unescape View File

@ -196,7 +196,7 @@ RadialMap::Widget::mousePressEvent( TQMouseEvent *e )
if( userIntention == KMessageBox::Continue ) {
TDEIO::Job *job = TDEIO::del( url );
job->setWindow( this );
connect( job, TQT_SIGNAL(result( TDEIO::Job* )), TQT_SLOT(deleteJobFinished( TDEIO::Job* )) );
connect( job, TQ_SIGNAL(result( TDEIO::Job* )), TQ_SLOT(deleteJobFinished( TDEIO::Job* )) );
TQApplication::setOverrideCursor( KCursor::workingCursor() );
}
}

56
krusader/Filter/advancedfilter.cpp
Unescape View File

@ -339,34 +339,34 @@ AdvancedFilter::AdvancedFilter( FilterTabs *tabs, TQWidget *parent, const char *
// Connection table
connect( biggerThanEnabled, TQT_SIGNAL( toggled(bool) ), biggerThanAmount, TQT_SLOT( setEnabled(bool) ) );
connect( biggerThanEnabled, TQT_SIGNAL( toggled(bool) ), biggerThanType, TQT_SLOT( setEnabled(bool) ) );
connect( smallerThanEnabled, TQT_SIGNAL( toggled(bool) ), smallerThanAmount, TQT_SLOT( setEnabled(bool) ) );
connect( smallerThanEnabled, TQT_SIGNAL( toggled(bool) ), smallerThanType, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenEnabled, TQT_SIGNAL( toggled(bool) ), modifiedBetweenData1, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenEnabled, TQT_SIGNAL( toggled(bool) ), modifiedBetweenBtn1, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenEnabled, TQT_SIGNAL( toggled(bool) ), modifiedBetweenData2, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenEnabled, TQT_SIGNAL( toggled(bool) ), modifiedBetweenBtn2, TQT_SLOT( setEnabled(bool) ) );
connect( notModifiedAfterEnabled, TQT_SIGNAL( toggled(bool) ), notModifiedAfterData, TQT_SLOT( setEnabled(bool) ) );
connect( notModifiedAfterEnabled, TQT_SIGNAL( toggled(bool) ), notModifiedAfterBtn, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedInTheLastEnabled, TQT_SIGNAL( toggled(bool) ), modifiedInTheLastData, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedInTheLastEnabled, TQT_SIGNAL( toggled(bool) ), modifiedInTheLastType, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedInTheLastEnabled, TQT_SIGNAL( toggled(bool) ), notModifiedInTheLastData, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedInTheLastEnabled, TQT_SIGNAL( toggled(bool) ), notModifiedInTheLastType, TQT_SLOT( setEnabled(bool) ) );
connect( belongsToUserEnabled, TQT_SIGNAL( toggled(bool) ), belongsToUserData, TQT_SLOT( setEnabled(bool) ) );
connect( belongsToGroupEnabled, TQT_SIGNAL( toggled(bool) ), belongsToGroupData, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), ownerR, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), ownerW, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), ownerX, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), groupR, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), groupW, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), groupX, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), allR, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), allW, TQT_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQT_SIGNAL( toggled(bool) ), allX, TQT_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenBtn1, TQT_SIGNAL( clicked() ), this, TQT_SLOT( modifiedBetweenSetDate1() ) );
connect( modifiedBetweenBtn2, TQT_SIGNAL( clicked() ), this, TQT_SLOT( modifiedBetweenSetDate2() ) );
connect( notModifiedAfterBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( notModifiedAfterSetDate() ) );
connect( biggerThanEnabled, TQ_SIGNAL( toggled(bool) ), biggerThanAmount, TQ_SLOT( setEnabled(bool) ) );
connect( biggerThanEnabled, TQ_SIGNAL( toggled(bool) ), biggerThanType, TQ_SLOT( setEnabled(bool) ) );
connect( smallerThanEnabled, TQ_SIGNAL( toggled(bool) ), smallerThanAmount, TQ_SLOT( setEnabled(bool) ) );
connect( smallerThanEnabled, TQ_SIGNAL( toggled(bool) ), smallerThanType, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenEnabled, TQ_SIGNAL( toggled(bool) ), modifiedBetweenData1, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenEnabled, TQ_SIGNAL( toggled(bool) ), modifiedBetweenBtn1, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenEnabled, TQ_SIGNAL( toggled(bool) ), modifiedBetweenData2, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenEnabled, TQ_SIGNAL( toggled(bool) ), modifiedBetweenBtn2, TQ_SLOT( setEnabled(bool) ) );
connect( notModifiedAfterEnabled, TQ_SIGNAL( toggled(bool) ), notModifiedAfterData, TQ_SLOT( setEnabled(bool) ) );
connect( notModifiedAfterEnabled, TQ_SIGNAL( toggled(bool) ), notModifiedAfterBtn, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedInTheLastEnabled, TQ_SIGNAL( toggled(bool) ), modifiedInTheLastData, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedInTheLastEnabled, TQ_SIGNAL( toggled(bool) ), modifiedInTheLastType, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedInTheLastEnabled, TQ_SIGNAL( toggled(bool) ), notModifiedInTheLastData, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedInTheLastEnabled, TQ_SIGNAL( toggled(bool) ), notModifiedInTheLastType, TQ_SLOT( setEnabled(bool) ) );
connect( belongsToUserEnabled, TQ_SIGNAL( toggled(bool) ), belongsToUserData, TQ_SLOT( setEnabled(bool) ) );
connect( belongsToGroupEnabled, TQ_SIGNAL( toggled(bool) ), belongsToGroupData, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), ownerR, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), ownerW, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), ownerX, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), groupR, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), groupW, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), groupX, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), allR, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), allW, TQ_SLOT( setEnabled(bool) ) );
connect( permissionsEnabled, TQ_SIGNAL( toggled(bool) ), allX, TQ_SLOT( setEnabled(bool) ) );
connect( modifiedBetweenBtn1, TQ_SIGNAL( clicked() ), this, TQ_SLOT( modifiedBetweenSetDate1() ) );
connect( modifiedBetweenBtn2, TQ_SIGNAL( clicked() ), this, TQ_SLOT( modifiedBetweenSetDate2() ) );
connect( notModifiedAfterBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( notModifiedAfterSetDate() ) );
// fill the users and groups list

2
krusader/Filter/filterdialog.cpp
Unescape View File

@ -52,7 +52,7 @@ FilterDialog::FilterDialog( TQWidget *parent, const char *name )
generalFilter->searchFor->setFocus();
connect( filterTabs, TQT_SIGNAL( closeRequest(bool) ), this, TQT_SLOT( slotCloseRequest(bool) ) );
connect( filterTabs, TQ_SIGNAL( closeRequest(bool) ), this, TQ_SLOT( slotCloseRequest(bool) ) );
exec();
}

18
krusader/Filter/generalfilter.cpp
Unescape View File

@ -279,17 +279,17 @@ GeneralFilter::GeneralFilter( FilterTabs *tabs, int properties, TQWidget *parent
if( properties & FilterTabs::HasProfileHandler )
{
connect( profileAddBtn, TQT_SIGNAL(clicked()) , this, TQT_SLOT( slotAddBtnClicked() ) );
connect( profileLoadBtn, TQT_SIGNAL(clicked()) , this, TQT_SLOT( slotLoadBtnClicked() ) );
connect( profileOverwriteBtn, TQT_SIGNAL(clicked()) , this, TQT_SLOT( slotOverwriteBtnClicked() ) );
connect( profileRemoveBtn, TQT_SIGNAL(clicked()) , this, TQT_SLOT( slotRemoveBtnClicked() ) );
connect( profileListBox, TQT_SIGNAL(doubleClicked(TQListBoxItem *)) , this, TQT_SLOT( slotProfileDoubleClicked(TQListBoxItem *) ) );
connect( profileManager, TQT_SIGNAL(loadFromProfile(TQString )), fltTabs, TQT_SLOT( loadFromProfile(TQString ) ) );
connect( profileManager, TQT_SIGNAL(saveToProfile(TQString )), fltTabs, TQT_SLOT( saveToProfile(TQString ) ) );
connect( profileAddBtn, TQ_SIGNAL(clicked()) , this, TQ_SLOT( slotAddBtnClicked() ) );
connect( profileLoadBtn, TQ_SIGNAL(clicked()) , this, TQ_SLOT( slotLoadBtnClicked() ) );
connect( profileOverwriteBtn, TQ_SIGNAL(clicked()) , this, TQ_SLOT( slotOverwriteBtnClicked() ) );
connect( profileRemoveBtn, TQ_SIGNAL(clicked()) , this, TQ_SLOT( slotRemoveBtnClicked() ) );
connect( profileListBox, TQ_SIGNAL(doubleClicked(TQListBoxItem *)) , this, TQ_SLOT( slotProfileDoubleClicked(TQListBoxItem *) ) );
connect( profileManager, TQ_SIGNAL(loadFromProfile(TQString )), fltTabs, TQ_SLOT( loadFromProfile(TQString ) ) );
connect( profileManager, TQ_SIGNAL(saveToProfile(TQString )), fltTabs, TQ_SLOT( saveToProfile(TQString ) ) );
}
connect( searchFor, TQT_SIGNAL(activated(const TQString&)), searchFor, TQT_SLOT(addToHistory(const TQString&)));
connect( containsText, TQT_SIGNAL(activated(const TQString&)), containsText, TQT_SLOT(addToHistory(const TQString&)));
connect( searchFor, TQ_SIGNAL(activated(const TQString&)), searchFor, TQ_SLOT(addToHistory(const TQString&)));
connect( containsText, TQ_SIGNAL(activated(const TQString&)), containsText, TQ_SLOT(addToHistory(const TQString&)));
// load the completion and history lists
// ==> search for

4
krusader/GUI/dirhistorybutton.cpp
Unescape View File

@ -44,8 +44,8 @@ DirHistoryButton::DirHistoryButton( DirHistoryQueue* hQ, TQWidget *parent, const
historyQueue = hQ;
connect( popupMenu, TQT_SIGNAL( aboutToShow() ), this, TQT_SLOT( slotAboutToShow() ) );
connect( popupMenu, TQT_SIGNAL( activated( int ) ), this, TQT_SLOT( slotPopupActivated( int ) ) );
connect( popupMenu, TQ_SIGNAL( aboutToShow() ), this, TQ_SLOT( slotAboutToShow() ) );
connect( popupMenu, TQ_SIGNAL( activated( int ) ), this, TQ_SLOT( slotPopupActivated( int ) ) );
}
DirHistoryButton::~DirHistoryButton() {}

2
krusader/GUI/dirhistoryqueue.cpp
Unescape View File

@ -23,7 +23,7 @@
DirHistoryQueue::DirHistoryQueue( ListPanel* p ) {
panel = p;
connect( panel, TQT_SIGNAL( pathChanged( ListPanel* ) ), this, TQT_SLOT( slotPathChanged( ListPanel* ) ) );
connect( panel, TQ_SIGNAL( pathChanged( ListPanel* ) ), this, TQ_SLOT( slotPathChanged( ListPanel* ) ) );
}
DirHistoryQueue::~DirHistoryQueue() {}

8
krusader/GUI/kcmdline.cpp
Unescape View File

@ -86,9 +86,9 @@ KCMDLine::KCMDLine( TQWidget *parent, const char *name ) : TQWidget( parent, nam
TQStringList list = krConfig->readListEntry( "cmdline history" );
cmdLine->setHistoryItems( list );
connect( cmdLine, TQT_SIGNAL( returnPressed(const TQString &) ), this, TQT_SLOT( slotRun() ) );
connect( cmdLine, TQT_SIGNAL( returnPressed(const TQString &) ), cmdLine, TQT_SLOT( clearEdit() ) );
connect( cmdLine, TQT_SIGNAL( returnToPanel() ), this, TQT_SLOT( slotReturnFocus() ));
connect( cmdLine, TQ_SIGNAL( returnPressed(const TQString &) ), this, TQ_SLOT( slotRun() ) );
connect( cmdLine, TQ_SIGNAL( returnPressed(const TQString &) ), cmdLine, TQ_SLOT( clearEdit() ) );
connect( cmdLine, TQ_SIGNAL( returnToPanel() ), this, TQ_SLOT( slotReturnFocus() ));
TQWhatsThis::add
( cmdLine, i18n( "<qt><p>Well, it's actually quite simple: You type your command here and Krusader obeys.</p><p><b>Tip</b>: Move within command line history with &lt;Up&gt; and &lt;Down&gt; arrows.</p></qt>" ) );
@ -98,7 +98,7 @@ KCMDLine::KCMDLine( TQWidget *parent, const char *name ) : TQWidget( parent, nam
buttonAddPlaceholder->setFixedSize(22,20);
buttonAddPlaceholder->adjustSize();
buttonAddPlaceholder->setPixmap( SmallIcon( "add" ) );
connect( buttonAddPlaceholder, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addPlaceholder() ) );
connect( buttonAddPlaceholder, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addPlaceholder() ) );
TQWhatsThis::add( buttonAddPlaceholder, i18n( "Add <b>Placeholders</b> for the selected files in the panel." ) );
layout->addWidget( buttonAddPlaceholder, 0, 2 );

18
krusader/GUI/kfnkeys.cpp
Unescape View File

@ -51,49 +51,49 @@ KFnKeys::KFnKeys(TQWidget *parent, char *name): TQWidget(parent,name) {
TQToolTip::add( F2, "<qt>" + i18n( "<p>Open terminal in current directory.</p>"
"<p>The terminal can be defined in Konfigurator, "
"default is <b>konsole</b>.</p>" ) + "</qt>" );
connect(F2,TQT_SIGNAL(clicked()), SLOTS, TQT_SLOT(terminal()));
connect(F2,TQ_SIGNAL(clicked()), SLOTS, TQ_SLOT(terminal()));
SETUP(F2);
F3=new TQPushButton( i18n("F3 View ") ,this);
TQToolTip::add( F3, i18n( "Open file in viewer." ) );
connect(F3,TQT_SIGNAL(clicked()), SLOTS, TQT_SLOT(view()));
connect(F3,TQ_SIGNAL(clicked()), SLOTS, TQ_SLOT(view()));
SETUP(F3);
F4=new TQPushButton( i18n("F4 Edit ") ,this);
TQToolTip::add( F4, "<qt>" + i18n( "<p>Edit file.</p>"
"<p>The editor can be defined in Konfigurator, "
"default is <b>internal editor</b>.</p>" ) + "</qt>" );
connect(F4,TQT_SIGNAL(clicked()), SLOTS, TQT_SLOT(edit()));
connect(F4,TQ_SIGNAL(clicked()), SLOTS, TQ_SLOT(edit()));
SETUP(F4);
F5=new TQPushButton( i18n("F5 Copy ") ,this);
TQToolTip::add( F5, i18n( "Copy file from one panel to the other." ) );
connect(F5,TQT_SIGNAL(clicked()), SLOTS, TQT_SLOT(copyFiles()));
connect(F5,TQ_SIGNAL(clicked()), SLOTS, TQ_SLOT(copyFiles()));
SETUP(F5);
F6=new TQPushButton( i18n("F6 Move") ,this);
TQToolTip::add( F6, i18n( "Move file from one panel to the other." ) );
connect(F6,TQT_SIGNAL(clicked()), SLOTS, TQT_SLOT(moveFiles()));
connect(F6,TQ_SIGNAL(clicked()), SLOTS, TQ_SLOT(moveFiles()));
SETUP(F6);
F7=new TQPushButton( i18n("F7 Mkdir ") ,this);
TQToolTip::add( F7, i18n( "Create directory in current panel." ) );
connect(F7,TQT_SIGNAL(clicked()), SLOTS, TQT_SLOT(mkdir()));
connect(F7,TQ_SIGNAL(clicked()), SLOTS, TQ_SLOT(mkdir()));
SETUP(F7);
F8=new TQPushButton( i18n("F8 Delete") ,this);
TQToolTip::add( F8, i18n( "Delete file, directory, etc." ) );
connect(F8,TQT_SIGNAL(clicked()), SLOTS, TQT_SLOT(deleteFiles()));
connect(F8,TQ_SIGNAL(clicked()), SLOTS, TQ_SLOT(deleteFiles()));
SETUP(F8);
F9=new TQPushButton( i18n("F9 Rename") ,this);
TQToolTip::add( F9, i18n( "Rename file, directory, etc." ) );
connect(F9,TQT_SIGNAL(clicked()), SLOTS, TQT_SLOT(rename()));
connect(F9,TQ_SIGNAL(clicked()), SLOTS, TQ_SLOT(rename()));
SETUP(F9);
F10=new TQPushButton( i18n("F10 Quit ") ,this);
TQToolTip::add( F10, i18n( "Quit Krusader." ) );
connect(F10,TQT_SIGNAL(clicked()),krApp, TQT_SLOT(slotClose()));
connect(F10,TQ_SIGNAL(clicked()),krApp, TQ_SLOT(slotClose()));
SETUP(F10);
// set a tighter box around the keys

12
krusader/GUI/krremoteencodingmenu.cpp
Unescape View File

@ -46,7 +46,7 @@
KrRemoteEncodingMenu::KrRemoteEncodingMenu(const TQString &text, const TQString &icon, TQObject *parent, const char *name) :
TDEActionMenu( text, icon, parent, name ), settingsLoaded( false )
{
connect(popupMenu(), TQT_SIGNAL(aboutToShow()), this, TQT_SLOT(slotAboutToShow()));
connect(popupMenu(), TQ_SIGNAL(aboutToShow()), this, TQ_SLOT(slotAboutToShow()));
}
void KrRemoteEncodingMenu::slotAboutToShow()
@ -91,11 +91,11 @@ void KrRemoteEncodingMenu::loadSettings()
TQStringList::ConstIterator it;
int count = 0;
for (it = encodingNames.begin(); it != encodingNames.end(); ++it)
menu->insertItem(*it, this, TQT_SLOT(slotItemSelected(int)), 0, ++count);
menu->insertItem(*it, this, TQ_SLOT(slotItemSelected(int)), 0, ++count);
menu->insertSeparator();
menu->insertItem(i18n("Reload"), this, TQT_SLOT(slotReload()), 0, ++count);
menu->insertItem(i18n("Default"), this, TQT_SLOT(slotDefault()), 0, ++count);
menu->insertItem(i18n("Reload"), this, TQ_SLOT(slotReload()), 0, ++count);
menu->insertItem(i18n("Default"), this, TQ_SLOT(slotDefault()), 0, ++count);
defaultID = count;
}
@ -103,7 +103,7 @@ int KrRemoteEncodingMenu::plug( TQWidget *widget, int index )
{
if( widget->inherits( "TQPopupMenu" ) )
{
connect( widget, TQT_SIGNAL(aboutToShow()), this, TQT_SLOT(slotCheckEnabled()));
connect( widget, TQ_SIGNAL(aboutToShow()), this, TQ_SLOT(slotCheckEnabled()));
slotCheckEnabled();
}
@ -201,7 +201,7 @@ void KrRemoteEncodingMenu::updateKIOSlaves()
delete client;
// Reload the page with the new charset
TQTimer::singleShot( 500, ACTIVE_FUNC, TQT_SLOT( refresh() ) );
TQTimer::singleShot( 500, ACTIVE_FUNC, TQ_SLOT( refresh() ) );
}
#include "krremoteencodingmenu.moc"

20
krusader/GUI/mediabutton.cpp
Unescape View File

@ -88,11 +88,11 @@ MediaButton::MediaButton( TQWidget *parent, const char *name ) : TQToolButton( p
setPopup( popupMenu );
connect( popupMenu, TQT_SIGNAL( aboutToShow() ), this, TQT_SLOT( slotAboutToShow() ) );
connect( popupMenu, TQT_SIGNAL( aboutToHide() ), this, TQT_SLOT( slotAboutToHide() ) );
connect( popupMenu, TQT_SIGNAL( activated( int ) ), this, TQT_SLOT( slotPopupActivated( int ) ) );
connect( popupMenu, TQ_SIGNAL( aboutToShow() ), this, TQ_SLOT( slotAboutToShow() ) );
connect( popupMenu, TQ_SIGNAL( aboutToHide() ), this, TQ_SLOT( slotAboutToHide() ) );
connect( popupMenu, TQ_SIGNAL( activated( int ) ), this, TQ_SLOT( slotPopupActivated( int ) ) );
connect( &mountCheckerTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( slotTimeout() ) );
connect( &mountCheckerTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( slotTimeout() ) );
}
MediaButton::~MediaButton() {
@ -130,10 +130,10 @@ void MediaButton::slotAboutToHide() {
void MediaButton::createListWithMedia() {
TDEIO::ListJob *job = TDEIO::listDir( KURL( "media:/" ), false );
connect( job, TQT_SIGNAL( entries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ),
this, TQT_SLOT( slotEntries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ) );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( slotListResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( entries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ),
this, TQ_SLOT( slotEntries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( slotListResult( TDEIO::Job* ) ) );
busy = true;
if( !busy )
@ -479,8 +479,8 @@ void MediaButton::addMountPoint( KMountPoint * mp, bool isMounted ) {
if( isMounted ) {
KDiskFreeSp *sp = KDiskFreeSp::findUsageInfo( mp->mountPoint() );
connect( sp, TQT_SIGNAL( foundMountPoint( const TQString &, unsigned long, unsigned long, unsigned long ) ),
this, TQT_SLOT( gettingSpaceData( const TQString&, unsigned long, unsigned long, unsigned long ) ) );
connect( sp, TQ_SIGNAL( foundMountPoint( const TQString &, unsigned long, unsigned long, unsigned long ) ),
this, TQ_SLOT( gettingSpaceData( const TQString&, unsigned long, unsigned long, unsigned long ) ) );
}
TQPixmap pixmap = FL_LOADICON( KMimeType::mimeType( mime ) ->icon( TQString(), true ) );

2
krusader/GUI/profilemanager.cpp
Unescape View File

@ -48,7 +48,7 @@ ProfileManager::ProfileManager( TQString profileType, TQWidget * parent, const c
this->profileType = profileType;
connect( this, TQT_SIGNAL( clicked() ), this, TQT_SLOT( profilePopup() ) );
connect( this, TQ_SIGNAL( clicked() ), this, TQ_SLOT( profilePopup() ) );
krConfig->setGroup("Private");
profileList = krConfig->readListEntry( profileType );

2
krusader/GUI/syncbrowsebutton.cpp
Unescape View File

@ -46,7 +46,7 @@ SyncBrowseButton::SyncBrowseButton(TQWidget *parent, const char *name) : TQToolB
"When active, each directory change is performed in the\n"
"active and inactive panel - if possible." ), true ); //set this as toop-tip (somehow whatsthis::add(this, ...) don't work)
connect( this, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotToggled(bool)) );
connect( this, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotToggled(bool)) );
}
SyncBrowseButton::~SyncBrowseButton() {

6
krusader/KViewer/diskusageviewer.cpp
Unescape View File

@ -56,9 +56,9 @@ void DiskUsageViewer::openURL( KURL url )
{
diskUsage = new DiskUsage( "DiskUsageViewer", this );
connect( diskUsage, TQT_SIGNAL( enteringDirectory( Directory * ) ), this, TQT_SLOT( slotUpdateStatus() ) );
connect( diskUsage, TQT_SIGNAL( status( TQString ) ), this, TQT_SLOT( slotUpdateStatus( TQString ) ) );
connect( diskUsage, TQT_SIGNAL( newSearch() ), this, TQT_SLOT( slotNewSearch() ) );
connect( diskUsage, TQ_SIGNAL( enteringDirectory( Directory * ) ), this, TQ_SLOT( slotUpdateStatus() ) );
connect( diskUsage, TQ_SIGNAL( status( TQString ) ), this, TQ_SLOT( slotUpdateStatus( TQString ) ) );
connect( diskUsage, TQ_SIGNAL( newSearch() ), this, TQ_SLOT( slotNewSearch() ) );
layout->addWidget( diskUsage, 0, 0 );
this->show();
diskUsage->show();

14
krusader/KViewer/kimagefilepreview.cpp
Unescape View File

@ -41,7 +41,7 @@ m_job( 0L ) {
vb->addWidget( imageLabel, 1 );
timer = new TQTimer( this );
connect( timer, TQT_SIGNAL( timeout() ), TQT_SLOT( showPreview() ) );
connect( timer, TQ_SIGNAL( timeout() ), TQ_SLOT( showPreview() ) );
setSupportedMimeTypes( TDEIO::PreviewJob::supportedMimeTypes() );
}
@ -76,14 +76,14 @@ void KrusaderImageFilePreview::showPreview( const KURL &url, bool force ) {
int h = imageLabel->contentsRect().height() - 4;
m_job = createJob( url, w, h );
connect( m_job, TQT_SIGNAL( result( TDEIO::Job * ) ),
this, TQT_SLOT( slotResult( TDEIO::Job * ) ) );
connect( m_job, TQT_SIGNAL( gotPreview( const KFileItem*,
connect( m_job, TQ_SIGNAL( result( TDEIO::Job * ) ),
this, TQ_SLOT( slotResult( TDEIO::Job * ) ) );
connect( m_job, TQ_SIGNAL( gotPreview( const KFileItem*,
const TQPixmap& ) ),
TQT_SLOT( gotPreview( const KFileItem*, const TQPixmap& ) ) );
TQ_SLOT( gotPreview( const KFileItem*, const TQPixmap& ) ) );
connect( m_job, TQT_SIGNAL( failed( const KFileItem* ) ),
this, TQT_SLOT( slotFailed( const KFileItem* ) ) );
connect( m_job, TQ_SIGNAL( failed( const KFileItem* ) ),
this, TQ_SLOT( slotFailed( const KFileItem* ) ) );
}
}

66
krusader/KViewer/krviewer.cpp
Unescape View File

@ -63,12 +63,12 @@ KParts::MainWindow( parent, name ), manager( this, this ), tabBar( this ), retur
setAutoSaveSettings( "KrViewerWindow", true );
tmpFile.setAutoDelete( true );
connect( &manager, TQT_SIGNAL( activePartChanged( KParts::Part* ) ),
this, TQT_SLOT( createGUI( KParts::Part* ) ) );
connect( &tabBar, TQT_SIGNAL( currentChanged( TQWidget *) ),
this, TQT_SLOT( tabChanged(TQWidget*) ) );
connect( &tabBar, TQT_SIGNAL( closeRequest( TQWidget *) ),
this, TQT_SLOT( tabCloseRequest(TQWidget*) ) );
connect( &manager, TQ_SIGNAL( activePartChanged( KParts::Part* ) ),
this, TQ_SLOT( createGUI( KParts::Part* ) ) );
connect( &tabBar, TQ_SIGNAL( currentChanged( TQWidget *) ),
this, TQ_SLOT( tabChanged(TQWidget*) ) );
connect( &tabBar, TQ_SIGNAL( closeRequest( TQWidget *) ),
this, TQ_SLOT( tabCloseRequest(TQWidget*) ) );
tabBar.setTabReorderingEnabled(false);
#if KDE_IS_VERSION(3,4,0)
@ -78,28 +78,28 @@ KParts::MainWindow( parent, name ), manager( this, this ), tabBar( this ), retur
// "document-save-as"
setCentralWidget( &tabBar );
printAction = KStdAction::print( this, TQT_SLOT( print() ), 0, 0 );
copyAction = KStdAction::copy( this, TQT_SLOT( copy() ), 0, 0 );
printAction = KStdAction::print( this, TQ_SLOT( print() ), 0, 0 );
copyAction = KStdAction::copy( this, TQ_SLOT( copy() ), 0, 0 );
viewerMenu = new TQPopupMenu( this );
viewerMenu->insertItem( i18n( "&Generic viewer" ), this, TQT_SLOT( viewGeneric() ), CTRL + SHIFT + Key_G, 1 );
viewerMenu->insertItem( i18n( "&Text viewer" ), this, TQT_SLOT( viewText() ), CTRL + SHIFT + Key_T, 2 );
viewerMenu->insertItem( i18n( "&Hex viewer" ), this, TQT_SLOT( viewHex() ), CTRL + SHIFT + Key_H, 3 );
viewerMenu->insertItem( i18n( "&Generic viewer" ), this, TQ_SLOT( viewGeneric() ), CTRL + SHIFT + Key_G, 1 );
viewerMenu->insertItem( i18n( "&Text viewer" ), this, TQ_SLOT( viewText() ), CTRL + SHIFT + Key_T, 2 );
viewerMenu->insertItem( i18n( "&Hex viewer" ), this, TQ_SLOT( viewHex() ), CTRL + SHIFT + Key_H, 3 );
viewerMenu->insertSeparator();
viewerMenu->insertItem( i18n( "Text &editor" ), this, TQT_SLOT( editText() ), CTRL + SHIFT + Key_E, 4 );
viewerMenu->insertItem( i18n( "Text &editor" ), this, TQ_SLOT( editText() ), CTRL + SHIFT + Key_E, 4 );
viewerMenu->insertSeparator();
viewerMenu->insertItem( i18n( "&Next tab" ), this, TQT_SLOT( nextTab() ), ALT+Key_Right );
viewerMenu->insertItem( i18n( "&Previous tab" ), this, TQT_SLOT( prevTab() ), ALT+Key_Left );
viewerMenu->insertItem( i18n( "&Next tab" ), this, TQ_SLOT( nextTab() ), ALT+Key_Right );
viewerMenu->insertItem( i18n( "&Previous tab" ), this, TQ_SLOT( prevTab() ), ALT+Key_Left );
detachActionIndex = viewerMenu->insertItem( i18n( "&Detach tab" ), this, TQT_SLOT( detachTab() ), CTRL + SHIFT + Key_D );
detachActionIndex = viewerMenu->insertItem( i18n( "&Detach tab" ), this, TQ_SLOT( detachTab() ), CTRL + SHIFT + Key_D );
//no point in detaching only one tab..
viewerMenu->setItemEnabled(detachActionIndex,false);
viewerMenu->insertSeparator();
viewerMenu->insertItem( printAction->text(), this, TQT_SLOT( print() ), printAction->shortcut() );
viewerMenu->insertItem( copyAction->text(), this, TQT_SLOT( copy() ), copyAction->shortcut() );
viewerMenu->insertItem( printAction->text(), this, TQ_SLOT( print() ), printAction->shortcut() );
viewerMenu->insertItem( copyAction->text(), this, TQ_SLOT( copy() ), copyAction->shortcut() );
viewerMenu->insertSeparator();
tabCloseID = viewerMenu->insertItem( i18n( "&Close current tab" ), this, TQT_SLOT( tabCloseRequest() ), Key_Escape );
closeID = viewerMenu->insertItem( i18n( "&Quit" ), this, TQT_SLOT( close() ), CTRL + Key_Q );
tabCloseID = viewerMenu->insertItem( i18n( "&Close current tab" ), this, TQ_SLOT( tabCloseRequest() ), Key_Escape );
closeID = viewerMenu->insertItem( i18n( "&Quit" ), this, TQ_SLOT( close() ), CTRL + Key_Q );
//toolBar() ->insertLined("Edit:",1,"",this,"",true ,i18n("Enter an URL to edit and press enter"));
@ -110,8 +110,8 @@ KParts::MainWindow( parent, name ), manager( this, this ), tabBar( this ), retur
KrViewer::~KrViewer() {
disconnect( &manager, TQT_SIGNAL( activePartChanged( KParts::Part* ) ),
this, TQT_SLOT( createGUI( KParts::Part* ) ) );
disconnect( &manager, TQ_SIGNAL( activePartChanged( KParts::Part* ) ),
this, TQ_SLOT( createGUI( KParts::Part* ) ) );
viewers.remove( this );
delete printAction;
@ -124,8 +124,8 @@ void KrViewer::createGUI( KParts::Part* part ) {
// and show the new part widget
connect( part, TQT_SIGNAL( setStatusBarText( const TQString& ) ),
this, TQT_SLOT( slotSetStatusBarText( const TQString& ) ) );
connect( part, TQ_SIGNAL( setStatusBarText( const TQString& ) ),
this, TQ_SLOT( slotSetStatusBarText( const TQString& ) ) );
KParts::MainWindow::createGUI( part );
toolBar() ->insertLineSeparator(0);
@ -179,9 +179,9 @@ bool KrViewer::eventFilter ( TQObject * /* watched */, TQEvent * e )
// don't activate the close functions immediately!
// it can cause crash
if( id == tabCloseID )
TQTimer::singleShot( 0, this, TQT_SLOT( tabCloseRequest() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( tabCloseRequest() ) );
else if( id == closeID )
TQTimer::singleShot( 0, this, TQT_SLOT( close() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( close() ) );
else {
int index = viewerMenu->indexOf( id );
viewerMenu->activateItemAt( index );
@ -319,8 +319,8 @@ void KrViewer::addTab(PanelViewerBase* pvb, TQString msg, TQString iconName ,KPa
show();
tabBar.show();
connect( pvb, TQT_SIGNAL( urlChanged( PanelViewerBase *, const KURL & ) ),
this, TQT_SLOT( tabURLChanged(PanelViewerBase *, const KURL & ) ) );
connect( pvb, TQ_SIGNAL( urlChanged( PanelViewerBase *, const KURL & ) ),
this, TQ_SLOT( tabURLChanged(PanelViewerBase *, const KURL & ) ) );
}
void KrViewer::tabURLChanged( PanelViewerBase *pvb, const KURL & url ) {
@ -439,7 +439,7 @@ void KrViewer::editText(){
}
void KrViewer::checkModified(){
TQTimer::singleShot( 1000, this, TQT_SLOT(checkModified()) );
TQTimer::singleShot( 1000, this, TQ_SLOT(checkModified()) );
PanelViewerBase* pvb = static_cast<PanelViewerBase*>( tabBar.currentPage() );
if( !pvb ) return;
@ -514,7 +514,7 @@ void KrViewer::print() {
KParts::BrowserExtension * ext = KParts::BrowserExtension::childObject( pvb->part() );
if( ext && ext->isActionEnabled( "print" ) )
Invoker( ext, TQT_SLOT( print() ) ).invoke();
Invoker( ext, TQ_SLOT( print() ) ).invoke();
}
void KrViewer::copy() {
@ -523,7 +523,7 @@ void KrViewer::copy() {
KParts::BrowserExtension * ext = KParts::BrowserExtension::childObject( pvb->part() );
if( ext && ext->isActionEnabled( "copy" ) )
Invoker( ext, TQT_SLOT( copy() ) ).invoke();
Invoker( ext, TQ_SLOT( copy() ) ).invoke();
}
PanelViewerBase * KrViewer::getPanelViewerBase( KParts::Part * part ) {
@ -608,11 +608,11 @@ bool KrViewer::viewGeneric() {
if ( !generic_part ) {
if ( mimetype.contains( "html" ) ) {
TDEHTMLPart * p = new TDEHTMLPart( this, 0, 0, 0, TDEHTMLPart::BrowserViewGUI );
connect( p->browserExtension(), TQT_SIGNAL( openURLRequest( const KURL &, const KParts::URLArgs & ) ),
this, TQT_SLOT( handleOpenURLRequest( const KURL &, const KParts::URLArgs & ) ) );
connect( p->browserExtension(), TQ_SIGNAL( openURLRequest( const KURL &, const KParts::URLArgs & ) ),
this, TQ_SLOT( handleOpenURLRequest( const KURL &, const KParts::URLArgs & ) ) );
/* At JavaScript self.close() the TDEHTMLPart destroys itself. */
/* After destruction, just close the window */
connect( p, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( close() ) );
connect( p, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( close() ) );
p-> openURL( url );
generic_part = p;

2
krusader/KViewer/krviewer.h
Unescape View File

@ -116,7 +116,7 @@ class Invoker : public TQObject {
public:
Invoker( TQObject *recv, const char * slot ) {
connect( this, TQT_SIGNAL( invokeSignal() ), recv, slot );
connect( this, TQ_SIGNAL( invokeSignal() ), recv, slot );
}
void invoke() {

10
krusader/KViewer/panelviewer.cpp
Unescape View File

@ -124,8 +124,8 @@ KParts::ReadOnlyPart* PanelViewer::getPart( TQString mimetype ) {
if ( part ) {
KParts::BrowserExtension * ext = KParts::BrowserExtension::childObject( part );
if ( ext ) {
connect( ext, TQT_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs & ) ), this, TQT_SLOT( openURL( const KURL & ) ) );
connect( ext, TQT_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs & ) ), this, TQT_SIGNAL( openURLRequest( const KURL & ) ) );
connect( ext, TQ_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs & ) ), this, TQ_SLOT( openURL( const KURL & ) ) );
connect( ext, TQ_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs & ) ), this, TQ_SIGNAL( openURLRequest( const KURL & ) ) );
}
}
return part;
@ -231,7 +231,7 @@ KParts::ReadOnlyPart* PanelEditor::openURL( const KURL &url, KrViewer::Mode mode
bool create = true;
TDEIO::StatJob* statJob = TDEIO::stat( url, false );
connect( statJob, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotStatResult( TDEIO::Job* ) ) );
connect( statJob, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotStatResult( TDEIO::Job* ) ) );
busy = true;
while ( busy ) tqApp->processEvents();
if( !entry.isEmpty() ) {
@ -287,8 +287,8 @@ KParts::ReadWritePart* PanelEditor::getPart( TQString mimetype ) {
if ( part ) {
KParts::BrowserExtension * ext = KParts::BrowserExtension::childObject( part );
if ( ext ) {
connect( ext, TQT_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs & ) ), this, TQT_SLOT( openURL( const KURL & ) ) );
connect( ext, TQT_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs & ) ), this, TQT_SIGNAL( openURLRequest( const KURL & ) ) );
connect( ext, TQ_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs & ) ), this, TQ_SLOT( openURL( const KURL & ) ) );
connect( ext, TQ_SIGNAL( openURLRequestDelayed( const KURL &, const KParts::URLArgs & ) ), this, TQ_SIGNAL( openURLRequest( const KURL & ) ) );
}
}
return part;

2
krusader/Konfigurator/kgarchives.cpp
Unescape View File

@ -81,7 +81,7 @@ KgArchives::KgArchives( bool first, TQWidget* parent, const char* name ) :
TQPushButton *btnAutoConfigure = new TQPushButton( i18n( "Auto Configure" ), hbox, "kgAutoConfigure" );
createSpacer( hbox, "spacer2" );
generalGrid->addWidget( hbox, 3, 0 );
connect( btnAutoConfigure, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotAutoConfigure() ) );
connect( btnAutoConfigure, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotAutoConfigure() ) );
kgArchivesLayout->addWidget( generalGrp, 0 ,0 );

36
krusader/Konfigurator/kgcolors.cpp
Unescape View File

@ -66,10 +66,10 @@ KgColors::KgColors( bool first, TQWidget* parent, const char* name ) :
generals->layout()->setSpacing( 5 );
connect( generals->find( "KDE Default" ), TQT_SIGNAL( stateChanged( int ) ), this, TQT_SLOT( slotDisable() ) );
connect( generals->find( "Enable Alternate Background" ), TQT_SIGNAL( stateChanged( int ) ), this, TQT_SLOT( generatePreview() ) );
connect( generals->find( "Show Current Item Always" ), TQT_SIGNAL( stateChanged( int ) ), this, TQT_SLOT( slotDisable() ) );
connect( generals->find( "Dim Inactive Colors" ), TQT_SIGNAL( stateChanged( int ) ), this, TQT_SLOT( slotDisable() ) );
connect( generals->find( "KDE Default" ), TQ_SIGNAL( stateChanged( int ) ), this, TQ_SLOT( slotDisable() ) );
connect( generals->find( "Enable Alternate Background" ), TQ_SIGNAL( stateChanged( int ) ), this, TQ_SLOT( generatePreview() ) );
connect( generals->find( "Show Current Item Always" ), TQ_SIGNAL( stateChanged( int ) ), this, TQ_SLOT( slotDisable() ) );
connect( generals->find( "Dim Inactive Colors" ), TQ_SIGNAL( stateChanged( int ) ), this, TQ_SLOT( slotDisable() ) );
kgColorsLayout->addMultiCellWidget( generalGrp, 0 ,0, 0, 2 );
TQHBox *hbox = new TQHBox( parent );
@ -83,7 +83,7 @@ KgColors::KgColors( bool first, TQWidget* parent, const char* name ) :
colorTabWidget = new TQTabWidget( colorsFrameGrp, "colorTabWidget" );
connect( colorTabWidget, TQT_SIGNAL( currentChanged ( TQWidget * ) ), this, TQT_SLOT( generatePreview() ) );
connect( colorTabWidget, TQ_SIGNAL( currentChanged ( TQWidget * ) ), this, TQ_SLOT( generatePreview() ) );
colorsGrp = new TQWidget( colorTabWidget, "colorTab" );
colorTabWidget->insertTab( colorsGrp, i18n( "Active" ) );
@ -113,10 +113,10 @@ KgColors::KgColors( bool first, TQWidget* parent, const char* name ) :
colorsGrid->addWidget(createSpacer(colorsGrp, ""), itemList.count() - offset, 1);
connect( getColorSelector( "Foreground" ), TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotForegroundChanged() ) );
connect( getColorSelector( "Background" ), TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotBackgroundChanged() ) );
connect( getColorSelector( "Alternate Background" ), TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotAltBackgroundChanged() ) );
connect( getColorSelector( "Marked Background" ), TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotMarkedBackgroundChanged() ) );
connect( getColorSelector( "Foreground" ), TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotForegroundChanged() ) );
connect( getColorSelector( "Background" ), TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotBackgroundChanged() ) );
connect( getColorSelector( "Alternate Background" ), TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotAltBackgroundChanged() ) );
connect( getColorSelector( "Marked Background" ), TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotMarkedBackgroundChanged() ) );
inactiveColorStack = new TQWidgetStack( colorTabWidget, "colorTab2" );
colorTabWidget->insertTab( inactiveColorStack, i18n( "Inactive" ) );
@ -150,10 +150,10 @@ KgColors::KgColors( bool first, TQWidget* parent, const char* name ) :
colorsGrid->addWidget(createSpacer(normalInactiveWidget, ""), itemList.count() - offset, 1);
connect( getColorSelector( "Inactive Foreground" ), TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotInactiveForegroundChanged() ) );
connect( getColorSelector( "Inactive Background" ), TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotInactiveBackgroundChanged() ) );
connect( getColorSelector( "Inactive Alternate Background" ), TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotInactiveAltBackgroundChanged() ) );
connect( getColorSelector( "Inactive Marked Background" ), TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotInactiveMarkedBackgroundChanged() ) );
connect( getColorSelector( "Inactive Foreground" ), TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotInactiveForegroundChanged() ) );
connect( getColorSelector( "Inactive Background" ), TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotInactiveBackgroundChanged() ) );
connect( getColorSelector( "Inactive Alternate Background" ), TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotInactiveAltBackgroundChanged() ) );
connect( getColorSelector( "Inactive Marked Background" ), TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotInactiveMarkedBackgroundChanged() ) );
offset = endOfPanelColors = itemList.count();
@ -171,7 +171,7 @@ KgColors::KgColors( bool first, TQWidget* parent, const char* name ) :
labelList.append( addLabel( colorsGrid, index, 0, i18n("Dim factor:"), colorsGrp, TQString( "ColorsLabel%1" ).arg( index ).ascii() ) );
dimFactor = createSpinBox("Colors", "Dim Factor", 100, 0, 100, colorsGrp);
dimFactor->setSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Fixed );
connect( dimFactor, TQT_SIGNAL( valueChanged( int ) ), this, TQT_SLOT( generatePreview() ) );
connect( dimFactor, TQ_SIGNAL( valueChanged( int ) ), this, TQ_SLOT( generatePreview() ) );
colorsGrid->addWidget( dimFactor, index++, 1 );
colorsGrid->addWidget(createSpacer(dimmedInactiveWidget, ""), itemList.count() + 1 - offset, 1);
@ -230,8 +230,8 @@ KgColors::KgColors( bool first, TQWidget* parent, const char* name ) :
exportBtn = new KPushButton(i18n("Export color-scheme"),parent);
kgColorsLayout->addWidget(exportBtn,2,1);
kgColorsLayout->addWidget(createSpacer(parent, ""), 2,2);
connect(importBtn, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotImportColors()));
connect(exportBtn, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotExportColors()));
connect(importBtn, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotImportColors()));
connect(exportBtn, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotExportColors()));
slotDisable();
}
@ -250,9 +250,9 @@ int KgColors::addColorSelector( TQString cfgName, TQString name, TQColor dflt, T
colorsGrid->addWidget( chooser, index, 1 );
connect( chooser, TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( generatePreview() ) );
connect( chooser, TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( generatePreview() ) );
if( !offset )
connect( chooser, TQT_SIGNAL( colorChanged() ), this, TQT_SLOT( slotActiveChanged() ) );
connect( chooser, TQ_SIGNAL( colorChanged() ), this, TQ_SLOT( slotActiveChanged() ) );
itemList.append( chooser );
itemNames.append( cfgName );

4
krusader/Konfigurator/kgdependencies.cpp
Unescape View File

@ -136,8 +136,8 @@ void KgDependencies::addApplication( TQString name, TQGridLayout *grid, int row,
addLabel( grid, row, 0, name, parent, (TQString( "label:" )+name).ascii() );
KonfiguratorURLRequester *fullPath = createURLRequester( "Dependencies", name, dflt, parent, false, page );
connect( fullPath->extension(), TQT_SIGNAL( applyManually( TQObject *, TQString, TQString ) ),
this, TQT_SLOT( slotApply( TQObject *, TQString, TQString ) ) );
connect( fullPath->extension(), TQ_SIGNAL( applyManually( TQObject *, TQString, TQString ) ),
this, TQ_SLOT( slotApply( TQObject *, TQString, TQString ) ) );
grid->addWidget( fullPath, row, 1 );
}

8
krusader/Konfigurator/kggeneral.cpp
Unescape View File

@ -120,13 +120,13 @@ TQFrame *line2 = createLine( generalGrp, "line2" );
TQPixmap icon = krLoader->loadIcon("add",TDEIcon::Desktop, size );
addButton->setFixedSize( icon.width() + 4, icon.height() + 4 );
addButton->setPixmap( icon );
connect( addButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotAddExtension() ) );
connect( addButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotAddExtension() ) );
TQToolButton *removeButton = new TQToolButton( hbox3, "removeBtnList" );
icon = krLoader->loadIcon("remove",TDEIcon::Desktop, size );
removeButton->setFixedSize( icon.width() + 4, icon.height() + 4 );
removeButton->setPixmap( icon );
connect( removeButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotRemoveExtension() ) );
connect( removeButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotRemoveExtension() ) );
TQStringList defaultAtomicExtensions;
defaultAtomicExtensions += ".tar.gz";
@ -161,8 +161,8 @@ TQFrame *line2 = createLine( generalGrp, "line2" );
KonfiguratorURLRequester *urlReq3 = createURLRequester( "General", "Temp Directory", "/tmp/krusader.tmp",
hbox, false );
urlReq3->setMode( KFile::Directory );
connect( urlReq3->extension(), TQT_SIGNAL( applyManually(TQObject *,TQString, TQString) ),
this, TQT_SLOT( applyTempDir(TQObject *,TQString, TQString) ) );
connect( urlReq3->extension(), TQ_SIGNAL( applyManually(TQObject *,TQString, TQString) ),
this, TQ_SLOT( applyTempDir(TQObject *,TQString, TQString) ) );
generalGrid->addMultiCellWidget( hbox, 13, 13, 0, 1 );
TQLabel *label4 = new TQLabel( i18n( "Note: you must have full permissions for the temporary directory!" ),

6
krusader/Konfigurator/kglookfeel.cpp
Unescape View File

@ -107,7 +107,7 @@ void KgLookFeel::setupOperationTab() {
quicksearchCheckboxes = createCheckBoxGroup( 2, 0, quicksearch, 2 /*count*/, quicksearchGroup, 0, PAGE_OPERATION );
quicksearchGrid->addWidget( quicksearchCheckboxes, 0, 0 );
connect( quicksearchCheckboxes->find( "New Style Quicksearch" ), TQT_SIGNAL( stateChanged( int ) ), this, TQT_SLOT( slotDisable() ) );
connect( quicksearchCheckboxes->find( "New Style Quicksearch" ), TQ_SIGNAL( stateChanged( int ) ), this, TQ_SLOT( slotDisable() ) );
slotDisable();
lookAndFeelLayout->addWidget( quicksearchGroup, 1, 0 );
@ -197,7 +197,7 @@ void KgLookFeel::setupPanelToolbarTab() {
};
panelToolbarActive = createCheckBoxGroup( 1, 0, panelToolbarActiveCheckbox, 1, tab_4, "panelToolbarActive", PAGE_PANELTOOLBAR);
connect( panelToolbarActive->find( "Panel Toolbar visible" ), TQT_SIGNAL( stateChanged( int ) ), this, TQT_SLOT( slotEnablePanelToolbar() ) );
connect( panelToolbarActive->find( "Panel Toolbar visible" ), TQ_SIGNAL( stateChanged( int ) ), this, TQ_SLOT( slotEnablePanelToolbar() ) );
TQGroupBox * panelToolbarGrp = createFrame( i18n( "Visible Panel Toolbar buttons" ), tab_4, "panelToolbarGrp");
TQGridLayout * panelToolbarGrid = createGridLayout( panelToolbarGrp->layout() );
@ -253,7 +253,7 @@ void KgLookFeel::setupMouseModeTab() {
mouseRadio = createRadioButtonGroup( "Look&Feel", "Mouse Selection", "0", 2, 2, mouseSelection, 4, mouseGeneralGroup, "myLook&FeelRadio", true, PAGE_MOUSE );
mouseRadio->layout()->setMargin( 0 );
mouseGeneralGrid->addWidget( mouseRadio, 0, 0 );
connect( mouseRadio, TQT_SIGNAL( clicked(int) ), TQT_SLOT( slotSelectionModeChanged() ) );
connect( mouseRadio, TQ_SIGNAL( clicked(int) ), TQ_SLOT( slotSelectionModeChanged() ) );
mouseLayout->addMultiCellWidget( mouseGeneralGroup, 0,0, 0,1 );

16
krusader/Konfigurator/kgprotocols.cpp
Unescape View File

@ -128,14 +128,14 @@ KgProtocols::KgProtocols( bool first, TQWidget* parent, const char* name ) :
// -------------------------- CONNECT TABLE ----------------------------------
connect( protocolList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotDisableButtons() ) );
connect( linkList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotDisableButtons() ) );
connect( mimeList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotDisableButtons() ) );
connect( linkList, TQT_SIGNAL( currentChanged( TQListViewItem *) ), this, TQT_SLOT( slotDisableButtons() ) );
connect( btnAddProtocol, TQT_SIGNAL( clicked() ) , this, TQT_SLOT( slotAddProtocol() ) );
connect( btnRemoveProtocol, TQT_SIGNAL( clicked() ) , this, TQT_SLOT( slotRemoveProtocol() ) );
connect( btnAddMime, TQT_SIGNAL( clicked() ) , this, TQT_SLOT( slotAddMime() ) );
connect( btnRemoveMime, TQT_SIGNAL( clicked() ) , this, TQT_SLOT( slotRemoveMime() ) );
connect( protocolList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotDisableButtons() ) );
connect( linkList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotDisableButtons() ) );
connect( mimeList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotDisableButtons() ) );
connect( linkList, TQ_SIGNAL( currentChanged( TQListViewItem *) ), this, TQ_SLOT( slotDisableButtons() ) );
connect( btnAddProtocol, TQ_SIGNAL( clicked() ) , this, TQ_SLOT( slotAddProtocol() ) );
connect( btnRemoveProtocol, TQ_SIGNAL( clicked() ) , this, TQ_SLOT( slotRemoveProtocol() ) );
connect( btnAddMime, TQ_SIGNAL( clicked() ) , this, TQ_SLOT( slotAddMime() ) );
connect( btnRemoveMime, TQ_SIGNAL( clicked() ) , this, TQ_SLOT( slotRemoveMime() ) );
loadInitialValues();
slotDisableButtons();

2
krusader/Konfigurator/kgstartup.cpp
Unescape View File

@ -96,7 +96,7 @@ KgStartup::KgStartup( bool first, TQWidget* parent, const char* name ) :
};
uiCbGroup = createCheckBoxGroup( 2, 0, uiCheckBoxes, 8, uiGrp );
connect( uiCbGroup->find( "UI Save Settings" ), TQT_SIGNAL( stateChanged( int ) ), this, TQT_SLOT( slotDisable() ) );
connect( uiCbGroup->find( "UI Save Settings" ), TQ_SIGNAL( stateChanged( int ) ), this, TQ_SLOT( slotDisable() ) );
uiGrid->addWidget( uiCbGroup, 1, 0 );

2
krusader/Konfigurator/kguseractions.cpp
Unescape View File

@ -55,7 +55,7 @@ KgUserActions::KgUserActions( bool first, TQWidget* parent, const char* name )
), InfoGroup, "InformationLabel" );
InfoGrid->addWidget( labelInfo, 0, 0 );
KPushButton *actionmanButton = new KPushButton( i18n("Start ActionMan"), InfoGroup, "actionmanButton");
connect( actionmanButton, TQT_SIGNAL( clicked() ), TQT_SLOT( startActionMan() ) );
connect( actionmanButton, TQ_SIGNAL( clicked() ), TQ_SLOT( startActionMan() ) );
InfoGrid->addWidget( actionmanButton, 1, 0 );
kgUserActionLayout->addWidget( InfoGroup, 0 ,0 );

6
krusader/Konfigurator/konfigurator.cpp
Unescape View File

@ -70,8 +70,8 @@ Konfigurator::Konfigurator( bool f, int startPage ) : KDialogBase(0,0,true,"Konf
setHelp("konfigurator");
connect( widget, TQT_SIGNAL( aboutToShowPage(TQWidget *) ), this, TQT_SLOT( slotPageSwitch() ) );
connect( &restoreTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotRestorePage()));
connect( widget, TQ_SIGNAL( aboutToShowPage(TQWidget *) ), this, TQ_SLOT( slotPageSwitch() ) );
connect( &restoreTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotRestorePage()));
createLayout( startPage );
setMainWidget(widget);
@ -81,7 +81,7 @@ Konfigurator::Konfigurator( bool f, int startPage ) : KDialogBase(0,0,true,"Konf
void Konfigurator::newContent(KonfiguratorPage *page)
{
kgFrames.append(page);
connect( page, TQT_SIGNAL( sigChanged() ), this, TQT_SLOT( slotApplyEnable() ) );
connect( page, TQ_SIGNAL( sigChanged() ), this, TQ_SLOT( slotApplyEnable() ) );
}
void Konfigurator::createLayout( int startPage )

78
krusader/Konfigurator/konfiguratoritems.cpp
Unescape View File

@ -45,8 +45,8 @@ KonfiguratorExtension::KonfiguratorExtension( TQObject *obj, TQString cfgClass,
void KonfiguratorExtension::connectNotify( const char *signal )
{
TQString signalString = TQString( signal ).replace( " ", "" );
TQString applyString = TQString( TQT_SIGNAL( applyManually(TQObject *,TQString, TQString) ) ).replace( " ", "" );
TQString defaultsString = TQString( TQT_SIGNAL( setDefaultsManually(TQObject *) ) ).replace( " ", "" );
TQString applyString = TQString( TQ_SIGNAL( applyManually(TQObject *,TQString, TQString) ) ).replace( " ", "" );
TQString defaultsString = TQString( TQ_SIGNAL( setDefaultsManually(TQObject *) ) ).replace( " ", "" );
if( signalString == applyString )
applyConnected = true;
@ -96,11 +96,11 @@ KonfiguratorCheckBox::KonfiguratorCheckBox( TQString cls, TQString name, bool df
defaultValue( dflt )
{
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
connect( this, TQT_SIGNAL( stateChanged( int ) ), ext, TQT_SLOT( setChanged() ) );
connect( this, TQ_SIGNAL( stateChanged( int ) ), ext, TQ_SLOT( setChanged() ) );
loadInitialValue();
}
@ -136,11 +136,11 @@ KonfiguratorSpinBox::KonfiguratorSpinBox( TQString cls, TQString name, int dflt,
defaultValue( dflt )
{
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
connect( this, TQT_SIGNAL( valueChanged(int) ), ext, TQT_SLOT( setChanged() ) );
connect( this, TQ_SIGNAL( valueChanged(int) ), ext, TQ_SLOT( setChanged() ) );
setMinValue( min );
setMaxValue( max );
@ -208,9 +208,9 @@ KonfiguratorRadioButtons::KonfiguratorRadioButtons( TQString cls, TQString name,
TQButtonGroup( parent, widgetName ), defaultValue( dflt )
{
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
}
KonfiguratorRadioButtons::~KonfiguratorRadioButtons()
@ -224,7 +224,7 @@ void KonfiguratorRadioButtons::addRadioButton( TQRadioButton *radioWidget, TQStr
radioNames.push_back( name );
radioValues.push_back( value );
connect( radioWidget, TQT_SIGNAL( stateChanged(int) ), ext, TQT_SLOT( setChanged() ) );
connect( radioWidget, TQ_SIGNAL( stateChanged(int) ), ext, TQ_SLOT( setChanged() ) );
}
TQRadioButton * KonfiguratorRadioButtons::find( int index )
@ -303,11 +303,11 @@ KonfiguratorEditBox::KonfiguratorEditBox( TQString cls, TQString name, TQString
defaultValue( dflt )
{
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
connect( this, TQT_SIGNAL( textChanged(const TQString &) ), ext, TQT_SLOT( setChanged() ) );
connect( this, TQ_SIGNAL( textChanged(const TQString &) ), ext, TQ_SLOT( setChanged() ) );
loadInitialValue();
}
@ -345,11 +345,11 @@ KonfiguratorURLRequester::KonfiguratorURLRequester( TQString cls, TQString name,
defaultValue( dflt )
{
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
connect( this, TQT_SIGNAL( textChanged(const TQString &) ), ext, TQT_SLOT( setChanged() ) );
connect( this, TQ_SIGNAL( textChanged(const TQString &) ), ext, TQ_SLOT( setChanged() ) );
button()->setIconSet( SmallIcon( "document-open" ) );
loadInitialValue();
@ -387,15 +387,15 @@ KonfiguratorFontChooser::KonfiguratorFontChooser( TQString cls, TQString name, T
defaultValue( dflt )
{
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
pLabel = new TQLabel( this );
pLabel->setMinimumWidth( 150 );
pToolButton = new TQToolButton( this );
connect( pToolButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotBrowseFont() ) );
connect( pToolButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotBrowseFont() ) );
pToolButton->setIconSet( SmallIcon( "document-open" ) );
@ -459,13 +459,13 @@ KonfiguratorComboBox::KonfiguratorComboBox( TQString cls, TQString name, TQStrin
}
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
// connect( this, TQT_SIGNAL( highlighted(int) ), ext, TQT_SLOT( setChanged() ) ); /* Removed because of startup combo failure */
connect( this, TQT_SIGNAL( activated(int) ), ext, TQT_SLOT( setChanged() ) );
connect( this, TQT_SIGNAL( textChanged ( const TQString & ) ), ext, TQT_SLOT( setChanged() ) );
// connect( this, TQ_SIGNAL( highlighted(int) ), ext, TQ_SLOT( setChanged() ) ); /* Removed because of startup combo failure */
connect( this, TQ_SIGNAL( activated(int) ), ext, TQ_SLOT( setChanged() ) );
connect( this, TQ_SIGNAL( textChanged ( const TQString & ) ), ext, TQ_SLOT( setChanged() ) );
setEditable( editable );
loadInitialValue();
@ -531,9 +531,9 @@ KonfiguratorColorChooser::KonfiguratorColorChooser( TQString cls, TQString name,
{
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
addColor( i18n("Custom color" ), TQColor( 255, 255, 255 ) );
addColor( i18n("Default" ), defaultValue );
@ -562,7 +562,7 @@ KonfiguratorColorChooser::KonfiguratorColorChooser( TQString cls, TQString name,
addColor( i18n("Dark Gray" ), TQt::darkGray );
addColor( i18n("Black" ), TQt::black );
connect( this, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( slotCurrentChanged( int ) ) );
connect( this, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( slotCurrentChanged( int ) ) );
loadInitialValue();
}
@ -743,9 +743,9 @@ KonfiguratorListBox::KonfiguratorListBox( TQString cls, TQString name, TQStringL
defaultValue( dflt )
{
ext = new KonfiguratorExtension( this, cls, name, rst, pg );
connect( ext, TQT_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQT_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQT_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQT_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQT_SIGNAL( setInitialValue(TQObject *) ), this, TQT_SLOT( loadInitialValue() ) );
connect( ext, TQ_SIGNAL( applyAuto(TQObject *,TQString, TQString) ), this, TQ_SLOT( slotApply(TQObject *,TQString, TQString) ) );
connect( ext, TQ_SIGNAL( setDefaultsAuto(TQObject *) ), this, TQ_SLOT( slotSetDefaults(TQObject *) ) );
connect( ext, TQ_SIGNAL( setInitialValue(TQObject *) ), this, TQ_SLOT( loadInitialValue() ) );
loadInitialValue();
}

2
krusader/Konfigurator/konfiguratorpage.cpp
Unescape View File

@ -303,7 +303,7 @@ void KonfiguratorPage::registerObject( KonfiguratorExtension *item )
KonfiguratorExtension *currentItem = itemList.current();
itemList.append( item );
connect( item, TQT_SIGNAL( sigChanged( bool ) ), this, TQT_SIGNAL ( sigChanged( ) ) );
connect( item, TQ_SIGNAL( sigChanged( bool ) ), this, TQ_SIGNAL ( sigChanged( ) ) );
itemList.find( currentItem );
}

8
krusader/Konfigurator/krresulttable.cpp
Unescape View File

@ -183,8 +183,8 @@ bool KrArchiverResultTable::addRow(SearchObject* search, TQGridLayout* grid)
_label->setMargin(5);
_label->setAlignment(TQt::AlignTop);
grid->addWidget(_label, _numRows, 0);
connect(_label, TQT_SIGNAL(leftClickedURL(const TQString&)),
TQT_SLOT(website(const TQString&)));
connect(_label, TQ_SIGNAL(leftClickedURL(const TQString&)),
TQ_SLOT(website(const TQString&)));
// Found column
_label = new TQLabel( arch->getPath(), this );
@ -336,8 +336,8 @@ bool KrToolResultTable::addRow(SearchObject* search, TQGridLayout* grid)
KURLLabel* l = new KURLLabel( (*it)->getWebsite(), (*it)->getAppName(), toolBox);
l->setAlignment(TQt::AlignLeft | TQt::AlignTop);
l->setMargin(5);
connect(l, TQT_SIGNAL(leftClickedURL(const TQString&)),
TQT_SLOT(website(const TQString&)));
connect(l, TQ_SIGNAL(leftClickedURL(const TQString&)),
TQ_SLOT(website(const TQString&)));
}
grid->addWidget(toolBox, _numRows, 1);

24
krusader/Locate/locate.cpp
Unescape View File

@ -152,12 +152,12 @@ LocateDlg::LocateDlg() : KDialogBase(0,0,false,"Locate", KDialogBase::User1 | KD
resultList->addColumn( i18n("Results"), TQFontMetrics(resultList->font()).width("W") * 60 );
resultList->setColumnWidthMode(0,TQListView::Maximum);
connect( resultList,TQT_SIGNAL(rightButtonPressed(TQListViewItem *, const TQPoint &, int)),
this, TQT_SLOT(slotRightClick(TQListViewItem *)));
connect( resultList,TQT_SIGNAL(doubleClicked(TQListViewItem *)),
this, TQT_SLOT(slotDoubleClick(TQListViewItem *)));
connect( resultList,TQT_SIGNAL(returnPressed(TQListViewItem *)),
this, TQT_SLOT(slotDoubleClick(TQListViewItem *)));
connect( resultList,TQ_SIGNAL(rightButtonPressed(TQListViewItem *, const TQPoint &, int)),
this, TQ_SLOT(slotRightClick(TQListViewItem *)));
connect( resultList,TQ_SIGNAL(doubleClicked(TQListViewItem *)),
this, TQ_SLOT(slotDoubleClick(TQListViewItem *)));
connect( resultList,TQ_SIGNAL(returnPressed(TQListViewItem *)),
this, TQ_SLOT(slotDoubleClick(TQListViewItem *)));
grid->addWidget( resultList, 3, 0 );
@ -171,7 +171,7 @@ LocateDlg::LocateDlg() : KDialogBase(0,0,false,"Locate", KDialogBase::User1 | KD
{
if( updateProcess->isRunning() )
{
connect( updateProcess, TQT_SIGNAL(processExited(TDEProcess *)), this, TQT_SLOT(updateFinished()));
connect( updateProcess, TQ_SIGNAL(processExited(TDEProcess *)), this, TQ_SLOT(updateFinished()));
enableButton( KDialogBase::User2, false );
}
else
@ -202,7 +202,7 @@ void LocateDlg::slotUser2() /* The Update DB button */
*updateProcess << KrServices::fullPathName( "updatedb" );
*updateProcess << KrServices::separateArgs( krConfig->readEntry( "UpdateDB Arguments", "" ) );
connect( updateProcess, TQT_SIGNAL(processExited(TDEProcess *)), this, TQT_SLOT(updateFinished()));
connect( updateProcess, TQ_SIGNAL(processExited(TDEProcess *)), this, TQ_SLOT(updateFinished()));
updateProcess->start(TDEProcess::NotifyOnExit);
enableButton( KDialogBase::User2, false );
}
@ -247,10 +247,10 @@ void LocateDlg::slotUser3() /* The locate button */
stopping = false;
TDEProcess locateProc;
connect( &locateProc, TQT_SIGNAL( receivedStdout(TDEProcess *, char *, int) ),
this, TQT_SLOT( processStdout(TDEProcess *, char *, int) ) );
connect( &locateProc, TQT_SIGNAL( receivedStderr(TDEProcess *, char *, int) ),
this, TQT_SLOT( processStderr(TDEProcess *, char *, int) ) );
connect( &locateProc, TQ_SIGNAL( receivedStdout(TDEProcess *, char *, int) ),
this, TQ_SLOT( processStdout(TDEProcess *, char *, int) ) );
connect( &locateProc, TQ_SIGNAL( receivedStderr(TDEProcess *, char *, int) ),
this, TQ_SLOT( processStderr(TDEProcess *, char *, int) ) );
locateProc << KrServices::fullPathName( "locate" );
if( !isCs )

8
krusader/MountMan/kdiskfreesp.cpp
Unescape View File

@ -47,10 +47,10 @@ KDiskFreeSp::KDiskFreeSp(TQObject *parent, const char *name)
{
dfProc = new TDEProcess(); TQ_CHECK_PTR(dfProc);
dfProc->setEnvironment("LANGUAGE", "C");
connect( dfProc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int) ),
this, TQT_SLOT (receivedDFStdErrOut(TDEProcess *, char *, int)) );
connect(dfProc,TQT_SIGNAL(processExited(TDEProcess *) ),
this, TQT_SLOT(dfDone() ) );
connect( dfProc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int) ),
this, TQ_SLOT (receivedDFStdErrOut(TDEProcess *, char *, int)) );
connect(dfProc,TQ_SIGNAL(processExited(TDEProcess *) ),
this, TQ_SLOT(dfDone() ) );
readingDFStdErrOut=false;
}

12
krusader/MountMan/kmountman.cpp
Unescape View File

@ -129,7 +129,7 @@ void KMountMan::mount( TQString mntPoint, bool blocking ) {
waiting = true; // prepare to block
TDEIO::SimpleJob *job = TDEIO::mount(false, m->mountType().local8Bit(), m->mountedFrom(), m->mountPoint(), false);
new KrProgress(job);
connect(job, TQT_SIGNAL(result(TDEIO::Job* )), this, TQT_SLOT(jobResult(TDEIO::Job* )));
connect(job, TQ_SIGNAL(result(TDEIO::Job* )), this, TQ_SLOT(jobResult(TDEIO::Job* )));
while (blocking && waiting) {
tqApp->processEvents();
usleep( 1000 );
@ -141,7 +141,7 @@ void KMountMan::unmount( TQString mntPoint, bool blocking ) {
waiting = true; // prepare to block
TDEIO::SimpleJob *job = TDEIO::unmount(mntPoint, false);
new KrProgress(job);
connect(job, TQT_SIGNAL(result(TDEIO::Job* )), this, TQT_SLOT(jobResult(TDEIO::Job* )));
connect(job, TQ_SIGNAL(result(TDEIO::Job* )), this, TQ_SLOT(jobResult(TDEIO::Job* )));
while (blocking && waiting) {
tqApp->processEvents();
usleep( 1000 );
@ -290,14 +290,14 @@ void KMountMan::quickList() {
( ( TDEToolBarPopupAction* ) krMountMan ) ->popupMenu() ->insertItem( text, idx );
}
connect( ( ( TDEToolBarPopupAction* ) krMountMan ) ->popupMenu(), TQT_SIGNAL( activated( int ) ),
this, TQT_SLOT( delayedPerformAction( int ) ) );
connect( ( ( TDEToolBarPopupAction* ) krMountMan ) ->popupMenu(), TQ_SIGNAL( activated( int ) ),
this, TQ_SLOT( delayedPerformAction( int ) ) );
}
void KMountMan::delayedPerformAction( int idx ) {
__delayedIdx = idx;
TQTimer::singleShot(0, this, TQT_SLOT(performAction(int)));
TQTimer::singleShot(0, this, TQ_SLOT(performAction(int)));
}
void KMountMan::performAction( int idx ) {
@ -321,7 +321,7 @@ void KMountMan::performAction( int idx ) {
// free memory
delete[] _actions;
_actions = 0L;
disconnect( ( ( TDEToolBarPopupAction* ) krMountMan ) ->popupMenu(), TQT_SIGNAL( activated( int ) ), 0, 0 );
disconnect( ( ( TDEToolBarPopupAction* ) krMountMan ) ->popupMenu(), TQ_SIGNAL( activated( int ) ), 0, 0 );
}
#include "kmountman.moc"

32
krusader/MountMan/kmountmangui.cpp
Unescape View File

@ -64,9 +64,9 @@ A
KMountManGUI::KMountManGUI() : KDialogBase( krApp, 0, true, "Mount.Man" ),
info( 0 ), mountList( 0 ) {
watcher = new TQTimer( this );
connect( watcher, TQT_SIGNAL( timeout() ), this, TQT_SLOT( checkMountChange() ) );
connect( watcher, TQ_SIGNAL( timeout() ), this, TQ_SLOT( checkMountChange() ) );
connect( this, TQT_SIGNAL( finishedGettingSpaceData() ), this, TQT_SLOT( updateList() ) );
connect( this, TQ_SIGNAL( finishedGettingSpaceData() ), this, TQ_SLOT( updateList() ) );
setButtonOK( i18n( "&Close" ) );
showButtonApply( false ); showButtonCancel( false );
setPlainCaption( i18n( "MountMan - Your Mount-Manager" ) );
@ -79,14 +79,14 @@ info( 0 ), mountList( 0 ) {
resize( minimumSize() );
// connections
connect( mountList, TQT_SIGNAL( doubleClicked( TQListViewItem * ) ), this,
TQT_SLOT( doubleClicked( TQListViewItem* ) ) );
connect( mountList, TQT_SIGNAL( contextMenuRequested( TQListViewItem *, const TQPoint &, int ) ),
this, TQT_SLOT( clicked( TQListViewItem*, const TQPoint&, int ) ) );
connect( mountList, TQT_SIGNAL( clicked( TQListViewItem * ) ), this,
TQT_SLOT( changeActive( TQListViewItem * ) ) );
connect( mountList, TQT_SIGNAL( selectionChanged( TQListViewItem * ) ), this,
TQT_SLOT( changeActive( TQListViewItem * ) ) );
connect( mountList, TQ_SIGNAL( doubleClicked( TQListViewItem * ) ), this,
TQ_SLOT( doubleClicked( TQListViewItem* ) ) );
connect( mountList, TQ_SIGNAL( contextMenuRequested( TQListViewItem *, const TQPoint &, int ) ),
this, TQ_SLOT( clicked( TQListViewItem*, const TQPoint&, int ) ) );
connect( mountList, TQ_SIGNAL( clicked( TQListViewItem * ) ), this,
TQ_SLOT( changeActive( TQListViewItem * ) ) );
connect( mountList, TQ_SIGNAL( selectionChanged( TQListViewItem * ) ), this,
TQ_SLOT( changeActive( TQListViewItem * ) ) );
getSpaceData();
exec();
@ -165,9 +165,9 @@ void KMountManGUI::getSpaceData() {
continue;
}
KDiskFreeSp *sp = KDiskFreeSp::findUsageInfo( ( *it ) ->mountPoint() );
connect( sp, TQT_SIGNAL( foundMountPoint( const TQString &, unsigned long, unsigned long, unsigned long ) ),
this, TQT_SLOT( gettingSpaceData( const TQString&, unsigned long, unsigned long, unsigned long ) ) );
connect( sp, TQT_SIGNAL( done() ), this, TQT_SLOT( gettingSpaceData() ) );
connect( sp, TQ_SIGNAL( foundMountPoint( const TQString &, unsigned long, unsigned long, unsigned long ) ),
this, TQ_SLOT( gettingSpaceData( const TQString&, unsigned long, unsigned long, unsigned long ) ) );
connect( sp, TQ_SIGNAL( done() ), this, TQ_SLOT( gettingSpaceData() ) );
}
}
@ -270,10 +270,10 @@ void KMountManGUI::doubleClicked( TQListViewItem *i ) {
return; // we don't want to refresh to swap, do we ?
// change the active panel to this mountpoint
connect( ( TQObject* ) this, TQT_SIGNAL( refreshPanel( const KURL & ) ), ( TQObject* ) SLOTS,
TQT_SLOT( refresh( const KURL & ) ) );
connect( ( TQObject* ) this, TQ_SIGNAL( refreshPanel( const KURL & ) ), ( TQObject* ) SLOTS,
TQ_SLOT( refresh( const KURL & ) ) );
emit refreshPanel( vfs::fromPathOrURL( i->text(2) ) ); // text(2) ? so ugly ...
disconnect( this, TQT_SIGNAL( refreshPanel( const KURL & ) ), 0, 0 );
disconnect( this, TQ_SIGNAL( refreshPanel( const KURL & ) ), 0, 0 );
slotClose();
}

38
krusader/Panel/krbriefview.cpp
Unescape View File

@ -99,23 +99,23 @@ void KrBriefView::setup() {
// decide on single click/double click selection
if ( _config->readBoolEntry( "Single Click Selects", _SingleClickSelects ) &&
TDEGlobalSettings::singleClick() ) {
connect( this, TQT_SIGNAL( executed( TQIconViewItem* ) ), this, TQT_SLOT( slotExecuted( TQIconViewItem* ) ) );
connect( this, TQ_SIGNAL( executed( TQIconViewItem* ) ), this, TQ_SLOT( slotExecuted( TQIconViewItem* ) ) );
} else {
connect( this, TQT_SIGNAL( clicked( TQIconViewItem* ) ), this, TQT_SLOT( slotClicked( TQIconViewItem* ) ) );
connect( this, TQT_SIGNAL( doubleClicked( TQIconViewItem* ) ), this, TQT_SLOT( slotDoubleClicked( TQIconViewItem* ) ) );
connect( this, TQ_SIGNAL( clicked( TQIconViewItem* ) ), this, TQ_SLOT( slotClicked( TQIconViewItem* ) ) );
connect( this, TQ_SIGNAL( doubleClicked( TQIconViewItem* ) ), this, TQ_SLOT( slotDoubleClicked( TQIconViewItem* ) ) );
}
// a change in the selection needs to update totals
connect( this, TQT_SIGNAL( onItem( TQIconViewItem* ) ), this, TQT_SLOT( slotItemDescription( TQIconViewItem* ) ) );
connect( this, TQT_SIGNAL( contextMenuRequested( TQIconViewItem*, const TQPoint& ) ),
this, TQT_SLOT( handleContextMenu( TQIconViewItem*, const TQPoint& ) ) );
connect( this, TQT_SIGNAL( rightButtonPressed(TQIconViewItem*, const TQPoint&)),
this, TQT_SLOT(slotRightButtonPressed(TQIconViewItem*, const TQPoint&)));
connect( this, TQT_SIGNAL( currentChanged( TQIconViewItem* ) ), this, TQT_SLOT( setNameToMakeCurrent( TQIconViewItem* ) ) );
connect( this, TQT_SIGNAL( currentChanged( TQIconViewItem* ) ), this, TQT_SLOT( transformCurrentChanged( TQIconViewItem* ) ) );
connect( this, TQT_SIGNAL( mouseButtonClicked ( int, TQIconViewItem *, const TQPoint & ) ),
this, TQT_SLOT( slotMouseClicked ( int, TQIconViewItem *, const TQPoint & ) ) );
connect( &KrColorCache::getColorCache(), TQT_SIGNAL( colorsRefreshed() ), this, TQT_SLOT( refreshColors() ) );
connect( this, TQ_SIGNAL( onItem( TQIconViewItem* ) ), this, TQ_SLOT( slotItemDescription( TQIconViewItem* ) ) );
connect( this, TQ_SIGNAL( contextMenuRequested( TQIconViewItem*, const TQPoint& ) ),
this, TQ_SLOT( handleContextMenu( TQIconViewItem*, const TQPoint& ) ) );
connect( this, TQ_SIGNAL( rightButtonPressed(TQIconViewItem*, const TQPoint&)),
this, TQ_SLOT(slotRightButtonPressed(TQIconViewItem*, const TQPoint&)));
connect( this, TQ_SIGNAL( currentChanged( TQIconViewItem* ) ), this, TQ_SLOT( setNameToMakeCurrent( TQIconViewItem* ) ) );
connect( this, TQ_SIGNAL( currentChanged( TQIconViewItem* ) ), this, TQ_SLOT( transformCurrentChanged( TQIconViewItem* ) ) );
connect( this, TQ_SIGNAL( mouseButtonClicked ( int, TQIconViewItem *, const TQPoint & ) ),
this, TQ_SLOT( slotMouseClicked ( int, TQIconViewItem *, const TQPoint & ) ) );
connect( &KrColorCache::getColorCache(), TQ_SIGNAL( colorsRefreshed() ), this, TQ_SLOT( refreshColors() ) );
// add whatever columns are needed to the listview
krConfig->setGroup( nameInTDEConfig() );
@ -131,10 +131,10 @@ void KrBriefView::setup() {
// allow in-place renaming
connect( this, TQT_SIGNAL( itemRenamed ( TQIconViewItem * ) ),
this, TQT_SLOT( inplaceRenameFinished( TQIconViewItem * ) ) );
connect( &renameTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( renameCurrentItem() ) );
connect( &contextMenuTimer, TQT_SIGNAL (timeout()), this, TQT_SLOT (showContextMenu()));
connect( this, TQ_SIGNAL( itemRenamed ( TQIconViewItem * ) ),
this, TQ_SLOT( inplaceRenameFinished( TQIconViewItem * ) ) );
connect( &renameTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( renameCurrentItem() ) );
connect( &contextMenuTimer, TQ_SIGNAL (timeout()), this, TQ_SLOT (showContextMenu()));
setSelectionMode( TQIconView::Extended );
@ -152,7 +152,7 @@ void KrBriefView::setup() {
header->setStretchEnabled( true );
header->setSortIndicator( 0, sortDirection() ? TQt::Ascending : TQt::Descending );
connect( header, TQT_SIGNAL(clicked( int )), this, TQT_SLOT( changeSortOrder()));
connect( header, TQ_SIGNAL(clicked( int )), this, TQ_SLOT( changeSortOrder()));
header->installEventFilter( this );
header->show();
@ -1295,7 +1295,7 @@ void KrBriefView::makeItemVisible( const KrViewItem *item ) {
void KrBriefView::initOperator() {
_operator = new KrViewOperator(this, this);
// TQIconView emits selection changed, so chain them to operator
connect(this, TQT_SIGNAL(selectionChanged()), _operator, TQT_SIGNAL(selectionChanged()));
connect(this, TQ_SIGNAL(selectionChanged()), _operator, TQ_SIGNAL(selectionChanged()));
}
void KrBriefView::initProperties() {

2
krusader/Panel/krcalcspacedialog.cpp
Unescape View File

@ -177,7 +177,7 @@ void KrCalcSpaceDialog::exec(){
showResult(); // fill the invisible dialog with usefull data
}
// prepare and start the poll timer
connect(m_pollTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timer()));
connect(m_pollTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(timer()));
m_pollTimer->start(100);
KDialogBase::exec(); // show the dialog
}

42
krusader/Panel/krdetailedview.cpp
Unescape View File

@ -118,24 +118,24 @@ void KrDetailedView::setup() {
// decide on single click/double click selection
if ( _config->readBoolEntry( "Single Click Selects", _SingleClickSelects ) &&
TDEGlobalSettings::singleClick() ) {
connect( this, TQT_SIGNAL( executed( TQListViewItem* ) ), this, TQT_SLOT( slotExecuted( TQListViewItem* ) ) );
connect( this, TQ_SIGNAL( executed( TQListViewItem* ) ), this, TQ_SLOT( slotExecuted( TQListViewItem* ) ) );
} else {
connect( this, TQT_SIGNAL( clicked( TQListViewItem* ) ), this, TQT_SLOT( slotClicked( TQListViewItem* ) ) );
connect( this, TQT_SIGNAL( doubleClicked( TQListViewItem* ) ), this, TQT_SLOT( slotDoubleClicked( TQListViewItem* ) ) );
connect( this, TQ_SIGNAL( clicked( TQListViewItem* ) ), this, TQ_SLOT( slotClicked( TQListViewItem* ) ) );
connect( this, TQ_SIGNAL( doubleClicked( TQListViewItem* ) ), this, TQ_SLOT( slotDoubleClicked( TQListViewItem* ) ) );
}
// a change in the selection needs to update totals
connect( this, TQT_SIGNAL( onItem( TQListViewItem* ) ), this, TQT_SLOT( slotItemDescription( TQListViewItem* ) ) );
connect( this, TQT_SIGNAL( contextMenuRequested( TQListViewItem*, const TQPoint&, int ) ),
this, TQT_SLOT( handleContextMenu( TQListViewItem*, const TQPoint&, int ) ) );
connect( this, TQT_SIGNAL( rightButtonPressed(TQListViewItem*, const TQPoint&, int)),
this, TQT_SLOT(slotRightButtonPressed(TQListViewItem*, const TQPoint&, int)));
connect( this, TQT_SIGNAL( currentChanged( TQListViewItem* ) ), this, TQT_SLOT( setNameToMakeCurrent( TQListViewItem* ) ) );
connect( this, TQT_SIGNAL( currentChanged( TQListViewItem* ) ), this, TQT_SLOT( transformCurrentChanged( TQListViewItem* ) ) );
connect( this, TQT_SIGNAL( mouseButtonClicked ( int, TQListViewItem *, const TQPoint &, int ) ),
this, TQT_SLOT( slotMouseClicked ( int, TQListViewItem *, const TQPoint &, int ) ) );
connect( &KrColorCache::getColorCache(), TQT_SIGNAL( colorsRefreshed() ), this, TQT_SLOT( refreshColors() ) );
connect( header(), TQT_SIGNAL(clicked(int)), this, TQT_SLOT(sortOrderChanged(int )));
connect( this, TQ_SIGNAL( onItem( TQListViewItem* ) ), this, TQ_SLOT( slotItemDescription( TQListViewItem* ) ) );
connect( this, TQ_SIGNAL( contextMenuRequested( TQListViewItem*, const TQPoint&, int ) ),
this, TQ_SLOT( handleContextMenu( TQListViewItem*, const TQPoint&, int ) ) );
connect( this, TQ_SIGNAL( rightButtonPressed(TQListViewItem*, const TQPoint&, int)),
this, TQ_SLOT(slotRightButtonPressed(TQListViewItem*, const TQPoint&, int)));
connect( this, TQ_SIGNAL( currentChanged( TQListViewItem* ) ), this, TQ_SLOT( setNameToMakeCurrent( TQListViewItem* ) ) );
connect( this, TQ_SIGNAL( currentChanged( TQListViewItem* ) ), this, TQ_SLOT( transformCurrentChanged( TQListViewItem* ) ) );
connect( this, TQ_SIGNAL( mouseButtonClicked ( int, TQListViewItem *, const TQPoint &, int ) ),
this, TQ_SLOT( slotMouseClicked ( int, TQListViewItem *, const TQPoint &, int ) ) );
connect( &KrColorCache::getColorCache(), TQ_SIGNAL( colorsRefreshed() ), this, TQ_SLOT( refreshColors() ) );
connect( header(), TQ_SIGNAL(clicked(int)), this, TQ_SLOT(sortOrderChanged(int )));
}
// add whatever columns are needed to the listview
@ -207,12 +207,12 @@ void KrDetailedView::setup() {
renameLineEdit()->installEventFilter( this );
// allow in-place renaming
connect( renameLineEdit(), TQT_SIGNAL( done( TQListViewItem *, int ) ),
this, TQT_SLOT( inplaceRenameFinished( TQListViewItem*, int ) ) );
connect( &renameTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( renameCurrentItem() ) );
connect( &contextMenuTimer, TQT_SIGNAL (timeout()), this, TQT_SLOT (showContextMenu()));
connect( renameLineEdit(), TQ_SIGNAL( done( TQListViewItem *, int ) ),
this, TQ_SLOT( inplaceRenameFinished( TQListViewItem*, int ) ) );
connect( &renameTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( renameCurrentItem() ) );
connect( &contextMenuTimer, TQ_SIGNAL (timeout()), this, TQ_SLOT (showContextMenu()));
connect( header(), TQT_SIGNAL(clicked(int)), this, TQT_SLOT(slotSortOrderChanged(int )));
connect( header(), TQ_SIGNAL(clicked(int)), this, TQ_SLOT(slotSortOrderChanged(int )));
setFocusPolicy( TQWidget::StrongFocus );
restoreSettings();
@ -1391,7 +1391,7 @@ void KrDetailedView::makeItemVisible( const KrViewItem *item ) {
void KrDetailedView::initOperator() {
_operator = new KrViewOperator(this, this);
// tdelistview emits selection changed, so chain them to operator
connect(this, TQT_SIGNAL(selectionChanged()), _operator, TQT_SIGNAL(selectionChanged()));
connect(this, TQ_SIGNAL(selectionChanged()), _operator, TQ_SIGNAL(selectionChanged()));
}
void KrDetailedView::initProperties() {
@ -1515,7 +1515,7 @@ void KrDetailedView::selectColumns()
if( refresh )
{
PanelManager *p = ACTIVE_PANEL->view == this ? ACTIVE_MNG : OTHER_MNG;
TQTimer::singleShot( 0, p, TQT_SLOT( slotRecreatePanels() ) );
TQTimer::singleShot( 0, p, TQ_SLOT( slotRecreatePanels() ) );
}
}

6
krusader/Panel/krpreviewpopup.cpp
Unescape View File

@ -24,7 +24,7 @@
#include "../krusader.h"
KrPreviewPopup::KrPreviewPopup(): id(1),noPreview(true){
connect(this,TQT_SIGNAL(activated(int)),this,TQT_SLOT(view(int)));
connect(this,TQ_SIGNAL(activated(int)),this,TQ_SLOT(view(int)));
}
void KrPreviewPopup::setUrls(const KURL::List* urls){
@ -40,8 +40,8 @@ void KrPreviewPopup::setUrls(const KURL::List* urls){
}
pjob = new TDEIO::PreviewJob(files,200,200,200,1,true,true,0);
connect(pjob,TQT_SIGNAL(gotPreview(const KFileItem*,const TQPixmap&)),
this,TQT_SLOT(addPreview(const KFileItem*,const TQPixmap&)));
connect(pjob,TQ_SIGNAL(gotPreview(const KFileItem*,const TQPixmap&)),
this,TQ_SLOT(addPreview(const KFileItem*,const TQPixmap&)));
}
KrPreviewPopup::~KrPreviewPopup(){}

138
krusader/Panel/listpanel.cpp
Unescape View File

@ -116,8 +116,8 @@ ListPanel::ListPanel( TQString typeIn, TQWidget *parent, bool &left, const char
layout = new TQGridLayout( this, 3, 3 );
mediaButton = new MediaButton( this, "mediaButton" );
connect( mediaButton, TQT_SIGNAL( pressed() ), this, TQT_SLOT( slotFocusOnMe() ) );
connect( mediaButton, TQT_SIGNAL( openUrl( const KURL& ) ), func, TQT_SLOT( openUrl( const KURL& ) ) );
connect( mediaButton, TQ_SIGNAL( pressed() ), this, TQ_SLOT( slotFocusOnMe() ) );
connect( mediaButton, TQ_SIGNAL( openUrl( const KURL& ) ), func, TQ_SLOT( openUrl( const KURL& ) ) );
status = new KrSqueezedTextLabel( this );
krConfig->setGroup( "Look&Feel" );
@ -133,18 +133,18 @@ ListPanel::ListPanel( TQString typeIn, TQWidget *parent, bool &left, const char
( status, i18n( "The statusbar displays information about the FILESYSTEM "
"which holds your current directory: Total size, free space, "
"type of filesystem, etc." ) );
connect( status, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotFocusOnMe() ) );
connect( status, TQT_SIGNAL( dropped( TQDropEvent *) ), this, TQT_SLOT( handleDropOnStatus(TQDropEvent *) ) );
connect( status, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotFocusOnMe() ) );
connect( status, TQ_SIGNAL( dropped( TQDropEvent *) ), this, TQ_SLOT( handleDropOnStatus(TQDropEvent *) ) );
// ... create the history button
dirHistoryQueue = new DirHistoryQueue( this );
historyButton = new DirHistoryButton( dirHistoryQueue, this, "historyButton" );
connect( historyButton, TQT_SIGNAL( pressed() ), this, TQT_SLOT( slotFocusOnMe() ) );
connect( historyButton, TQT_SIGNAL( openUrl( const KURL& ) ), func, TQT_SLOT( openUrl( const KURL& ) ) );
connect( historyButton, TQ_SIGNAL( pressed() ), this, TQ_SLOT( slotFocusOnMe() ) );
connect( historyButton, TQ_SIGNAL( openUrl( const KURL& ) ), func, TQ_SLOT( openUrl( const KURL& ) ) );
bookmarksButton = new KrBookmarkButton(this);
connect( bookmarksButton, TQT_SIGNAL( pressed() ), this, TQT_SLOT( slotFocusOnMe() ) );
connect( bookmarksButton, TQT_SIGNAL( openUrl( const KURL& ) ), func, TQT_SLOT( openUrl( const KURL& ) ) );
connect( bookmarksButton, TQ_SIGNAL( pressed() ), this, TQ_SLOT( slotFocusOnMe() ) );
connect( bookmarksButton, TQ_SIGNAL( openUrl( const KURL& ) ), func, TQ_SLOT( openUrl( const KURL& ) ) );
TQWhatsThis::add
( bookmarksButton, i18n( "Open menu with bookmarks. You can also add "
"current location to the list, edit bookmarks "
@ -162,20 +162,20 @@ ListPanel::ListPanel( TQString typeIn, TQWidget *parent, bool &left, const char
TQWhatsThis::add
( totals, i18n( "The totals bar shows how many files exist, "
"how many selected and the bytes math" ) );
connect( totals, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotFocusOnMe() ) );
connect( totals, TQT_SIGNAL( dropped( TQDropEvent *) ), this, TQT_SLOT( handleDropOnTotals(TQDropEvent *) ) );
connect( totals, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotFocusOnMe() ) );
connect( totals, TQ_SIGNAL( dropped( TQDropEvent *) ), this, TQ_SLOT( handleDropOnTotals(TQDropEvent *) ) );
// a cancel button for the inplace refresh mechanism
inlineRefreshCancelButton = new KPushButton(this);
inlineRefreshCancelButton->setFixedSize( 22, 20 );
inlineRefreshCancelButton->setPixmap(krLoader->loadIcon("cancel", TDEIcon::Toolbar, 16));
connect(inlineRefreshCancelButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(inlineRefreshCancel()));
connect(inlineRefreshCancelButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(inlineRefreshCancel()));
// a quick button to open the popup panel
popupBtn = new TQToolButton( this, "popupbtn" );
popupBtn->setFixedSize( 22, 20 );
popupBtn->setPixmap(krLoader->loadIcon("1uparrow", TDEIcon::Toolbar, 16));
connect(popupBtn, TQT_SIGNAL(clicked()), this, TQT_SLOT(togglePanelPopup()));
connect(popupBtn, TQ_SIGNAL(clicked()), this, TQ_SLOT(togglePanelPopup()));
TQToolTip::add( popupBtn, i18n( "Open the popup panel" ) );
totalsLayout->addWidget(totals);
totalsLayout->addWidget(inlineRefreshCancelButton); inlineRefreshCancelButton->hide();
@ -212,16 +212,16 @@ ListPanel::ListPanel( TQString typeIn, TQWidget *parent, bool &left, const char
"enter name of desired location to move there. "
"Use of Net protocols like ftp or fish is possible." ) );
origin->setMode( KFile::Directory | KFile::ExistingOnly );
connect( origin, TQT_SIGNAL( returnPressed( const TQString& ) ), func, TQT_SLOT( openUrl( const TQString& ) ) );
connect( origin, TQT_SIGNAL( returnPressed( const TQString& ) ), this, TQT_SLOT( slotFocusOnMe() ) );
connect( origin, TQT_SIGNAL( urlSelected( const TQString& ) ), func, TQT_SLOT( openUrl( const TQString& ) ) );
connect( origin, TQT_SIGNAL( urlSelected( const TQString& ) ), this, TQT_SLOT( slotFocusOnMe() ) );
connect( origin, TQ_SIGNAL( returnPressed( const TQString& ) ), func, TQ_SLOT( openUrl( const TQString& ) ) );
connect( origin, TQ_SIGNAL( returnPressed( const TQString& ) ), this, TQ_SLOT( slotFocusOnMe() ) );
connect( origin, TQ_SIGNAL( urlSelected( const TQString& ) ), func, TQ_SLOT( openUrl( const TQString& ) ) );
connect( origin, TQ_SIGNAL( urlSelected( const TQString& ) ), this, TQ_SLOT( slotFocusOnMe() ) );
// this is here on purpose, do not move up!
if (clearButton) {
clearOrigin->setFixedSize( 20, origin->button() ->height() );
connect(clearOrigin, TQT_SIGNAL(clicked()), origin->lineEdit(), TQT_SLOT(clear()));
connect(clearOrigin, TQT_SIGNAL(clicked()), origin->lineEdit(), TQT_SLOT(setFocus()));
connect(clearOrigin, TQ_SIGNAL(clicked()), origin->lineEdit(), TQ_SLOT(clear()));
connect(clearOrigin, TQ_SIGNAL(clicked()), origin->lineEdit(), TQ_SLOT(setFocus()));
}
//
@ -229,25 +229,25 @@ ListPanel::ListPanel( TQString typeIn, TQWidget *parent, bool &left, const char
cdOtherButton->setFixedSize( 20, origin->button() ->height() );
cdOtherButton->setText( i18n( "=" ) );
TQToolTip::add( cdOtherButton, i18n( "Equal" ) );
connect( cdOtherButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotFocusAndCDOther() ) );
connect( cdOtherButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotFocusAndCDOther() ) );
cdUpButton = new TQToolButton( hbox, "cdUpButton" );
cdUpButton->setFixedSize( 20, origin->button() ->height() );
cdUpButton->setText( i18n( ".." ) );
TQToolTip::add( cdUpButton, i18n( "Up" ) );
connect( cdUpButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotFocusAndCDup() ) );
connect( cdUpButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotFocusAndCDup() ) );
cdHomeButton = new TQToolButton( hbox, "cdHomeButton" );
cdHomeButton->setFixedSize( 20, origin->button() ->height() );
cdHomeButton->setText( i18n( "~" ) );
TQToolTip::add( cdHomeButton, i18n( "Home" ) );
connect( cdHomeButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotFocusAndCDHome() ) );
connect( cdHomeButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotFocusAndCDHome() ) );
cdRootButton = new TQToolButton( hbox, "cdRootButton" );
cdRootButton->setFixedSize( 20, origin->button() ->height() );
cdRootButton->setText( i18n( "/" ) );
TQToolTip::add( cdRootButton, i18n( "Root" ) );
connect( cdRootButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotFocusAndCDRoot() ) );
connect( cdRootButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotFocusAndCDRoot() ) );
// ... creates the button for sync-browsing
syncBrowseButton = new SyncBrowseButton( hbox );
@ -265,13 +265,13 @@ ListPanel::ListPanel( TQString typeIn, TQWidget *parent, bool &left, const char
createView();
// make sure that a focus/path change reflects in the command line and activePanel
connect( this, TQT_SIGNAL( cmdLineUpdate( TQString ) ), SLOTS, TQT_SLOT( slotCurrentChanged( TQString ) ) );
connect( this, TQT_SIGNAL( activePanelChanged( ListPanel * ) ), SLOTS, TQT_SLOT( slotSetActivePanel( ListPanel * ) ) );
connect( this, TQ_SIGNAL( cmdLineUpdate( TQString ) ), SLOTS, TQ_SLOT( slotCurrentChanged( TQString ) ) );
connect( this, TQ_SIGNAL( activePanelChanged( ListPanel * ) ), SLOTS, TQ_SLOT( slotSetActivePanel( ListPanel * ) ) );
// add a popup
popup = new PanelPopup(splt, left);
connect(popup, TQT_SIGNAL(selection(const KURL&)), SLOTS, TQT_SLOT(refresh(const KURL&)));
connect(popup, TQT_SIGNAL(hideMe()), this, TQT_SLOT(togglePanelPopup()));
connect(popup, TQ_SIGNAL(selection(const KURL&)), SLOTS, TQ_SLOT(refresh(const KURL&)));
connect(popup, TQ_SIGNAL(hideMe()), this, TQ_SLOT(togglePanelPopup()));
popup->hide();
// finish the layout
@ -296,48 +296,48 @@ void ListPanel::createView()
view = new KrBriefView( header, splt, _left, krConfig );
view->init();
connect( dynamic_cast<KrBriefView*>( view ), TQT_SIGNAL( middleButtonClicked( KrViewItem * ) ), SLOTS, TQT_SLOT( newTab( KrViewItem * ) ) );
connect( dynamic_cast<KrBriefView*>( view ), TQT_SIGNAL( currentChanged( KrViewItem * ) ),
SLOTS, TQT_SLOT( updatePopupPanel( KrViewItem* ) ) );
connect( dynamic_cast<KrBriefView*>( view ), TQ_SIGNAL( middleButtonClicked( KrViewItem * ) ), SLOTS, TQ_SLOT( newTab( KrViewItem * ) ) );
connect( dynamic_cast<KrBriefView*>( view ), TQ_SIGNAL( currentChanged( KrViewItem * ) ),
SLOTS, TQ_SLOT( updatePopupPanel( KrViewItem* ) ) );
// connect quicksearch
connect( quickSearch, TQT_SIGNAL( textChanged( const TQString& ) ),
dynamic_cast<KrBriefView*>( view ), TQT_SLOT( quickSearch( const TQString& ) ) );
connect( quickSearch, TQT_SIGNAL( otherMatching( const TQString&, int ) ),
dynamic_cast<KrBriefView*>( view ), TQT_SLOT( quickSearch( const TQString& , int ) ) );
connect( quickSearch, TQT_SIGNAL( stop( TQKeyEvent* ) ),
dynamic_cast<KrBriefView*>( view ), TQT_SLOT( stopQuickSearch( TQKeyEvent* ) ) );
connect( quickSearch, TQT_SIGNAL( process( TQKeyEvent* ) ),
dynamic_cast<KrBriefView*>( view ), TQT_SLOT( handleQuickSearchEvent( TQKeyEvent* ) ) );
connect( quickSearch, TQ_SIGNAL( textChanged( const TQString& ) ),
dynamic_cast<KrBriefView*>( view ), TQ_SLOT( quickSearch( const TQString& ) ) );
connect( quickSearch, TQ_SIGNAL( otherMatching( const TQString&, int ) ),
dynamic_cast<KrBriefView*>( view ), TQ_SLOT( quickSearch( const TQString& , int ) ) );
connect( quickSearch, TQ_SIGNAL( stop( TQKeyEvent* ) ),
dynamic_cast<KrBriefView*>( view ), TQ_SLOT( stopQuickSearch( TQKeyEvent* ) ) );
connect( quickSearch, TQ_SIGNAL( process( TQKeyEvent* ) ),
dynamic_cast<KrBriefView*>( view ), TQ_SLOT( handleQuickSearchEvent( TQKeyEvent* ) ) );
} else { /* Detailed */
panelType = "Detailed";
view = new KrDetailedView( splt, _left, krConfig );
view->init();
connect( dynamic_cast<KrDetailedView*>( view ), TQT_SIGNAL( middleButtonClicked( KrViewItem * ) ), SLOTS, TQT_SLOT( newTab( KrViewItem * ) ) );
connect( dynamic_cast<KrDetailedView*>( view ), TQT_SIGNAL( currentChanged( KrViewItem * ) ),
SLOTS, TQT_SLOT( updatePopupPanel( KrViewItem * ) ) );
connect( dynamic_cast<KrDetailedView*>( view ), TQ_SIGNAL( middleButtonClicked( KrViewItem * ) ), SLOTS, TQ_SLOT( newTab( KrViewItem * ) ) );
connect( dynamic_cast<KrDetailedView*>( view ), TQ_SIGNAL( currentChanged( KrViewItem * ) ),
SLOTS, TQ_SLOT( updatePopupPanel( KrViewItem * ) ) );
// connect quicksearch
connect( quickSearch, TQT_SIGNAL( textChanged( const TQString& ) ),
dynamic_cast<KrDetailedView*>( view ), TQT_SLOT( quickSearch( const TQString& ) ) );
connect( quickSearch, TQT_SIGNAL( otherMatching( const TQString&, int ) ),
dynamic_cast<KrDetailedView*>( view ), TQT_SLOT( quickSearch( const TQString& , int ) ) );
connect( quickSearch, TQT_SIGNAL( stop( TQKeyEvent* ) ),
dynamic_cast<KrDetailedView*>( view ), TQT_SLOT( stopQuickSearch( TQKeyEvent* ) ) );
connect( quickSearch, TQT_SIGNAL( process( TQKeyEvent* ) ),
dynamic_cast<KrDetailedView*>( view ), TQT_SLOT( handleQuickSearchEvent( TQKeyEvent* ) ) );
connect( quickSearch, TQ_SIGNAL( textChanged( const TQString& ) ),
dynamic_cast<KrDetailedView*>( view ), TQ_SLOT( quickSearch( const TQString& ) ) );
connect( quickSearch, TQ_SIGNAL( otherMatching( const TQString&, int ) ),
dynamic_cast<KrDetailedView*>( view ), TQ_SLOT( quickSearch( const TQString& , int ) ) );
connect( quickSearch, TQ_SIGNAL( stop( TQKeyEvent* ) ),
dynamic_cast<KrDetailedView*>( view ), TQ_SLOT( stopQuickSearch( TQKeyEvent* ) ) );
connect( quickSearch, TQ_SIGNAL( process( TQKeyEvent* ) ),
dynamic_cast<KrDetailedView*>( view ), TQ_SLOT( handleQuickSearchEvent( TQKeyEvent* ) ) );
}
connect( view->op(), TQT_SIGNAL( renameItem( const TQString &, const TQString & ) ),
func, TQT_SLOT( rename( const TQString &, const TQString & ) ) );
connect( view->op(), TQT_SIGNAL( executed( TQString& ) ), func, TQT_SLOT( execute( TQString& ) ) );
connect( view->op(), TQT_SIGNAL( needFocus() ), this, TQT_SLOT( slotFocusOnMe() ) );
connect( view->op(), TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateTotals() ) );
connect( view->op(), TQT_SIGNAL( itemDescription( TQString& ) ), krApp, TQT_SLOT( statusBarUpdate( TQString& ) ) );
connect( view->op(), TQT_SIGNAL( contextMenu( const TQPoint & ) ), this, TQT_SLOT( popRightClickMenu( const TQPoint & ) ) );
connect( view->op(), TQT_SIGNAL( emptyContextMenu( const TQPoint &) ),
this, TQT_SLOT( popEmptyRightClickMenu( const TQPoint & ) ) );
connect( view->op(), TQT_SIGNAL( letsDrag( TQStringList, TQPixmap ) ), this, TQT_SLOT( startDragging( TQStringList, TQPixmap ) ) );
connect( view->op(), TQT_SIGNAL( gotDrop( TQDropEvent * ) ), this, TQT_SLOT( handleDropOnView( TQDropEvent * ) ) );
connect( view->op(), TQ_SIGNAL( renameItem( const TQString &, const TQString & ) ),
func, TQ_SLOT( rename( const TQString &, const TQString & ) ) );
connect( view->op(), TQ_SIGNAL( executed( TQString& ) ), func, TQ_SLOT( execute( TQString& ) ) );
connect( view->op(), TQ_SIGNAL( needFocus() ), this, TQ_SLOT( slotFocusOnMe() ) );
connect( view->op(), TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateTotals() ) );
connect( view->op(), TQ_SIGNAL( itemDescription( TQString& ) ), krApp, TQ_SLOT( statusBarUpdate( TQString& ) ) );
connect( view->op(), TQ_SIGNAL( contextMenu( const TQPoint & ) ), this, TQ_SLOT( popRightClickMenu( const TQPoint & ) ) );
connect( view->op(), TQ_SIGNAL( emptyContextMenu( const TQPoint &) ),
this, TQ_SLOT( popEmptyRightClickMenu( const TQPoint & ) ) );
connect( view->op(), TQ_SIGNAL( letsDrag( TQStringList, TQPixmap ) ), this, TQ_SLOT( startDragging( TQStringList, TQPixmap ) ) );
connect( view->op(), TQ_SIGNAL( gotDrop( TQDropEvent * ) ), this, TQ_SLOT( handleDropOnView( TQDropEvent * ) ) );
}
void ListPanel::changeType( const TQString & type )
@ -739,8 +739,8 @@ void ListPanel::slotGetStats( const KURL& url ) {
status->setText( i18n( "Mt.Man: working ..." ) );
statsAgent = KDiskFreeSp::findUsageInfo( path );
connect( statsAgent, TQT_SIGNAL( foundMountPoint( const TQString &, unsigned long, unsigned long, unsigned long ) ),
this, TQT_SLOT( gotStats( const TQString &, unsigned long, unsigned long, unsigned long ) ) );
connect( statsAgent, TQ_SIGNAL( foundMountPoint( const TQString &, unsigned long, unsigned long, unsigned long ) ),
this, TQ_SLOT( gotStats( const TQString &, unsigned long, unsigned long, unsigned long ) ) );
}
void ListPanel::gotStats( const TQString &mountPoint, unsigned long kBSize,
@ -1054,14 +1054,14 @@ void ListPanel::slotJobStarted(TDEIO::Job* job) {
syncBrowseButton->setEnabled(false);
// connect to the job interface to provide in-panel refresh notification
connect( job, TQT_SIGNAL( infoMessage( TDEIO::Job*, const TQString & ) ),
TQT_SLOT( inlineRefreshInfoMessage( TDEIO::Job*, const TQString & ) ) );
connect( job, TQT_SIGNAL( percent( TDEIO::Job*, unsigned long ) ),
TQT_SLOT( inlineRefreshPercent( TDEIO::Job*, unsigned long ) ) );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),
this,TQT_SLOT(inlineRefreshListResult(TDEIO::Job*)));
connect(job,TQT_SIGNAL(canceled(TDEIO::Job*)),
this,TQT_SLOT(inlineRefreshListResult(TDEIO::Job*)));
connect( job, TQ_SIGNAL( infoMessage( TDEIO::Job*, const TQString & ) ),
TQ_SLOT( inlineRefreshInfoMessage( TDEIO::Job*, const TQString & ) ) );
connect( job, TQ_SIGNAL( percent( TDEIO::Job*, unsigned long ) ),
TQ_SLOT( inlineRefreshPercent( TDEIO::Job*, unsigned long ) ) );
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),
this,TQ_SLOT(inlineRefreshListResult(TDEIO::Job*)));
connect(job,TQ_SIGNAL(canceled(TDEIO::Job*)),
this,TQ_SLOT(inlineRefreshListResult(TDEIO::Job*)));
inlineRefreshJob = job;

50
krusader/Panel/panelfunc.cpp
Unescape View File

@ -87,7 +87,7 @@ A
ListPanelFunc::ListPanelFunc( ListPanel *parent ) :
panel( parent ), inRefresh( false ), vfsP( 0 ) {
urlStack.push( "file:/" );
connect( &delayTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( doOpenUrl() ) );
connect( &delayTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( doOpenUrl() ) );
}
void ListPanelFunc::openUrl( const TQString& url, const TQString& nameToMakeCurrent ) {
@ -155,7 +155,7 @@ void ListPanelFunc::immediateOpenUrl( const KURL& urlIn ) {
if( vfsP->vfs_canDelete() )
delete vfsP;
else {
connect( vfsP, TQT_SIGNAL( deleteAllowed() ), vfsP, TQT_SLOT( deleteLater() ) );
connect( vfsP, TQ_SIGNAL( deleteAllowed() ), vfsP, TQ_SLOT( deleteLater() ) );
vfsP->vfs_requestDelete();
}
vfsP = v; // v != 0 so this is safe
@ -167,8 +167,8 @@ void ListPanelFunc::immediateOpenUrl( const KURL& urlIn ) {
return;
}
}
connect( files(), TQT_SIGNAL(startJob(TDEIO::Job* )),
panel, TQT_SLOT(slotJobStarted(TDEIO::Job* )));
connect( files(), TQ_SIGNAL(startJob(TDEIO::Job* )),
panel, TQ_SLOT(slotJobStarted(TDEIO::Job* )));
if ( vfsP->vfs_refresh( u ) ) {
break; // we have a valid refreshed URL now
}
@ -191,19 +191,19 @@ void ListPanelFunc::immediateOpenUrl( const KURL& urlIn ) {
urlStack.push( files() ->vfs_getOrigin() );
}
// disconnect older signals
disconnect( files(), TQT_SIGNAL( addedVfile( vfile* ) ), 0, 0 );
disconnect( files(), TQT_SIGNAL( updatedVfile( vfile* ) ), 0, 0 );
disconnect( files(), TQT_SIGNAL( deletedVfile( const TQString& ) ), 0, 0 );
disconnect( files(), TQT_SIGNAL( cleared() ), 0, 0 );
disconnect( files(), TQ_SIGNAL( addedVfile( vfile* ) ), 0, 0 );
disconnect( files(), TQ_SIGNAL( updatedVfile( vfile* ) ), 0, 0 );
disconnect( files(), TQ_SIGNAL( deletedVfile( const TQString& ) ), 0, 0 );
disconnect( files(), TQ_SIGNAL( cleared() ), 0, 0 );
// connect to the vfs's dirwatch signals
connect( files(), TQT_SIGNAL( addedVfile( vfile* ) ),
panel, TQT_SLOT( slotItemAdded( vfile* ) ) );
connect( files(), TQT_SIGNAL( updatedVfile( vfile* ) ),
panel, TQT_SLOT( slotItemUpdated( vfile* ) ) );
connect( files(), TQT_SIGNAL( deletedVfile( const TQString& ) ),
panel, TQT_SLOT( slotItemDeleted( const TQString& ) ) );
connect( files(), TQT_SIGNAL( cleared() ),
panel, TQT_SLOT( slotCleared() ) );
connect( files(), TQ_SIGNAL( addedVfile( vfile* ) ),
panel, TQ_SLOT( slotItemAdded( vfile* ) ) );
connect( files(), TQ_SIGNAL( updatedVfile( vfile* ) ),
panel, TQ_SLOT( slotItemUpdated( vfile* ) ) );
connect( files(), TQ_SIGNAL( deletedVfile( const TQString& ) ),
panel, TQ_SLOT( slotItemDeleted( const TQString& ) ) );
connect( files(), TQ_SIGNAL( cleared() ),
panel, TQ_SLOT( slotCleared() ) );
// on local file system change the working directory
if ( files() ->vfs_getType() == vfs::NORMAL )
@ -449,9 +449,9 @@ void ListPanelFunc::moveFiles() {
if( !virtualBaseURL.isEmpty() ) {
// keep the directory structure for virtual paths
VirtualCopyJob *vjob = new VirtualCopyJob( &fileNames, files(), dest, virtualBaseURL, pmode, TDEIO::CopyJob::Move, false, true );
connect( vjob, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( refresh() ) );
connect( vjob, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( refresh() ) );
if ( dest.equals( panel->otherPanel->virtualPath(), true ) )
connect( vjob, TQT_SIGNAL( result( TDEIO::Job* ) ), panel->otherPanel->func, TQT_SLOT( refresh() ) );
connect( vjob, TQ_SIGNAL( result( TDEIO::Job* ) ), panel->otherPanel->func, TQ_SLOT( refresh() ) );
}
// if we are not moving to the other panel :
else if ( !dest.equals( panel->otherPanel->virtualPath(), true ) ) {
@ -461,10 +461,10 @@ void ListPanelFunc::moveFiles() {
TDEIO::Job* job = PreservingCopyJob::createCopyJob( pmode, *fileUrls, dest, TDEIO::CopyJob::Move, false, true );
job->setAutoErrorHandlingEnabled( true );
// refresh our panel when done
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( refresh() ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( refresh() ) );
// and if needed the other panel as well
if ( dest.equals( panel->otherPanel->virtualPath(), true ) )
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), panel->otherPanel->func, TQT_SLOT( refresh() ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), panel->otherPanel->func, TQ_SLOT( refresh() ) );
} else { // let the other panel do the dirty job
//check if copy is supported
@ -597,9 +597,9 @@ void ListPanelFunc::copyFiles() {
if( !virtualBaseURL.isEmpty() ) {
// keep the directory structure for virtual paths
VirtualCopyJob *vjob = new VirtualCopyJob( &fileNames, files(), dest, virtualBaseURL, pmode, TDEIO::CopyJob::Copy, false, true );
connect( vjob, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( refresh() ) );
connect( vjob, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( refresh() ) );
if ( dest.equals( panel->otherPanel->virtualPath(), true ) )
connect( vjob, TQT_SIGNAL( result( TDEIO::Job* ) ), panel->otherPanel->func, TQT_SLOT( refresh() ) );
connect( vjob, TQ_SIGNAL( result( TDEIO::Job* ) ), panel->otherPanel->func, TQ_SLOT( refresh() ) );
}
// if we are not copying to the other panel :
else if ( !dest.equals( panel->otherPanel->virtualPath(), true ) ) {
@ -611,7 +611,7 @@ void ListPanelFunc::copyFiles() {
if ( dest.equals( panel->virtualPath(), true ) ||
dest.upURL().equals( panel->virtualPath(), true ) )
// refresh our panel when done
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( refresh() ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( refresh() ) );
// let the other panel do the dirty job
} else {
//check if copy is supported
@ -1110,7 +1110,7 @@ void ListPanelFunc::properties() {
// Show the properties dialog
KPropertiesDialog *dlg = new KPropertiesDialog( fi );
connect( dlg, TQT_SIGNAL( applied() ), SLOTS, TQT_SLOT( refresh() ) );
connect( dlg, TQ_SIGNAL( applied() ), SLOTS, TQ_SLOT( refresh() ) );
}
void ListPanelFunc::refreshActions() {
@ -1144,7 +1144,7 @@ ListPanelFunc::~ListPanelFunc() {
if( vfsP->vfs_canDelete() )
delete vfsP;
else {
connect( vfsP, TQT_SIGNAL( deleteAllowed() ), vfsP, TQT_SLOT( deleteLater() ) );
connect( vfsP, TQ_SIGNAL( deleteAllowed() ), vfsP, TQ_SLOT( deleteLater() ) );
vfsP->vfs_requestDelete();
}
}

24
krusader/Panel/panelpopup.cpp
Unescape View File

@ -43,7 +43,7 @@ PanelPopup::PanelPopup( TQSplitter *parent, bool left ) : TQWidget( parent ),
// create the label+buttons setup
dataLine = new KrSqueezedTextLabel(this);
dataLine->setText("blah blah");
connect( dataLine, TQT_SIGNAL( clicked() ), this, TQT_SLOT( setFocus() ) );
connect( dataLine, TQ_SIGNAL( clicked() ), this, TQ_SLOT( setFocus() ) );
krConfig->setGroup( "Look&Feel" );
dataLine->setFont( krConfig->readFontEntry( "Filelist Font", _FilelistFont ) );
// --- hack: setup colors to be the same as an inactive panel
@ -60,7 +60,7 @@ PanelPopup::PanelPopup( TQSplitter *parent, bool left ) : TQWidget( parent ),
btns = new TQButtonGroup(this);
btns->setExclusive(true);
btns->hide(); // it should be invisible
connect(btns, TQT_SIGNAL(clicked(int)), this, TQT_SLOT(tabSelected(int)));
connect(btns, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(tabSelected(int)));
treeBtn = new TQToolButton(this);
TQToolTip::add(treeBtn, i18n("Tree Panel: a tree view of the local file system"));
@ -111,8 +111,8 @@ PanelPopup::PanelPopup( TQSplitter *parent, bool left ) : TQWidget( parent ),
// create the tree part ----------
tree = new KFileTreeView( stack );
tree->setAcceptDrops(true);
connect(tree, TQT_SIGNAL(dropped (TQWidget *, TQDropEvent *, KURL::List &, KURL &)),
this, TQT_SLOT(slotDroppedOnTree(TQWidget *, TQDropEvent *, KURL::List&, KURL& )));
connect(tree, TQ_SIGNAL(dropped (TQWidget *, TQDropEvent *, KURL::List &, KURL &)),
this, TQ_SLOT(slotDroppedOnTree(TQWidget *, TQDropEvent *, KURL::List&, KURL& )));
stack->addWidget( tree, Tree );
tree->addColumn( "" );
// add ~
@ -126,7 +126,7 @@ PanelPopup::PanelPopup( TQSplitter *parent, bool left ) : TQWidget( parent ),
tree->branch( i18n( "Root" ) ) ->setChildRecurse(false);
tree->branch( i18n( "Root" ) ) ->setOpen( true );
tree->header() ->setHidden( true );
connect(tree, TQT_SIGNAL(doubleClicked(TQListViewItem*)), this, TQT_SLOT(treeSelection(TQListViewItem*)));
connect(tree, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(treeSelection(TQListViewItem*)));
// start listing the tree
tree->branch( i18n( "Root" ) ) ->root();
tree->branch( i18n( "Home" ) ) ->root();
@ -139,14 +139,14 @@ PanelPopup::PanelPopup( TQSplitter *parent, bool left ) : TQWidget( parent ),
panelviewer = new PanelViewer(stack);
stack->addWidget(panelviewer, View);
connect(panelviewer, TQT_SIGNAL(openURLRequest(const KURL &)), this, TQT_SLOT(handleOpenURLRequest(const KURL &)));
connect(panelviewer, TQ_SIGNAL(openURLRequest(const KURL &)), this, TQ_SLOT(handleOpenURLRequest(const KURL &)));
// create the disk usage view
diskusage = new DiskUsageViewer( stack );
diskusage->setStatusLabel( dataLine, i18n("Disk Usage: ") );
stack->addWidget( diskusage, DskUsage );
connect(diskusage, TQT_SIGNAL(openURLRequest(const KURL &)), this, TQT_SLOT(handleOpenURLRequest(const KURL &)));
connect(diskusage, TQ_SIGNAL(openURLRequest(const KURL &)), this, TQ_SLOT(handleOpenURLRequest(const KURL &)));
// create the quick-panel part ----
@ -164,26 +164,26 @@ PanelPopup::PanelPopup( TQSplitter *parent, bool left ) : TQWidget( parent ),
quickSelectCombo->setCurrentText( "*" );
quickSelectCombo->setSizePolicy( TQSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Preferred ) );
connect(quickSelectCombo, TQT_SIGNAL(returnPressed(const TQString& )),
this, TQT_SLOT(quickSelect(const TQString& )));
connect(quickSelectCombo, TQ_SIGNAL(returnPressed(const TQString& )),
this, TQ_SLOT(quickSelect(const TQString& )));
TQToolButton *qselectBtn = new TQToolButton(quickPanel);
qselectBtn->setPixmap(krLoader->loadIcon( "kr_selectall", TDEIcon::Toolbar, 16 ));
qselectBtn->setFixedSize(20, 20);
TQToolTip::add( qselectBtn, i18n("apply the selection") );
connect(qselectBtn, TQT_SIGNAL(clicked()), this, TQT_SLOT(quickSelect()));
connect(qselectBtn, TQ_SIGNAL(clicked()), this, TQ_SLOT(quickSelect()));
TQToolButton *qstoreBtn = new TQToolButton(quickPanel);
qstoreBtn->setPixmap(krLoader->loadIcon( "document-save", TDEIcon::Toolbar, 16 ));
qstoreBtn->setFixedSize(20, 20);
TQToolTip::add( qstoreBtn, i18n("store the current selection") );
connect(qstoreBtn, TQT_SIGNAL(clicked()), this, TQT_SLOT(quickSelectStore()));
connect(qstoreBtn, TQ_SIGNAL(clicked()), this, TQ_SLOT(quickSelectStore()));
TQToolButton *qsettingsBtn = new TQToolButton(quickPanel);
qsettingsBtn->setPixmap(krLoader->loadIcon( "configure", TDEIcon::Toolbar, 16 ));
qsettingsBtn->setFixedSize(20, 20);
TQToolTip::add( qsettingsBtn, i18n("select group dialog") );
connect(qsettingsBtn, TQT_SIGNAL(clicked()), krSelect, TQT_SLOT(activate()));
connect(qsettingsBtn, TQ_SIGNAL(clicked()), krSelect, TQ_SLOT(activate()));
qlayout->addWidget(selectLabel,0,0);
qlayout->addWidget(quickSelectCombo,0,1);

8
krusader/RemoteMan/remoteman.cpp
Unescape View File

@ -54,10 +54,10 @@ remoteMan::remoteMan() : remoteManBase(0,0,true), currentItem(0) {
// some minor fixes, left out of the designer - do again in next version !
password->setEchoMode(TQLineEdit::Password);
// ===> should be moved to remoteManBase <=====
connect( hostName, TQT_SIGNAL( textChanged(const TQString&) ),
this, TQT_SLOT( updateConnect(const TQString&) ) );
connect( sessions, TQT_SIGNAL(doubleClicked(TQListViewItem *)), this, TQT_SLOT(connection()));
connect( sessions, TQT_SIGNAL(returnPressed(TQListViewItem *)), this, TQT_SLOT(connection()));
connect( hostName, TQ_SIGNAL( textChanged(const TQString&) ),
this, TQ_SLOT( updateConnect(const TQString&) ) );
connect( sessions, TQ_SIGNAL(doubleClicked(TQListViewItem *)), this, TQ_SLOT(connection()));
connect( sessions, TQ_SIGNAL(returnPressed(TQListViewItem *)), this, TQ_SLOT(connection()));
// execute the main dialog
exec();
}

30
krusader/RemoteMan/remotemanbase.cpp
Unescape View File

@ -238,21 +238,21 @@ remoteManBase::remoteManBase( TQWidget* parent, const char* name, bool modal, W
remoteManBaseLayout->addWidget( TextLabel1_4, 3, 1 );
// signals and slots connections
connect( closeBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( accept() ) );
connect( addBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addSession() ) );
connect( removeBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( removeSession() ) );
connect( sessions, TQT_SIGNAL( selectionChanged(TQListViewItem*) ), this, TQT_SLOT( refreshData() ) );
connect( sessions, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( refreshData() ) );
connect( sessions, TQT_SIGNAL( expanded(TQListViewItem*) ), this, TQT_SLOT( refreshData() ) );
connect( sessions, TQT_SIGNAL( currentChanged(TQListViewItem*) ), this, TQT_SLOT( refreshData() ) );
connect( sessions, TQT_SIGNAL( mouseButtonClicked(int,TQListViewItem*,const
TQPoint&,int) ), this, TQT_SLOT( refreshData() ) );
connect( sessions, TQT_SIGNAL( collapsed(TQListViewItem*) ), this, TQT_SLOT( refreshData() ) );
connect( connectBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( connection() ) );
connect( sessionName, TQT_SIGNAL( textChanged(const TQString&) ), this, TQT_SLOT( updateName(const TQString&) ) );
connect( newGroupBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addGroup() ) );
connect( anonymous, TQT_SIGNAL( clicked() ), this, TQT_SLOT( refreshData() ) );
connect( protocol, TQT_SIGNAL(activated(int)), this, TQT_SLOT(refreshData()));
connect( closeBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( accept() ) );
connect( addBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addSession() ) );
connect( removeBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( removeSession() ) );
connect( sessions, TQ_SIGNAL( selectionChanged(TQListViewItem*) ), this, TQ_SLOT( refreshData() ) );
connect( sessions, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( refreshData() ) );
connect( sessions, TQ_SIGNAL( expanded(TQListViewItem*) ), this, TQ_SLOT( refreshData() ) );
connect( sessions, TQ_SIGNAL( currentChanged(TQListViewItem*) ), this, TQ_SLOT( refreshData() ) );
connect( sessions, TQ_SIGNAL( mouseButtonClicked(int,TQListViewItem*,const
TQPoint&,int) ), this, TQ_SLOT( refreshData() ) );
connect( sessions, TQ_SIGNAL( collapsed(TQListViewItem*) ), this, TQ_SLOT( refreshData() ) );
connect( connectBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( connection() ) );
connect( sessionName, TQ_SIGNAL( textChanged(const TQString&) ), this, TQ_SLOT( updateName(const TQString&) ) );
connect( newGroupBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addGroup() ) );
connect( anonymous, TQ_SIGNAL( clicked() ), this, TQ_SLOT( refreshData() ) );
connect( protocol, TQ_SIGNAL(activated(int)), this, TQ_SLOT(refreshData()));
// tab order
setTabOrder( sessionName, hostName );

42
krusader/Search/krsearchdialog.cpp
Unescape View File

@ -235,22 +235,22 @@ KrSearchDialog::KrSearchDialog( TQString profile, TQWidget* parent, const char*
// signals and slots connections
connect( mainSearchBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( startSearch() ) );
connect( mainStopBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( stopSearch() ) );
connect( resultsList, TQT_SIGNAL( returnPressed(TQListViewItem*) ), this,
TQT_SLOT( resultDoubleClicked(TQListViewItem*) ) );
connect( resultsList, TQT_SIGNAL( doubleClicked(TQListViewItem*) ), this,
TQT_SLOT( resultDoubleClicked(TQListViewItem*) ) );
connect( resultsList, TQT_SIGNAL( currentChanged(TQListViewItem*) ), this,
TQT_SLOT( resultClicked(TQListViewItem*) ) );
connect( resultsList, TQT_SIGNAL( clicked(TQListViewItem*) ), this,
TQT_SLOT( resultClicked(TQListViewItem*) ) );
connect( resultsList, TQT_SIGNAL( rightButtonClicked(TQListViewItem*,const TQPoint&,int) ), this, TQT_SLOT( rightClickMenu(TQListViewItem*, const TQPoint&, int) ) );
connect( mainCloseBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( closeDialog() ) );
connect( mainFeedToListBoxBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( feedToListBox() ) );
connect( profileManager, TQT_SIGNAL( loadFromProfile( TQString ) ), filterTabs, TQT_SLOT( loadFromProfile( TQString ) ) );
connect( profileManager, TQT_SIGNAL( saveToProfile( TQString ) ), filterTabs, TQT_SLOT( saveToProfile( TQString ) ) );
connect( mainSearchBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( startSearch() ) );
connect( mainStopBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( stopSearch() ) );
connect( resultsList, TQ_SIGNAL( returnPressed(TQListViewItem*) ), this,
TQ_SLOT( resultDoubleClicked(TQListViewItem*) ) );
connect( resultsList, TQ_SIGNAL( doubleClicked(TQListViewItem*) ), this,
TQ_SLOT( resultDoubleClicked(TQListViewItem*) ) );
connect( resultsList, TQ_SIGNAL( currentChanged(TQListViewItem*) ), this,
TQ_SLOT( resultClicked(TQListViewItem*) ) );
connect( resultsList, TQ_SIGNAL( clicked(TQListViewItem*) ), this,
TQ_SLOT( resultClicked(TQListViewItem*) ) );
connect( resultsList, TQ_SIGNAL( rightButtonClicked(TQListViewItem*,const TQPoint&,int) ), this, TQ_SLOT( rightClickMenu(TQListViewItem*, const TQPoint&, int) ) );
connect( mainCloseBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( closeDialog() ) );
connect( mainFeedToListBoxBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( feedToListBox() ) );
connect( profileManager, TQ_SIGNAL( loadFromProfile( TQString ) ), filterTabs, TQ_SLOT( loadFromProfile( TQString ) ) );
connect( profileManager, TQ_SIGNAL( saveToProfile( TQString ) ), filterTabs, TQ_SLOT( saveToProfile( TQString ) ) );
// tab order
@ -403,11 +403,11 @@ void KrSearchDialog::startSearch() {
searcher = 0;
}
searcher = new KRSearchMod(query);
connect(searcher, TQT_SIGNAL(searching(const TQString&)),
searchingLabel, TQT_SLOT(setText(const TQString&)));
connect(searcher, TQT_SIGNAL(found(TQString,TQString,TDEIO::filesize_t,time_t,TQString,TQString)),
this, TQT_SLOT(found(TQString,TQString,TDEIO::filesize_t,time_t,TQString,TQString)));
connect(searcher, TQT_SIGNAL(finished()), this, TQT_SLOT(stopSearch()));
connect(searcher, TQ_SIGNAL(searching(const TQString&)),
searchingLabel, TQ_SLOT(setText(const TQString&)));
connect(searcher, TQ_SIGNAL(found(TQString,TQString,TDEIO::filesize_t,time_t,TQString,TQString)),
this, TQ_SLOT(found(TQString,TQString,TDEIO::filesize_t,time_t,TQString,TQString)));
connect(searcher, TQ_SIGNAL(finished()), this, TQ_SLOT(stopSearch()));
isSearching = true;
searcher->start();

8
krusader/Search/krsearchmod.cpp
Unescape View File

@ -56,10 +56,10 @@ KRSearchMod::KRSearchMod( const KRQuery* q )
{
stopSearch = false; /// ===> added
query = new KRQuery( *q );
connect( query, TQT_SIGNAL( status( const TQString & ) ),
this, TQT_SIGNAL( searching(const TQString&) ) );
connect( query, TQT_SIGNAL( processEvents( bool & ) ),
this, TQT_SLOT ( slotProcessEvents( bool & ) ) );
connect( query, TQ_SIGNAL( status( const TQString & ) ),
this, TQ_SIGNAL( searching(const TQString&) ) );
connect( query, TQ_SIGNAL( processEvents( bool & ) ),
this, TQ_SLOT ( slotProcessEvents( bool & ) ) );
remote_vfs = 0;
virtual_vfs = 0;

28
krusader/Splitter/combiner.cpp
Unescape View File

@ -87,10 +87,10 @@ void Combiner::combine()
combineReadJob = TDEIO::get( splURL, false, false );
connect(combineReadJob, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(combineSplitFileDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(combineReadJob, TQT_SIGNAL(result(TDEIO::Job*)),
this, TQT_SLOT(combineSplitFileFinished(TDEIO::Job *)));
connect(combineReadJob, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(combineSplitFileDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(combineReadJob, TQ_SIGNAL(result(TDEIO::Job*)),
this, TQ_SLOT(combineSplitFileFinished(TDEIO::Job *)));
}
exec();
@ -197,13 +197,13 @@ void Combiner::openNextFile()
/* creating a write job */
combineReadJob = TDEIO::get( readURL, false, false );
connect(combineReadJob, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(combineDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(combineReadJob, TQT_SIGNAL(result(TDEIO::Job*)),
this, TQT_SLOT(combineReceiveFinished(TDEIO::Job *)));
connect(combineReadJob, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(combineDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(combineReadJob, TQ_SIGNAL(result(TDEIO::Job*)),
this, TQ_SLOT(combineReceiveFinished(TDEIO::Job *)));
if( hasValidSplitFile )
connect(combineReadJob, TQT_SIGNAL(percent (TDEIO::Job *, unsigned long)),
this, TQT_SLOT(combineWritePercent(TDEIO::Job *, unsigned long)));
connect(combineReadJob, TQ_SIGNAL(percent (TDEIO::Job *, unsigned long)),
this, TQ_SLOT(combineWritePercent(TDEIO::Job *, unsigned long)));
}
@ -228,10 +228,10 @@ void Combiner::combineDataReceived(TDEIO::Job *, const TQByteArray &byteArray)
combineWriteJob = TDEIO::put( writeURL, permissions, true, false, false );
connect(combineWriteJob, TQT_SIGNAL(dataReq(TDEIO::Job *, TQByteArray &)),
this, TQT_SLOT(combineDataSend(TDEIO::Job *, TQByteArray &)));
connect(combineWriteJob, TQT_SIGNAL(result(TDEIO::Job*)),
this, TQT_SLOT(combineSendFinished(TDEIO::Job *)));
connect(combineWriteJob, TQ_SIGNAL(dataReq(TDEIO::Job *, TQByteArray &)),
this, TQ_SLOT(combineDataSend(TDEIO::Job *, TQByteArray &)));
connect(combineWriteJob, TQ_SIGNAL(result(TDEIO::Job*)),
this, TQ_SLOT(combineSendFinished(TDEIO::Job *)));
}
if( combineWriteJob )

28
krusader/Splitter/splitter.cpp
Unescape View File

@ -80,12 +80,12 @@ void Splitter::split( TDEIO::filesize_t splitSizeIn )
splitReadJob = TDEIO::get( fileName, false, false );
connect(splitReadJob, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(splitDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(splitReadJob, TQT_SIGNAL(result(TDEIO::Job*)),
this, TQT_SLOT(splitReceiveFinished(TDEIO::Job *)));
connect(splitReadJob, TQT_SIGNAL(percent (TDEIO::Job *, unsigned long)),
this, TQT_SLOT(splitReceivePercent(TDEIO::Job *, unsigned long)));
connect(splitReadJob, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(splitDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(splitReadJob, TQ_SIGNAL(result(TDEIO::Job*)),
this, TQ_SLOT(splitReceiveFinished(TDEIO::Job *)));
connect(splitReadJob, TQ_SIGNAL(percent (TDEIO::Job *, unsigned long)),
this, TQ_SLOT(splitReceivePercent(TDEIO::Job *, unsigned long)));
splitWriteJob = 0;
noValidWriteJob = true;
@ -152,10 +152,10 @@ void Splitter::splitCreateWriteJob()
/* creating a write job */
splitWriteJob = TDEIO::put( writeURL, permissions, true, false, false );
outputFileSize = 0;
connect(splitWriteJob, TQT_SIGNAL(dataReq(TDEIO::Job *, TQByteArray &)),
this, TQT_SLOT(splitDataSend(TDEIO::Job *, TQByteArray &)));
connect(splitWriteJob, TQT_SIGNAL(result(TDEIO::Job*)),
this, TQT_SLOT(splitSendFinished(TDEIO::Job *)));
connect(splitWriteJob, TQ_SIGNAL(dataReq(TDEIO::Job *, TQByteArray &)),
this, TQ_SLOT(splitDataSend(TDEIO::Job *, TQByteArray &)));
connect(splitWriteJob, TQ_SIGNAL(result(TDEIO::Job*)),
this, TQ_SLOT(splitSendFinished(TDEIO::Job *)));
noValidWriteJob = false;
}
@ -211,10 +211,10 @@ void Splitter::splitSendFinished(TDEIO::Job *job)
writeURL = destinationDir;
writeURL.addPath( fileName.fileName() + ".crc" );
splitWriteJob = TDEIO::put( writeURL, permissions, true, false, false );
connect(splitWriteJob, TQT_SIGNAL(dataReq(TDEIO::Job *, TQByteArray &)),
this, TQT_SLOT(splitFileSend(TDEIO::Job *, TQByteArray &)));
connect(splitWriteJob, TQT_SIGNAL(result(TDEIO::Job*)),
this, TQT_SLOT(splitFileFinished(TDEIO::Job *)));
connect(splitWriteJob, TQ_SIGNAL(dataReq(TDEIO::Job *, TQByteArray &)),
this, TQ_SLOT(splitFileSend(TDEIO::Job *, TQByteArray &)));
connect(splitWriteJob, TQ_SIGNAL(result(TDEIO::Job*)),
this, TQ_SLOT(splitFileFinished(TDEIO::Job *)));
}
}

8
krusader/Splitter/splittergui.cpp
Unescape View File

@ -117,10 +117,10 @@ SplitterGUI::SplitterGUI( TQWidget* parent, KURL fileURL, KURL defaultDir ) :
setCaption(i18n("Krusader::Splitter"));
connect( sizeCombo, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( sizeComboActivated( int ) ) );
connect( deviceCombo, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( predefinedComboActivated( int ) ) );
connect( cancelBtn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( reject() ) );
connect( splitBtn , TQT_SIGNAL( clicked() ), this, TQT_SLOT( splitPressed() ) );
connect( sizeCombo, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( sizeComboActivated( int ) ) );
connect( deviceCombo, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( predefinedComboActivated( int ) ) );
connect( cancelBtn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( reject() ) );
connect( splitBtn , TQ_SIGNAL( clicked() ), this, TQ_SLOT( splitPressed() ) );
predefinedComboActivated( 0 );
resultCode = exec();

14
krusader/Synchronizer/synchronizedialog.cpp
Unescape View File

@ -118,9 +118,9 @@ SynchronizeDialog::SynchronizeDialog( TQWidget* parent, const char* name, bool
layout->addWidget( hbox );
connect( btnStart, TQT_SIGNAL( clicked() ), this, TQT_SLOT( startSynchronization() ) );
connect( btnPause, TQT_SIGNAL( clicked() ), this, TQT_SLOT( pauseOrResume() ) );
connect( btnClose, TQT_SIGNAL( clicked() ), this, TQT_SLOT( reject() ) );
connect( btnStart, TQ_SIGNAL( clicked() ), this, TQ_SLOT( startSynchronization() ) );
connect( btnPause, TQ_SIGNAL( clicked() ), this, TQ_SLOT( pauseOrResume() ) );
connect( btnClose, TQ_SIGNAL( clicked() ), this, TQ_SLOT( reject() ) );
exec();
}
@ -134,10 +134,10 @@ void SynchronizeDialog::startSynchronization()
{
btnStart->setEnabled( false );
btnPause->setEnabled( syncStarted = true );
connect( synchronizer, TQT_SIGNAL( synchronizationFinished() ), this, TQT_SLOT( synchronizationFinished() ) );
connect( synchronizer, TQT_SIGNAL( processedSizes( int, TDEIO::filesize_t, int, TDEIO::filesize_t, int, TDEIO::filesize_t ) ),
this, TQT_SLOT( processedSizes( int, TDEIO::filesize_t, int, TDEIO::filesize_t, int, TDEIO::filesize_t) ) );
connect( synchronizer, TQT_SIGNAL( pauseAccepted() ), this, TQT_SLOT( pauseAccepted() ) );
connect( synchronizer, TQ_SIGNAL( synchronizationFinished() ), this, TQ_SLOT( synchronizationFinished() ) );
connect( synchronizer, TQ_SIGNAL( processedSizes( int, TDEIO::filesize_t, int, TDEIO::filesize_t, int, TDEIO::filesize_t ) ),
this, TQ_SLOT( processedSizes( int, TDEIO::filesize_t, int, TDEIO::filesize_t, int, TDEIO::filesize_t) ) );
connect( synchronizer, TQ_SIGNAL( pauseAccepted() ), this, TQ_SLOT( pauseAccepted() ) );
if( !cbRightToLeft->isChecked() ) leftCopySize = 0;
if( !cbLeftToRight->isChecked() ) rightCopySize = 0;

22
krusader/Synchronizer/synchronizer.cpp
Unescape View File

@ -954,7 +954,7 @@ void Synchronizer::executeTask( SynchronizerFileItem * task )
if( task->isDir() )
{
TDEIO::SimpleJob *job = TDEIO::mkdir( leftURL );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(slotTaskFinished(TDEIO::Job*)));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(slotTaskFinished(TDEIO::Job*)));
jobMap[ job ] = task;
disableNewTasks = true;
}
@ -967,14 +967,14 @@ void Synchronizer::executeTask( SynchronizerFileItem * task )
if( task->rightLink().isNull() ) {
TDEIO::FileCopyJob *job = TDEIO::file_copy(rightURL, destURL, -1,
overWrite || task->overWrite(), false, false );
connect(job,TQT_SIGNAL(processedSize (TDEIO::Job *, TDEIO::filesize_t )), this,
TQT_SLOT (slotProcessedSize (TDEIO::Job *, TDEIO::filesize_t )));
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(slotTaskFinished(TDEIO::Job*)));
connect(job,TQ_SIGNAL(processedSize (TDEIO::Job *, TDEIO::filesize_t )), this,
TQ_SLOT (slotProcessedSize (TDEIO::Job *, TDEIO::filesize_t )));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(slotTaskFinished(TDEIO::Job*)));
jobMap[ job ] = task;
} else {
TDEIO::SimpleJob *job = TDEIO::symlink( task->rightLink(), destURL,
overWrite || task->overWrite(), false );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(slotTaskFinished(TDEIO::Job*)));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(slotTaskFinished(TDEIO::Job*)));
jobMap[ job ] = task;
}
}
@ -983,7 +983,7 @@ void Synchronizer::executeTask( SynchronizerFileItem * task )
if( task->isDir() )
{
TDEIO::SimpleJob *job = TDEIO::mkdir( rightURL );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(slotTaskFinished(TDEIO::Job*)));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(slotTaskFinished(TDEIO::Job*)));
jobMap[ job ] = task;
disableNewTasks = true;
}
@ -996,14 +996,14 @@ void Synchronizer::executeTask( SynchronizerFileItem * task )
if( task->leftLink().isNull() ) {
TDEIO::FileCopyJob *job = TDEIO::file_copy(leftURL, destURL, -1,
overWrite || task->overWrite(), false, false );
connect(job,TQT_SIGNAL(processedSize (TDEIO::Job *, TDEIO::filesize_t )), this,
TQT_SLOT (slotProcessedSize (TDEIO::Job *, TDEIO::filesize_t )));
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(slotTaskFinished(TDEIO::Job*)));
connect(job,TQ_SIGNAL(processedSize (TDEIO::Job *, TDEIO::filesize_t )), this,
TQ_SLOT (slotProcessedSize (TDEIO::Job *, TDEIO::filesize_t )));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(slotTaskFinished(TDEIO::Job*)));
jobMap[ job ] = task;
} else {
TDEIO::SimpleJob *job = TDEIO::symlink( task->leftLink(), destURL,
overWrite || task->overWrite(), false );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(slotTaskFinished(TDEIO::Job*)));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(slotTaskFinished(TDEIO::Job*)));
jobMap[ job ] = task;
}
}
@ -1011,7 +1011,7 @@ void Synchronizer::executeTask( SynchronizerFileItem * task )
case TT_DELETE:
{
TDEIO::DeleteJob *job = TDEIO::del( leftURL, false );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(slotTaskFinished(TDEIO::Job*)));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(slotTaskFinished(TDEIO::Job*)));
jobMap[ job ] = task;
}
break;

8
krusader/Synchronizer/synchronizerdirlist.cpp
Unescape View File

@ -154,10 +154,10 @@ bool SynchronizerDirList::load( const TQString &urlIn, bool wait ) {
return true;
} else {
TDEIO::Job *job = TDEIO::listDir( url, false, true );
connect( job, TQT_SIGNAL( entries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ),
this, TQT_SLOT( slotEntries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ) );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( slotListResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( entries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ),
this, TQ_SLOT( slotEntries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( slotListResult( TDEIO::Job* ) ) );
busy = true;
if( !wait )

84
krusader/Synchronizer/synchronizergui.cpp
Unescape View File

@ -1475,50 +1475,50 @@ void SynchronizerGUI::initGUI(TQWidget* /* parent */, TQString profileName, KURL
/* =============================== Connect table ================================ */
connect( syncList,TQT_SIGNAL(rightButtonPressed(TQListViewItem *, const TQPoint &, int)),
this, TQT_SLOT(rightMouseClicked(TQListViewItem *)));
connect( syncList,TQT_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint &, int)),
this, TQT_SLOT(doubleClicked(TQListViewItem *)));
connect( syncList,TQ_SIGNAL(rightButtonPressed(TQListViewItem *, const TQPoint &, int)),
this, TQ_SLOT(rightMouseClicked(TQListViewItem *)));
connect( syncList,TQ_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint &, int)),
this, TQ_SLOT(doubleClicked(TQListViewItem *)));
connect( syncList,TQT_SIGNAL(contextMenuRequested(TQListViewItem *, const TQPoint &, int)),
this, TQT_SLOT(rightMouseClicked(TQListViewItem *)));
connect( syncList,TQ_SIGNAL(contextMenuRequested(TQListViewItem *, const TQPoint &, int)),
this, TQ_SLOT(rightMouseClicked(TQListViewItem *)));
connect( profileManager, TQT_SIGNAL( loadFromProfile( TQString ) ), this, TQT_SLOT( loadFromProfile( TQString ) ) );
connect( profileManager, TQT_SIGNAL( saveToProfile( TQString ) ), this, TQT_SLOT( saveToProfile( TQString ) ) );
connect( btnSwapSides, TQT_SIGNAL( clicked() ), this, TQT_SLOT( swapSides() ) );
connect( btnCompareDirs, TQT_SIGNAL( clicked() ), this, TQT_SLOT( compare() ) );
connect( btnStopComparing, TQT_SIGNAL( clicked() ), this, TQT_SLOT( stop() ) );
connect( btnFeedToListBox, TQT_SIGNAL( clicked() ), this, TQT_SLOT( feedToListBox() ) );
connect( btnSynchronize, TQT_SIGNAL( clicked() ), this, TQT_SLOT( synchronize() ) );
connect( btnScrollResults, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( setScrolling(bool) ) );
connect( btnCloseSync, TQT_SIGNAL( clicked() ), this, TQT_SLOT( closeDialog() ) );
connect( cbSubdirs, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( subdirsChecked( bool ) ) );
connect( cbAsymmetric, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( setPanelLabels() ) );
connect( &synchronizer, TQT_SIGNAL( comparedFileData( SynchronizerFileItem * ) ), this,
TQT_SLOT( addFile( SynchronizerFileItem * ) ) );
connect( &synchronizer, TQT_SIGNAL( markChanged( SynchronizerFileItem *, bool ) ), this,
TQT_SLOT( markChanged( SynchronizerFileItem *, bool ) ) );
connect( &synchronizer, TQT_SIGNAL( statusInfo( TQString ) ), this, TQT_SLOT( statusInfo( TQString ) ) );
connect( btnLeftToRight, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( refresh() ) );
connect( btnEquals, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( refresh() ) );
connect( btnDifferents, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( refresh() ) );
connect( btnRightToLeft, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( refresh() ) );
connect( btnDeletable, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( refresh() ) );
connect( btnDuplicates, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( refresh() ) );
connect( btnSingles, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( refresh() ) );
connect( fileFilter, TQT_SIGNAL( textChanged( const TQString & ) ), this, TQT_SLOT( connectFilters( const TQString & ) ) );
connect( generalFilter->searchFor, TQT_SIGNAL( textChanged( const TQString & ) ), this, TQT_SLOT( connectFilters( const TQString & ) ) );
connect( generalFilter->searchFor, TQT_SIGNAL( textChanged( const TQString & ) ), this, TQT_SLOT( setCompletion() ) );
connect( generalFilter->dontSearchIn, TQT_SIGNAL( checkValidity( TQString &, TQString & ) ),
this, TQT_SLOT( checkExcludeURLValidity( TQString &, TQString & ) ) );
connect( profileManager, TQT_SIGNAL( loadFromProfile( TQString ) ), filterTabs, TQT_SLOT( loadFromProfile( TQString ) ) );
connect( profileManager, TQT_SIGNAL( saveToProfile( TQString ) ), filterTabs, TQT_SLOT( saveToProfile( TQString ) ) );
connect( profileManager, TQ_SIGNAL( loadFromProfile( TQString ) ), this, TQ_SLOT( loadFromProfile( TQString ) ) );
connect( profileManager, TQ_SIGNAL( saveToProfile( TQString ) ), this, TQ_SLOT( saveToProfile( TQString ) ) );
connect( btnSwapSides, TQ_SIGNAL( clicked() ), this, TQ_SLOT( swapSides() ) );
connect( btnCompareDirs, TQ_SIGNAL( clicked() ), this, TQ_SLOT( compare() ) );
connect( btnStopComparing, TQ_SIGNAL( clicked() ), this, TQ_SLOT( stop() ) );
connect( btnFeedToListBox, TQ_SIGNAL( clicked() ), this, TQ_SLOT( feedToListBox() ) );
connect( btnSynchronize, TQ_SIGNAL( clicked() ), this, TQ_SLOT( synchronize() ) );
connect( btnScrollResults, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( setScrolling(bool) ) );
connect( btnCloseSync, TQ_SIGNAL( clicked() ), this, TQ_SLOT( closeDialog() ) );
connect( cbSubdirs, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( subdirsChecked( bool ) ) );
connect( cbAsymmetric, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( setPanelLabels() ) );
connect( &synchronizer, TQ_SIGNAL( comparedFileData( SynchronizerFileItem * ) ), this,
TQ_SLOT( addFile( SynchronizerFileItem * ) ) );
connect( &synchronizer, TQ_SIGNAL( markChanged( SynchronizerFileItem *, bool ) ), this,
TQ_SLOT( markChanged( SynchronizerFileItem *, bool ) ) );
connect( &synchronizer, TQ_SIGNAL( statusInfo( TQString ) ), this, TQ_SLOT( statusInfo( TQString ) ) );
connect( btnLeftToRight, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( refresh() ) );
connect( btnEquals, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( refresh() ) );
connect( btnDifferents, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( refresh() ) );
connect( btnRightToLeft, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( refresh() ) );
connect( btnDeletable, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( refresh() ) );
connect( btnDuplicates, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( refresh() ) );
connect( btnSingles, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( refresh() ) );
connect( fileFilter, TQ_SIGNAL( textChanged( const TQString & ) ), this, TQ_SLOT( connectFilters( const TQString & ) ) );
connect( generalFilter->searchFor, TQ_SIGNAL( textChanged( const TQString & ) ), this, TQ_SLOT( connectFilters( const TQString & ) ) );
connect( generalFilter->searchFor, TQ_SIGNAL( textChanged( const TQString & ) ), this, TQ_SLOT( setCompletion() ) );
connect( generalFilter->dontSearchIn, TQ_SIGNAL( checkValidity( TQString &, TQString & ) ),
this, TQ_SLOT( checkExcludeURLValidity( TQString &, TQString & ) ) );
connect( profileManager, TQ_SIGNAL( loadFromProfile( TQString ) ), filterTabs, TQ_SLOT( loadFromProfile( TQString ) ) );
connect( profileManager, TQ_SIGNAL( saveToProfile( TQString ) ), filterTabs, TQ_SLOT( saveToProfile( TQString ) ) );
setPanelLabels();
setCompletion();

26
krusader/Synchronizer/synchronizertask.cpp
Unescape View File

@ -72,12 +72,12 @@ void CompareTask::start() {
m_loadFinished = m_otherLoadFinished = false;
m_dirList = new SynchronizerDirList( parentWidget, ignoreHidden );
connect( m_dirList, TQT_SIGNAL( finished( bool ) ), this, TQT_SLOT( slotFinished( bool ) ));
connect( m_dirList, TQ_SIGNAL( finished( bool ) ), this, TQ_SLOT( slotFinished( bool ) ));
m_dirList->load( m_url, false );
if( m_duplicate ) {
m_otherDirList = new SynchronizerDirList( parentWidget, ignoreHidden );
connect( m_otherDirList, TQT_SIGNAL( finished( bool ) ), this, TQT_SLOT( slotOtherFinished( bool ) ));
connect( m_otherDirList, TQ_SIGNAL( finished( bool ) ), this, TQ_SLOT( slotOtherFinished( bool ) ));
m_otherDirList->load( m_otherUrl, false );
}
}
@ -144,7 +144,7 @@ void CompareContentTask::start() {
}
timer = new TQTimer( this );
connect( timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(sendStatusMessage()) );
connect( timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(sendStatusMessage()) );
timer->start( 1000, true );
localFileCompareCycle();
@ -152,19 +152,19 @@ void CompareContentTask::start() {
leftReadJob = TDEIO::get( leftURL, false, false );
rightReadJob = TDEIO::get( rightURL, false, false );
connect(leftReadJob, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(slotDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(rightReadJob, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(slotDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(leftReadJob, TQT_SIGNAL(result(TDEIO::Job*)),
this, TQT_SLOT(slotFinished(TDEIO::Job *)));
connect(rightReadJob, TQT_SIGNAL(result(TDEIO::Job*)),
this, TQT_SLOT(slotFinished(TDEIO::Job *)));
connect(leftReadJob, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(slotDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(rightReadJob, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(slotDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(leftReadJob, TQ_SIGNAL(result(TDEIO::Job*)),
this, TQ_SLOT(slotFinished(TDEIO::Job *)));
connect(rightReadJob, TQ_SIGNAL(result(TDEIO::Job*)),
this, TQ_SLOT(slotFinished(TDEIO::Job *)));
rightReadJob->suspend();
timer = new TQTimer( this );
connect( timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(sendStatusMessage()) );
connect( timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(sendStatusMessage()) );
timer->start( 1000, true );
}
}
@ -217,7 +217,7 @@ void CompareContentTask::localFileCompareCycle() {
return;
}
TQTimer::singleShot( 0, this, TQT_SLOT( localFileCompareCycle() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( localFileCompareCycle() ) );
}

18
krusader/UserAction/kraction.cpp
Unescape View File

@ -80,9 +80,9 @@ _stdout(0), _stderr(0), _currentTextEdit(0) {
}
_currentTextEdit = _stdout;
connect( _stdout, TQT_SIGNAL( clicked(int, int) ), TQT_SLOT( currentTextEditChanged() ) );
connect( _stdout, TQ_SIGNAL( clicked(int, int) ), TQ_SLOT( currentTextEditChanged() ) );
if (_stderr)
connect( _stderr, TQT_SIGNAL( clicked(int, int) ), TQT_SLOT( currentTextEditChanged() ) );
connect( _stderr, TQ_SIGNAL( clicked(int, int) ), TQ_SLOT( currentTextEditChanged() ) );
krConfig->setGroup( "UserActions" );
normalFont = krConfig->readFontEntry( "Normal Font", _UserActions_NormalFont );
@ -98,7 +98,7 @@ _stdout(0), _stderr(0), _currentTextEdit(0) {
TQCheckBox* useFixedFont = new TQCheckBox( i18n("Use font with fixed width"), buttonBox );
buttonBoxLayout->insertWidget( 0, useFixedFont );
useFixedFont->setChecked( startupState );
connect( useFixedFont, TQT_SIGNAL( toggled(bool) ), TQT_SLOT( toggleFixedFont(bool) ) );
connect( useFixedFont, TQ_SIGNAL( toggled(bool) ), TQ_SLOT( toggleFixedFont(bool) ) );
}
void KrActionProcDlg::addStderr( TDEProcess *, char *buffer, int buflen ) {
@ -176,8 +176,8 @@ void KrActionProcDlg::currentTextEditChanged() {
KrActionProc::KrActionProc( KrActionBase* action ) : TQObject(), _action( action ), _proc( new TDEProcess(this) ), _output( 0 ) {
_proc->setUseShell( true );
connect( _proc, TQT_SIGNAL( processExited( TDEProcess* ) ),
this, TQT_SLOT( processExited( TDEProcess* ) ) ) ;
connect( _proc, TQ_SIGNAL( processExited( TDEProcess* ) ),
this, TQ_SLOT( processExited( TDEProcess* ) ) ) ;
}
KrActionProc::~KrActionProc() {
@ -244,9 +244,9 @@ void KrActionProc::start( TQStringList cmdLineList ) {
separateStderr = true;
_output = new KrActionProcDlg( _action->text(), separateStderr );
// connect the output to the dialog
connect( _proc, TQT_SIGNAL( receivedStderr( TDEProcess*, char*, int ) ), _output, TQT_SLOT( addStderr( TDEProcess*, char *, int ) ) );
connect( _proc, TQT_SIGNAL( receivedStdout( TDEProcess*, char*, int ) ), _output, TQT_SLOT( addStdout( TDEProcess*, char *, int ) ) );
connect( _output, TQT_SIGNAL( cancelClicked() ), this, TQT_SLOT( kill() ) );
connect( _proc, TQ_SIGNAL( receivedStderr( TDEProcess*, char*, int ) ), _output, TQ_SLOT( addStderr( TDEProcess*, char *, int ) ) );
connect( _proc, TQ_SIGNAL( receivedStdout( TDEProcess*, char*, int ) ), _output, TQ_SLOT( addStdout( TDEProcess*, char *, int ) ) );
connect( _output, TQ_SIGNAL( cancelClicked() ), this, TQ_SLOT( kill() ) );
_output->show();
for ( TQStringList::Iterator it = cmdLineList.begin(); it != cmdLineList.end(); ++it) {
if ( ! cmd.isEmpty() )
@ -281,7 +281,7 @@ void KrActionProc::processExited( TDEProcess * ) {
//////////////////////////////////////////////////////////////////////////////////////////////////////
KrAction::KrAction( TDEActionCollection *parent, const char* name ) : TDEAction( parent, name ) {
connect(this, TQT_SIGNAL(activated()), this, TQT_SLOT(exec()) );
connect(this, TQ_SIGNAL(activated()), this, TQ_SLOT(exec()) );
}
KrAction::~KrAction() {

24
krusader/VFS/arc_vfs.cpp
Unescape View File

@ -284,9 +284,9 @@ void arc_vfs::vfs_addFiles(KURL::List *fileUrls,TDEIO::CopyJob::CopyMode mode,TQ
dest.setPath(tmpDir+path+dir);
TDEIO::Job* job = new TDEIO::CopyJob(*fileUrls,dest,mode,false,true);
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(vfs_refresh(TDEIO::Job*)) );
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(vfs_refresh(TDEIO::Job*)) );
if(mode == TDEIO::CopyJob::Move) // notify the other panel
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),toNotify,TQT_SLOT(vfs_refresh(TDEIO::Job*)) );
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),toNotify,TQ_SLOT(vfs_refresh(TDEIO::Job*)) );
}
@ -301,7 +301,7 @@ void arc_vfs::vfs_delFiles(TQStringList *fileNames){
changed = true;
TDEIO::Job *job = new TDEIO::CopyJob(*filesUrls,TDEGlobalSettings::trashPath(),TDEIO::CopyJob::Move,false,true );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(vfs_refresh(TDEIO::Job*)));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(vfs_refresh(TDEIO::Job*)));
}
// else we have to delete the files from both the archive and the temp dir
else {
@ -320,8 +320,8 @@ void arc_vfs::vfs_delFiles(TQStringList *fileNames){
KShellProcess proc1 , proc2;
krApp->startWaiting(i18n("Deleting Files..."),files.count()+ignoreLines);
connect(&proc1,TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
krApp, TQT_SLOT(incProgress(TDEProcess*,char*,int)) );
connect(&proc1,TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
krApp, TQ_SLOT(incProgress(TDEProcess*,char*,int)) );
proc1 << delCmd << "\""+arcFile+"\"";
proc2 << "rm -rf";
@ -395,8 +395,8 @@ KURL::List* arc_vfs::vfs_getFiles(TQStringList* names){
if ( files.count() > 0 ){
krApp->startWaiting(i18n("Unpacking Files"),files.count()+ignoreLines);
KShellProcess proc;
connect(&proc,TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
krApp, TQT_SLOT(incProgress(TDEProcess*,char*,int)) );
connect(&proc,TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
krApp, TQ_SLOT(incProgress(TDEProcess*,char*,int)) );
proc << cmd << getCmd << "\""+arcFile+"\"";
if( vfs_type == "gzip" || vfs_type == "zip2" ) proc << ">";
@ -444,7 +444,7 @@ void arc_vfs::vfs_rename(TQString fileName,TQString newName){
dest.setPath(tmpDir+path+"/"+newName);
TDEIO::Job* job = new TDEIO::CopyJob(temp,dest,TDEIO::CopyJob::Move,false,false);
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(vfs_refresh(TDEIO::Job*)) );
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(vfs_refresh(TDEIO::Job*)) );
}
bool arc_vfs::vfs_refresh(TQString origin){
@ -577,8 +577,8 @@ void arc_vfs::repack(){
if( !filesToDelete.isEmpty() ){
KShellProcess delProc;
krApp->startWaiting(i18n("Deleting Files..."),filesToDelete.count()+ignoreLines);
connect(&delProc,TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
krApp, TQT_SLOT(incProgress(TDEProcess*,char*,int)) );
connect(&delProc,TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
krApp, TQ_SLOT(incProgress(TDEProcess*,char*,int)) );
delProc << delCmd << "\""+arcFile+"\"";
for( unsigned int i=0 ; i < filesToDelete.count() ;){
@ -601,8 +601,8 @@ void arc_vfs::repack(){
if( !filesToPack.isEmpty() ){
KShellProcess addProc;
krApp->startWaiting(i18n("Repacking..."),filesToPack.count()+ignoreLines);
connect(&addProc,TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
krApp, TQT_SLOT(incProgress(TDEProcess*,char*,int)) );
connect(&addProc,TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
krApp, TQ_SLOT(incProgress(TDEProcess*,char*,int)) );
if( vfs_type=="gzip" || vfs_type=="zip2" ){
addProc << addCmd << *filesToPack.at(0)<< ">" << "\""+arcFile+"\"";

28
krusader/VFS/ftp_vfs.cpp
Unescape View File

@ -179,21 +179,21 @@ bool ftp_vfs::populateVfsList( const KURL& origin, bool showHidden ) {
vfs_origin = origin;
vfs_origin.adjustPath(-1);
//TQTimer::singleShot( 0,this,TQT_SLOT(startLister()) );
//TQTimer::singleShot( 0,this,TQ_SLOT(startLister()) );
listError = false;
// Open the directory marked by origin
krConfig->setGroup( "Look&Feel" );
//vfs_origin.adjustPath(+1);
TDEIO::Job *job = TDEIO::listDir( vfs_origin, false, showHidden );
connect( job, TQT_SIGNAL( entries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ),
this, TQT_SLOT( slotAddFiles( TDEIO::Job*, const TDEIO::UDSEntryList& ) ) );
connect( job, TQT_SIGNAL( redirection( TDEIO::Job*, const KURL& ) ),
this, TQT_SLOT( slotRedirection( TDEIO::Job*, const KURL& ) ) );
connect( job, TQT_SIGNAL( permanentRedirection( TDEIO::Job*, const KURL&, const KURL& ) ),
this, TQT_SLOT( slotPermanentRedirection( TDEIO::Job*, const KURL&, const KURL& ) ) );
connect( job, TQ_SIGNAL( entries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ),
this, TQ_SLOT( slotAddFiles( TDEIO::Job*, const TDEIO::UDSEntryList& ) ) );
connect( job, TQ_SIGNAL( redirection( TDEIO::Job*, const KURL& ) ),
this, TQ_SLOT( slotRedirection( TDEIO::Job*, const KURL& ) ) );
connect( job, TQ_SIGNAL( permanentRedirection( TDEIO::Job*, const KURL&, const KURL& ) ),
this, TQ_SLOT( slotPermanentRedirection( TDEIO::Job*, const KURL&, const KURL& ) ) );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( slotListResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( slotListResult( TDEIO::Job* ) ) );
job->setWindow( krApp );
@ -225,9 +225,9 @@ void ftp_vfs::vfs_addFiles( KURL::List *fileUrls, TDEIO::CopyJob::CopyMode mode,
}
TDEIO::Job* job = new TDEIO::CopyJob( *fileUrls, destUrl, mode, false, true );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( vfs_refresh( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( vfs_refresh( TDEIO::Job* ) ) );
if ( mode == TDEIO::CopyJob::Move ) // notify the other panel
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), toNotify, TQT_SLOT( vfs_refresh( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), toNotify, TQ_SLOT( vfs_refresh( TDEIO::Job* ) ) );
}
// remove a file from the vfs (physical)
@ -243,7 +243,7 @@ void ftp_vfs::vfs_delFiles( TQStringList *fileNames ) {
filesUrls.append( url );
}
TDEIO::Job *job = new TDEIO::DeleteJob( filesUrls, false, true );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( vfs_refresh( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( vfs_refresh( TDEIO::Job* ) ) );
}
@ -273,7 +273,7 @@ void ftp_vfs::vfs_mkdir( const TQString& name ) {
url.addPath( name );
TDEIO::SimpleJob* job = TDEIO::mkdir( url );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( vfs_refresh( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( vfs_refresh( TDEIO::Job* ) ) );
}
void ftp_vfs::vfs_rename( const TQString& fileName, const TQString& newName ) {
@ -287,7 +287,7 @@ void ftp_vfs::vfs_rename( const TQString& fileName, const TQString& newName ) {
newUrl.addPath( newName );
TDEIO::Job *job = new TDEIO::CopyJob( fileUrls, newUrl, TDEIO::CopyJob::Move, true, true );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( vfs_refresh( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( vfs_refresh( TDEIO::Job* ) ) );
}
TQString ftp_vfs::vfs_workingDir() {

16
krusader/VFS/krarchandler.cpp
Unescape View File

@ -323,11 +323,11 @@ bool KRarcHandler::unpack( TQString archive, TQString type, TQString password, T
// tell the user to wait
krApp->startWaiting( i18n( "Unpacking File(s)" ), count, true );
if ( count != 0 ) {
connect( &proc, TQT_SIGNAL( receivedStdout( TDEProcess*, char*, int ) ),
krApp, TQT_SLOT( incProgress( TDEProcess*, char*, int ) ) );
connect( &proc, TQ_SIGNAL( receivedStdout( TDEProcess*, char*, int ) ),
krApp, TQ_SLOT( incProgress( TDEProcess*, char*, int ) ) );
if( type == "-rpm" )
connect( &proc, TQT_SIGNAL( receivedStderr( TDEProcess*, char*, int ) ),
krApp, TQT_SLOT( incProgress( TDEProcess*, char*, int ) ) );
connect( &proc, TQ_SIGNAL( receivedStderr( TDEProcess*, char*, int ) ),
krApp, TQ_SLOT( incProgress( TDEProcess*, char*, int ) ) );
}
// start the unpacking process
@ -395,8 +395,8 @@ bool KRarcHandler::test( TQString archive, TQString type, TQString password, lon
// tell the user to wait
krApp->startWaiting( i18n( "Testing Archive" ), count, true );
if ( count != 0 ) connect( &proc, TQT_SIGNAL( receivedStdout( TDEProcess*, char*, int ) ),
krApp, TQT_SLOT( incProgress( TDEProcess*, char*, int ) ) );
if ( count != 0 ) connect( &proc, TQ_SIGNAL( receivedStdout( TDEProcess*, char*, int ) ),
krApp, TQ_SLOT( incProgress( TDEProcess*, char*, int ) ) );
// start the unpacking process
proc.start( TDEProcess::NotifyOnExit, TDEProcess::AllOutput );
@ -508,8 +508,8 @@ bool KRarcHandler::pack( TQStringList fileNames, TQString type, TQString dest, l
// tell the user to wait
krApp->startWaiting( i18n( "Packing File(s)" ), count, true );
if ( count != 0 )
connect( &proc, TQT_SIGNAL( receivedStdout( TDEProcess*, char*, int ) ),
krApp, TQT_SLOT( incProgress( TDEProcess*, char*, int ) ) );
connect( &proc, TQ_SIGNAL( receivedStdout( TDEProcess*, char*, int ) ),
krApp, TQ_SLOT( incProgress( TDEProcess*, char*, int ) ) );
// start the packing process
proc.start( TDEProcess::NotifyOnExit, TDEProcess::AllOutput );

12
krusader/VFS/krarchandler.h
Unescape View File

@ -74,10 +74,10 @@ class KrShellProcess : public KShellProcess {
public:
KrShellProcess() : KShellProcess(), errorMsg( TQString() ), outputMsg( TQString() ) {
connect(this,TQT_SIGNAL(receivedStderr(TDEProcess*,char*,int)),
this,TQT_SLOT(receivedErrorMsg(TDEProcess*,char*,int)) );
connect(this,TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
this,TQT_SLOT(receivedOutputMsg(TDEProcess*,char*,int)) );
connect(this,TQ_SIGNAL(receivedStderr(TDEProcess*,char*,int)),
this,TQ_SLOT(receivedErrorMsg(TDEProcess*,char*,int)) );
connect(this,TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
this,TQ_SLOT(receivedOutputMsg(TDEProcess*,char*,int)) );
}
TQString getErrorMsg() {
@ -112,8 +112,8 @@ class Kr7zEncryptionChecker : public KrShellProcess {
public:
Kr7zEncryptionChecker() : KrShellProcess(), encrypted( false ), lastData() {
connect(this,TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
this,TQT_SLOT(processStdout(TDEProcess*,char*,int)) );
connect(this,TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
this,TQ_SLOT(processStdout(TDEProcess*,char*,int)) );
}
public slots:

2
krusader/VFS/krdirwatch.cpp
Unescape View File

@ -39,7 +39,7 @@ KRdirWatch::KRdirWatch(int msec,bool dirOnly):
delay(msec),t(this), changed(false) {
if(dirOnly) dir.setFilter( TQDir::Dirs | TQDir::Hidden | TQDir::NoSymLinks );
watched.setAutoDelete(true);
connect(&t,TQT_SIGNAL(timeout()),this, TQT_SLOT(checkDirs()));
connect(&t,TQ_SIGNAL(timeout()),this, TQ_SLOT(checkDirs()));
startScan();
}

12
krusader/VFS/krquery.cpp
Unescape View File

@ -113,14 +113,14 @@ KRQuery& KRQuery::operator=(const KRQuery &old) {
void KRQuery::connectNotify ( const char * signal ) {
TQString signalString = TQString( signal ).replace( " ", "" );
TQString processString = TQString( TQT_SIGNAL( processEvents( bool & ) ) ).replace( " ", "" );
TQString processString = TQString( TQ_SIGNAL( processEvents( bool & ) ) ).replace( " ", "" );
if( signalString == processString )
processEventsConnected++;
}
void KRQuery::disconnectNotify ( const char * signal ) {
TQString signalString = TQString( signal ).replace( " ", "" );
TQString processString = TQString( TQT_SIGNAL( processEvents( bool & ) ) ).replace( " ", "" );
TQString processString = TQString( TQ_SIGNAL( processEvents( bool & ) ) ).replace( " ", "" );
if( signalString == processString )
processEventsConnected--;
}
@ -410,10 +410,10 @@ bool KRQuery::containsContent( TQString file ) const
bool KRQuery::containsContent( KURL url ) const
{
TDEIO::TransferJob *contentReader = TDEIO::get( url, false, false );
connect(contentReader, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(containsContentData(TDEIO::Job *, const TQByteArray &)));
connect(contentReader, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT(containsContentFinished( TDEIO::Job* ) ) );
connect(contentReader, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(containsContentData(TDEIO::Job *, const TQByteArray &)));
connect(contentReader, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT(containsContentFinished( TDEIO::Job* ) ) );
busy = true;
containsContentResult = false;

24
krusader/VFS/normal_vfs.cpp
Unescape View File

@ -131,9 +131,9 @@ bool normal_vfs::populateVfsList(const KURL& origin, bool showHidden){
{
watcher = new KDirWatch();
// connect the watcher
connect(watcher,TQT_SIGNAL(dirty(const TQString&)),this,TQT_SLOT(vfs_slotDirty(const TQString&)));
connect(watcher,TQT_SIGNAL(created(const TQString&)),this, TQT_SLOT(vfs_slotCreated(const TQString&)));
connect(watcher,TQT_SIGNAL(deleted(const TQString&)),this, TQT_SLOT(vfs_slotDeleted(const TQString&)));
connect(watcher,TQ_SIGNAL(dirty(const TQString&)),this,TQ_SLOT(vfs_slotDirty(const TQString&)));
connect(watcher,TQ_SIGNAL(created(const TQString&)),this, TQ_SLOT(vfs_slotCreated(const TQString&)));
connect(watcher,TQ_SIGNAL(deleted(const TQString&)),this, TQ_SLOT(vfs_slotDeleted(const TQString&)));
watcher->addDir(vfs_getOrigin().path(-1),true); //start watching the new dir
watcher->startScan(true);
}
@ -153,9 +153,9 @@ void normal_vfs::vfs_addFiles(KURL::List *fileUrls,TDEIO::CopyJob::CopyMode mode
dest.setPath(vfs_workingDir()+"/"+dir);
TDEIO::Job* job = PreservingCopyJob::createCopyJob( pmode, *fileUrls,dest,mode,false,true );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(vfs_refresh()) );
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(vfs_refresh()) );
if(mode == TDEIO::CopyJob::Move) // notify the other panel
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),toNotify,TQT_SLOT(vfs_refresh(TDEIO::Job*)) );
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),toNotify,TQ_SLOT(vfs_refresh(TDEIO::Job*)) );
else
job->setAutoErrorHandlingEnabled( true );
}
@ -190,12 +190,12 @@ void normal_vfs::vfs_delFiles(TQStringList *fileNames){
#else
job = new TDEIO::CopyJob(filesUrls,TDEGlobalSettings::trashPath(),TDEIO::CopyJob::Move,false,true );
#endif
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),SLOTS,TQT_SLOT(changeTrashIcon()));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),SLOTS,TQ_SLOT(changeTrashIcon()));
}
else
job = new TDEIO::DeleteJob(filesUrls, false, true);
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(vfs_refresh(TDEIO::Job*)));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(vfs_refresh(TDEIO::Job*)));
}
// return a path to the file
@ -236,7 +236,7 @@ void normal_vfs::vfs_rename(const TQString& fileName,const TQString& newName){
dest.setPath(vfs_workingDir()+"/"+newName);
TDEIO::Job *job = new TDEIO::CopyJob(fileUrls,dest,TDEIO::CopyJob::Move,true,false );
connect(job,TQT_SIGNAL(result(TDEIO::Job*)),this,TQT_SLOT(vfs_refresh(TDEIO::Job*)));
connect(job,TQ_SIGNAL(result(TDEIO::Job*)),this,TQ_SLOT(vfs_refresh(TDEIO::Job*)));
}
vfile* normal_vfs::vfileFromName(const TQString& name){
@ -352,7 +352,7 @@ void normal_vfs::vfs_slotRefresh()
krConfig->setGroup("Advanced");
int maxRefreshFrequency = krConfig->readNumEntry("Max Refresh Frequency", 1000);
vfs_refresh();
disconnect( &refreshTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( vfs_slotRefresh() ) );
disconnect( &refreshTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( vfs_slotRefresh() ) );
refreshTimer.start( maxRefreshFrequency, true );
}
@ -360,11 +360,11 @@ bool normal_vfs::burstRefresh(const TQString& path ){
if( path == vfs_getOrigin().path(-1) ) {
if( !refreshTimer.isActive() ) {
// the directory itself is dirty - full refresh is needed
TQTimer::singleShot(0, this, TQT_SLOT( vfs_slotRefresh() ) ); // safety: dirty signal comes from KDirWatch!
TQTimer::singleShot(0, this, TQ_SLOT( vfs_slotRefresh() ) ); // safety: dirty signal comes from KDirWatch!
return true;
}
disconnect( &refreshTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( vfs_slotRefresh() ) );
connect( &refreshTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( vfs_slotRefresh() ) );
disconnect( &refreshTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( vfs_slotRefresh() ) );
connect( &refreshTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( vfs_slotRefresh() ) );
postponedRefreshURL = fromPathOrURL(path);
return true;
}

20
krusader/VFS/preservingcopyjob.cpp
Unescape View File

@ -82,12 +82,12 @@ PreservingCopyJob::PreservingCopyJob( const KURL::List& src, const KURL& dest, C
{
if( dest.isLocalFile() )
{
connect( this, TQT_SIGNAL( aboutToCreate (TDEIO::Job *, const TQValueList< TDEIO::CopyInfo > &) ),
this, TQT_SLOT( slotAboutToCreate (TDEIO::Job *, const TQValueList< TDEIO::CopyInfo > &) ) );
connect( this, TQT_SIGNAL( copyingDone( TDEIO::Job *, const KURL &, const KURL &, bool, bool) ),
this, TQT_SLOT( slotCopyingDone( TDEIO::Job *, const KURL &, const KURL &, bool, bool) ) );
connect( this, TQT_SIGNAL( result( TDEIO::Job * ) ),
this, TQT_SLOT( slotFinished() ) );
connect( this, TQ_SIGNAL( aboutToCreate (TDEIO::Job *, const TQValueList< TDEIO::CopyInfo > &) ),
this, TQ_SLOT( slotAboutToCreate (TDEIO::Job *, const TQValueList< TDEIO::CopyInfo > &) ) );
connect( this, TQ_SIGNAL( copyingDone( TDEIO::Job *, const KURL &, const KURL &, bool, bool) ),
this, TQ_SLOT( slotCopyingDone( TDEIO::Job *, const KURL &, const KURL &, bool, bool) ) );
connect( this, TQ_SIGNAL( result( TDEIO::Job * ) ),
this, TQ_SLOT( slotFinished() ) );
}
}
@ -173,10 +173,10 @@ void PreservingCopyJob::slotResult( Job *job ) {
for( unsigned j=0; j != subjobs.count(); j++ ) {
if( subjobs.at( j )->inherits( "TDEIO::ListJob" ) ) {
disconnect( subjobs.at( j ), TQT_SIGNAL( entries (TDEIO::Job *, const TDEIO::UDSEntryList &) ),
this, TQT_SLOT( slotListEntries (TDEIO::Job *, const TDEIO::UDSEntryList &) ) );
connect( subjobs.at( j ), TQT_SIGNAL( entries (TDEIO::Job *, const TDEIO::UDSEntryList &) ),
this, TQT_SLOT( slotListEntries (TDEIO::Job *, const TDEIO::UDSEntryList &) ) );
disconnect( subjobs.at( j ), TQ_SIGNAL( entries (TDEIO::Job *, const TDEIO::UDSEntryList &) ),
this, TQ_SLOT( slotListEntries (TDEIO::Job *, const TDEIO::UDSEntryList &) ) );
connect( subjobs.at( j ), TQ_SIGNAL( entries (TDEIO::Job *, const TDEIO::UDSEntryList &) ),
this, TQ_SLOT( slotListEntries (TDEIO::Job *, const TDEIO::UDSEntryList &) ) );
}
}
}

8
krusader/VFS/vfs.cpp
Unescape View File

@ -49,8 +49,8 @@ vfs::vfs(TQObject* panel, bool quiet): vfs_busy(false), quietMode(quiet),disable
setVfsFilesP( new vfileDict() );
if ( panel ){
panelConnected = true;
connect(this,TQT_SIGNAL(startUpdate()),panel,TQT_SLOT(slotStartUpdate()));
connect(this,TQT_SIGNAL(incrementalRefreshFinished( const KURL& )),panel,TQT_SLOT(slotGetStats( const KURL& )));
connect(this,TQ_SIGNAL(startUpdate()),panel,TQ_SLOT(slotStartUpdate()));
connect(this,TQ_SIGNAL(incrementalRefreshFinished( const KURL& )),panel,TQ_SLOT(slotGetStats( const KURL& )));
}
else quietMode = true;
}
@ -316,7 +316,7 @@ void vfs::calculateURLSize( KURL url, TDEIO::filesize_t* totalSize, unsigned lo
} else {
stat_busy = true;
TDEIO::StatJob* statJob = TDEIO::stat( url, false );
connect( statJob, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotStatResultArrived( TDEIO::Job* ) ) );
connect( statJob, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotStatResultArrived( TDEIO::Job* ) ) );
while ( !(*stop) && stat_busy ) {usleep(1000);}
if( entry.isEmpty() ) return; // statJob failed
KFileItem kfi(entry, url, true );
@ -328,7 +328,7 @@ void vfs::calculateURLSize( KURL url, TDEIO::filesize_t* totalSize, unsigned lo
}
KDirSize* kds = KDirSize::dirSizeJob( url );
connect( kds, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotKdsResult( TDEIO::Job* ) ) );
connect( kds, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotKdsResult( TDEIO::Job* ) ) );
while ( !(*stop) ){
// we are in a sepetate thread - so sleeping is OK
usleep(1000);

8
krusader/VFS/virt_vfs.cpp
Unescape View File

@ -126,12 +126,12 @@ void virt_vfs::vfs_delFiles( TQStringList *fileNames ) {
#else
job = new TDEIO::CopyJob( filesUrls, TDEGlobalSettings::trashPath(), TDEIO::CopyJob::Move, false, true );
#endif
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), krApp, TQT_SLOT( changeTrashIcon() ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), krApp, TQ_SLOT( changeTrashIcon() ) );
} else
job = new TDEIO::DeleteJob( filesUrls, false, true );
// refresh will remove the deleted files...
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( vfs_refresh( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( vfs_refresh( TDEIO::Job* ) ) );
}
void virt_vfs::vfs_removeFiles( TQStringList *fileNames ) {
@ -205,7 +205,7 @@ void virt_vfs::vfs_rename( const TQString& fileName, const TQString& newName ) {
virtVfsDict[ path ] ->append( dest );
TDEIO::Job *job = new TDEIO::CopyJob( fileUrls, dest, TDEIO::CopyJob::Move, true, false );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( vfs_refresh( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( vfs_refresh( TDEIO::Job* ) ) );
}
void virt_vfs::slotStatResult( TDEIO::Job* job ) {
@ -229,7 +229,7 @@ vfile* virt_vfs::stat( const KURL& url ) {
else {
busy = true;
TDEIO::StatJob* statJob = TDEIO::stat( url, false );
connect( statJob, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotStatResult( TDEIO::Job* ) ) );
connect( statJob, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotStatResult( TDEIO::Job* ) ) );
while ( busy && vfs_processEvents() );
if( entry.isEmpty() ) return 0; // statJob failed

60
krusader/VFS/virtualcopyjob.cpp
Unescape View File

@ -83,19 +83,19 @@ VirtualCopyJob::VirtualCopyJob( const TQStringList *names, vfs * vfs, const KURL
}
if ( showProgressInfo ) {
connect( this, TQT_SIGNAL( totalFiles( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQT_SLOT( slotTotalFiles( TDEIO::Job*, unsigned long ) ) );
connect( this, TQT_SIGNAL( totalDirs( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQT_SLOT( slotTotalDirs( TDEIO::Job*, unsigned long ) ) );
connect( this, TQT_SIGNAL( processedFiles( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQT_SLOT( slotProcessedFiles( TDEIO::Job*, unsigned long ) ) );
connect( this, TQT_SIGNAL( processedDirs( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQT_SLOT( slotProcessedDirs( TDEIO::Job*, unsigned long ) ) );
connect( this, TQT_SIGNAL( percent( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQT_SLOT( slotPercent( TDEIO::Job*, unsigned long ) ) );
connect( this, TQ_SIGNAL( totalFiles( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQ_SLOT( slotTotalFiles( TDEIO::Job*, unsigned long ) ) );
connect( this, TQ_SIGNAL( totalDirs( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQ_SLOT( slotTotalDirs( TDEIO::Job*, unsigned long ) ) );
connect( this, TQ_SIGNAL( processedFiles( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQ_SLOT( slotProcessedFiles( TDEIO::Job*, unsigned long ) ) );
connect( this, TQ_SIGNAL( processedDirs( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQ_SLOT( slotProcessedDirs( TDEIO::Job*, unsigned long ) ) );
connect( this, TQ_SIGNAL( percent( TDEIO::Job*, unsigned long ) ),
Observer::self(), TQ_SLOT( slotPercent( TDEIO::Job*, unsigned long ) ) );
}
TQTimer::singleShot( 0, this, TQT_SLOT( slotStart() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( slotStart() ) );
}
void VirtualCopyJob::slotStart() {
@ -106,7 +106,7 @@ void VirtualCopyJob::slotStart() {
Observer::self()->slotCopying( this, m_baseURL, m_dest );
}
connect(&m_reportTimer,TQT_SIGNAL(timeout()),this,TQT_SLOT(slotReport()));
connect(&m_reportTimer,TQ_SIGNAL(timeout()),this,TQ_SLOT(slotReport()));
m_reportTimer.start(REPORT_TIMEOUT,false);
statNextDir();
@ -158,7 +158,7 @@ void VirtualCopyJob::statNextDir() {
m_currentDir = KURL::relativeURL( m_baseURL, dirToCheck.upURL() );
KDirSize* kds = KDirSize::dirSizeJob( dirToCheck );
connect( kds, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotKdsResult( TDEIO::Job* ) ) );
connect( kds, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotKdsResult( TDEIO::Job* ) ) );
}
void VirtualCopyJob::slotKdsResult( TDEIO::Job * job ) {
@ -189,7 +189,7 @@ void VirtualCopyJob::createNextDir() {
m_current.addPath( m_currentDir );
TDEIO::Job *job = TDEIO::stat( m_current );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotStatResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotStatResult( TDEIO::Job* ) ) );
}
void VirtualCopyJob::slotStatResult( TDEIO::Job *job ) {
@ -199,7 +199,7 @@ void VirtualCopyJob::slotStatResult( TDEIO::Job *job ) {
if( job->error() == TDEIO::ERR_DOES_NOT_EXIST && !url.equals( url.upURL(),true ) ) {
m_dirStack.push_back( url.fileName() );
TDEIO::Job *job = TDEIO::stat( url.upURL() );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotStatResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotStatResult( TDEIO::Job* ) ) );
return;
}
job->showErrorDialog( krApp );
@ -214,7 +214,7 @@ void VirtualCopyJob::slotStatResult( TDEIO::Job *job ) {
m_dirStack.pop_back();
TDEIO::Job *mkdir_job = TDEIO::mkdir( url );
connect( mkdir_job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotMkdirResult( TDEIO::Job* ) ) );
connect( mkdir_job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotMkdirResult( TDEIO::Job* ) ) );
}
else
copyCurrentDir();
@ -236,7 +236,7 @@ void VirtualCopyJob::slotMkdirResult( TDEIO::Job *job ) {
m_dirStack.pop_back();
TDEIO::Job *mkdir_job = TDEIO::mkdir( url );
connect( mkdir_job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotMkdirResult( TDEIO::Job* ) ) );
connect( mkdir_job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotMkdirResult( TDEIO::Job* ) ) );
}
else
copyCurrentDir();
@ -248,19 +248,19 @@ void VirtualCopyJob::copyCurrentDir() {
TDEIO::CopyJob * copy_job = PreservingCopyJob::createCopyJob( m_pmode, *m_filesToCopy[ m_currentDir ], m_current,
m_mode, m_asMethod, false );
connect( copy_job, TQT_SIGNAL( copying(TDEIO::Job *, const KURL &, const KURL &) ),
this, TQT_SLOT( slotCopying(TDEIO::Job *, const KURL &, const KURL &) ) );
connect( copy_job, TQT_SIGNAL( moving(TDEIO::Job *, const KURL &, const KURL &) ),
this, TQT_SLOT( slotMoving(TDEIO::Job *, const KURL &, const KURL &) ) );
connect( copy_job, TQT_SIGNAL( creatingDir(TDEIO::Job *, const KURL &) ),
this, TQT_SLOT( slotCreatingDir(TDEIO::Job *, const KURL &) ) );
connect( copy_job, TQT_SIGNAL( processedFiles (TDEIO::Job *, unsigned long) ),
this, TQT_SLOT( slotProcessedFiles (TDEIO::Job *, unsigned long) ) );
connect( copy_job, TQT_SIGNAL( processedDirs (TDEIO::Job *, unsigned long) ),
this, TQT_SLOT( slotProcessedDirs (TDEIO::Job *, unsigned long) ) );
connect( copy_job, TQT_SIGNAL( processedSize (TDEIO::Job *, TDEIO::filesize_t) ),
this, TQT_SLOT( slotProcessedSize (TDEIO::Job *, TDEIO::filesize_t) ) );
connect( copy_job, TQT_SIGNAL( result( TDEIO::Job* ) ), this, TQT_SLOT( slotCopyResult( TDEIO::Job* ) ) );
connect( copy_job, TQ_SIGNAL( copying(TDEIO::Job *, const KURL &, const KURL &) ),
this, TQ_SLOT( slotCopying(TDEIO::Job *, const KURL &, const KURL &) ) );
connect( copy_job, TQ_SIGNAL( moving(TDEIO::Job *, const KURL &, const KURL &) ),
this, TQ_SLOT( slotMoving(TDEIO::Job *, const KURL &, const KURL &) ) );
connect( copy_job, TQ_SIGNAL( creatingDir(TDEIO::Job *, const KURL &) ),
this, TQ_SLOT( slotCreatingDir(TDEIO::Job *, const KURL &) ) );
connect( copy_job, TQ_SIGNAL( processedFiles (TDEIO::Job *, unsigned long) ),
this, TQ_SLOT( slotProcessedFiles (TDEIO::Job *, unsigned long) ) );
connect( copy_job, TQ_SIGNAL( processedDirs (TDEIO::Job *, unsigned long) ),
this, TQ_SLOT( slotProcessedDirs (TDEIO::Job *, unsigned long) ) );
connect( copy_job, TQ_SIGNAL( processedSize (TDEIO::Job *, TDEIO::filesize_t) ),
this, TQ_SLOT( slotProcessedSize (TDEIO::Job *, TDEIO::filesize_t) ) );
connect( copy_job, TQ_SIGNAL( result( TDEIO::Job* ) ), this, TQ_SLOT( slotCopyResult( TDEIO::Job* ) ) );
}
void VirtualCopyJob::slotCopyResult( TDEIO::Job *job ) {

8
krusader/krservices.cpp
Unescape View File

@ -201,10 +201,10 @@ KEasyProcess::KEasyProcess(): TDEProcess() {
}
void KEasyProcess::init() {
connect(this, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(receivedStdout(TDEProcess *, char *, int)));
connect(this, TQT_SIGNAL(receivedStderr(TDEProcess *, char *, int)),
this, TQT_SLOT(receivedStderr(TDEProcess *, char *, int)));
connect(this, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQ_SLOT(receivedStdout(TDEProcess *, char *, int)));
connect(this, TQ_SIGNAL(receivedStderr(TDEProcess *, char *, int)),
this, TQ_SLOT(receivedStderr(TDEProcess *, char *, int)));
}
void KEasyProcess::receivedStdout (TDEProcess * /* proc */, char *buffer, int buflen) {

226
krusader/krusader.cpp
Unescape View File

@ -370,7 +370,7 @@ Krusader::Krusader() : KParts::MainWindow(0,0,WType_TopLevel|WDestructiveClose|T
sysTray->setPixmap( iconLoader->loadIcon( privIcon(), TDEIcon::Panel, 22 ) );
sysTray->hide();
connect( sysTray, TQT_SIGNAL( quitSelected() ), this, TQT_SLOT( setDirectExit() ) );
connect( sysTray, TQ_SIGNAL( quitSelected() ), this, TQ_SLOT( setDirectExit() ) );
setCentralWidget( mainView );
config->setGroup( "Startup" );
@ -536,10 +536,10 @@ void Krusader::setupAccels() {
accels = new TDEAccel( this );
// SHIFT+F3
accels->insert( "F3_ViewDlg", i18n( "F3 View Dialog" ), TQString(),
SHIFT + Key_F3, SLOTS, TQT_SLOT( viewDlg() ) );
SHIFT + Key_F3, SLOTS, TQ_SLOT( viewDlg() ) );
// Tab
accels->insert( "Tab-Switch panel", i18n( "Tab: switch panel" ), TQString(),
Key_Tab, mainView, TQT_SLOT( panelSwitch() ) );
Key_Tab, mainView, TQ_SLOT( panelSwitch() ) );
}
@ -550,110 +550,110 @@ void Krusader::setupActions() {
//actNewTool = 0;//new TDEAction(i18n("&Add a new tool"), 0, this, 0, actionCollection(), "add tool");
//actToolsSetup = 0;//new TDEAction(i18n("&Tools Menu Setup"), 0, 0, this, 0, actionCollection(), "tools setup");
//KStdAction::print(SLOTS, 0,actionCollection(),"std_print");
//KStdAction::showMenubar( SLOTS, TQT_SLOT( showMenubar() ), actionCollection(), "std_menubar" );
//KStdAction::showMenubar( SLOTS, TQ_SLOT( showMenubar() ), actionCollection(), "std_menubar" );
// second, the TDE standard action
//KStdAction::up( SLOTS, TQT_SLOT( dirUp() ), actionCollection(), "std_up" )->setShortcut(Key_Backspace);
//KStdAction::up( SLOTS, TQ_SLOT( dirUp() ), actionCollection(), "std_up" )->setShortcut(Key_Backspace);
/* Shortcut disabled because of the Terminal Emulator bug. */
krConfig->setGroup( "Private" );
int compareMode = krConfig->readNumEntry( "Compare Mode", 0 );
int cmdExecMode = krConfig->readNumEntry( "Command Execution Mode", 0 );
KStdAction::home( SLOTS, TQT_SLOT( home() ), actionCollection(), "std_home" )->setText( i18n("Home") ); /*->setShortcut(Key_QuoteLeft);*/
new TDEAction( i18n( "&Reload" ), "reload", CTRL + Key_R, SLOTS, TQT_SLOT( refresh() ), actionCollection(), "std_redisplay" );
actShowToolBar = KStdAction::showToolbar( SLOTS, TQT_SLOT( toggleToolbar() ), actionCollection(), "std_toolbar" );
new TDEToggleAction( i18n("Show Actions Toolbar"), 0, SLOTS, TQT_SLOT( toggleActionsToolbar() ),
KStdAction::home( SLOTS, TQ_SLOT( home() ), actionCollection(), "std_home" )->setText( i18n("Home") ); /*->setShortcut(Key_QuoteLeft);*/
new TDEAction( i18n( "&Reload" ), "reload", CTRL + Key_R, SLOTS, TQ_SLOT( refresh() ), actionCollection(), "std_redisplay" );
actShowToolBar = KStdAction::showToolbar( SLOTS, TQ_SLOT( toggleToolbar() ), actionCollection(), "std_toolbar" );
new TDEToggleAction( i18n("Show Actions Toolbar"), 0, SLOTS, TQ_SLOT( toggleActionsToolbar() ),
actionCollection(), "toggle actions toolbar" );
actShowStatusBar = KStdAction::showStatusbar( SLOTS, TQT_SLOT( toggleStatusbar() ), actionCollection(), "std_statusbar" );
KStdAction::quit( this, TQT_SLOT( slotClose() ), actionCollection(), "std_quit" );
KStdAction::configureToolbars( SLOTS, TQT_SLOT( configToolbar() ), actionCollection(), "std_config_toolbar" );
KStdAction::keyBindings( SLOTS, TQT_SLOT( configKeys() ), actionCollection(), "std_config_keys" );
actShowStatusBar = KStdAction::showStatusbar( SLOTS, TQ_SLOT( toggleStatusbar() ), actionCollection(), "std_statusbar" );
KStdAction::quit( this, TQ_SLOT( slotClose() ), actionCollection(), "std_quit" );
KStdAction::configureToolbars( SLOTS, TQ_SLOT( configToolbar() ), actionCollection(), "std_config_toolbar" );
KStdAction::keyBindings( SLOTS, TQ_SLOT( configKeys() ), actionCollection(), "std_config_keys" );
KStdAction::cut( SLOTS, TQT_SLOT( cut() ), actionCollection(), "std_cut" )->setText( i18n("Cut to Clipboard") );
(actCopy = KStdAction::copy( SLOTS, TQT_SLOT( copy() ), actionCollection(), "std_copy" ))->setText( i18n("Copy to Clipboard") );
(actPaste = KStdAction::paste( SLOTS, TQT_SLOT( paste() ), actionCollection(), "std_paste" ))->setText( i18n("Paste from Clipboard") );
KStdAction::cut( SLOTS, TQ_SLOT( cut() ), actionCollection(), "std_cut" )->setText( i18n("Cut to Clipboard") );
(actCopy = KStdAction::copy( SLOTS, TQ_SLOT( copy() ), actionCollection(), "std_copy" ))->setText( i18n("Copy to Clipboard") );
(actPaste = KStdAction::paste( SLOTS, TQ_SLOT( paste() ), actionCollection(), "std_paste" ))->setText( i18n("Paste from Clipboard") );
// the toggle actions
actToggleFnkeys = new TDEToggleAction( i18n( "Show &FN Keys Bar" ), 0, SLOTS,
TQT_SLOT( toggleFnkeys() ), actionCollection(), "toggle fn bar" );
TQ_SLOT( toggleFnkeys() ), actionCollection(), "toggle fn bar" );
actToggleFnkeys->setChecked( true );
actToggleCmdline = new TDEToggleAction( i18n( "Show &Command Line" ), 0, SLOTS,
TQT_SLOT( toggleCmdline() ), actionCollection(), "toggle command line" );
TQ_SLOT( toggleCmdline() ), actionCollection(), "toggle command line" );
actToggleCmdline->setChecked( true );
actToggleTerminal = new TDEToggleAction( i18n( "Show Terminal &Emulator" ), ALT + CTRL + Key_T, SLOTS,
TQT_SLOT( toggleTerminal() ), actionCollection(), "toggle terminal emulator" );
TQ_SLOT( toggleTerminal() ), actionCollection(), "toggle terminal emulator" );
actToggleTerminal->setChecked( false );
actDetailedView = new TDEAction( i18n( "&Detailed View" ), ALT + SHIFT + Key_D, SLOTS,
TQT_SLOT( setDetailedView() ), actionCollection(), "detailed_view" );
TQ_SLOT( setDetailedView() ), actionCollection(), "detailed_view" );
actBriefView = new TDEAction( i18n( "&Brief View" ), ALT + SHIFT + Key_B, SLOTS,
TQT_SLOT( setBriefView() ), actionCollection(), "brief_view" );
TQ_SLOT( setBriefView() ), actionCollection(), "brief_view" );
actToggleHidden = new TDEToggleAction( i18n( "Show &Hidden Files" ), CTRL + Key_Period, SLOTS,
TQT_SLOT( toggleHidden() ), actionCollection(), "toggle hidden files" );
TQ_SLOT( toggleHidden() ), actionCollection(), "toggle hidden files" );
actSwapPanels = new TDEAction( i18n( "S&wap Panels" ), CTRL + Key_U, SLOTS,
TQT_SLOT( swapPanels() ), actionCollection(), "swap panels" );
TQ_SLOT( swapPanels() ), actionCollection(), "swap panels" );
actSwapSides = new TDEAction( i18n( "Sw&ap Sides" ), CTRL + SHIFT + Key_U, SLOTS,
TQT_SLOT( toggleSwapSides() ), actionCollection(), "toggle swap sides" );
TQ_SLOT( toggleSwapSides() ), actionCollection(), "toggle swap sides" );
krConfig->setGroup( "Look&Feel" );
actToggleHidden->setChecked( krConfig->readBoolEntry( "Show Hidden", _ShowHidden ) );
// and then the DONE actions
actCmdlinePopup = new TDEAction( i18n( "popup cmdline" ), 0, CTRL + Key_Slash, SLOTS,
TQT_SLOT( cmdlinePopup() ), actionCollection(), "cmdline popup" );
TQ_SLOT( cmdlinePopup() ), actionCollection(), "cmdline popup" );
/* Shortcut disabled because of the Terminal Emulator bug. */
actDirUp = new TDEAction( i18n( "Up" ), "go-up", CTRL+Key_PageUp /*Key_Backspace*/, SLOTS, TQT_SLOT( dirUp() ), actionCollection(), "dirUp" );
new TDEAction( i18n( "&New Text File..." ), "document-new", SHIFT + Key_F4, SLOTS, TQT_SLOT( editDlg() ), actionCollection(), "edit_new_file" );
new TDEAction( i18n( "Start &Root Mode Krusader" ), "krusader_root", ALT + Key_K, SLOTS, TQT_SLOT( rootKrusader() ), actionCollection(), "root krusader" );
actDirUp = new TDEAction( i18n( "Up" ), "go-up", CTRL+Key_PageUp /*Key_Backspace*/, SLOTS, TQ_SLOT( dirUp() ), actionCollection(), "dirUp" );
new TDEAction( i18n( "&New Text File..." ), "document-new", SHIFT + Key_F4, SLOTS, TQ_SLOT( editDlg() ), actionCollection(), "edit_new_file" );
new TDEAction( i18n( "Start &Root Mode Krusader" ), "krusader_root", ALT + Key_K, SLOTS, TQ_SLOT( rootKrusader() ), actionCollection(), "root krusader" );
actTest = new TDEAction( i18n( "T&est Archive" ), "ark", ALT + Key_E,
SLOTS, TQT_SLOT( testArchive() ), actionCollection(), "test archives" );
SLOTS, TQ_SLOT( testArchive() ), actionCollection(), "test archives" );
//actFTPConnect = new TDEAction( i18n( "&Net Connections" ), "domtreeviewer", 0,
// SLOTS, TQT_SLOT( runRemoteMan() ), actionCollection(), "ftp connect" );
// SLOTS, TQ_SLOT( runRemoteMan() ), actionCollection(), "ftp connect" );
actFTPNewConnect = new TDEAction( i18n( "New Net &Connection..." ), "connect_creating", CTRL + Key_N,
SLOTS, TQT_SLOT( newFTPconnection() ), actionCollection(), "ftp new connection" );
SLOTS, TQ_SLOT( newFTPconnection() ), actionCollection(), "ftp new connection" );
actProfiles = new TDEAction( i18n( "Pro&files" ), "kr_profile", ALT + Key_L,
MAIN_VIEW, TQT_SLOT( profiles() ), actionCollection(), "profile" );
MAIN_VIEW, TQ_SLOT( profiles() ), actionCollection(), "profile" );
actCalculate = new TDEAction( i18n( "Calculate &Occupied Space" ), "kcalc", 0,
SLOTS, TQT_SLOT( calcSpace() ), actionCollection(), "calculate" );
SLOTS, TQ_SLOT( calcSpace() ), actionCollection(), "calculate" );
actCreateChecksum = new TDEAction( i18n( "Create Checksum..." ), "application-octet-stream", 0,
SLOTS, TQT_SLOT( createChecksum() ), actionCollection(), "create checksum" );
SLOTS, TQ_SLOT( createChecksum() ), actionCollection(), "create checksum" );
actMatchChecksum = new TDEAction( i18n( "Verify Checksum..." ), "match_checksum", 0,
SLOTS, TQT_SLOT( matchChecksum() ), actionCollection(), "match checksum" );
SLOTS, TQ_SLOT( matchChecksum() ), actionCollection(), "match checksum" );
actProperties = new TDEAction( i18n( "&Properties..." ), "edit", ALT+Key_Enter,
SLOTS, TQT_SLOT( properties() ), actionCollection(), "properties" );
SLOTS, TQ_SLOT( properties() ), actionCollection(), "properties" );
actPack = new TDEAction( i18n( "Pac&k..." ), "kr_arc_pack", ALT + Key_P,
SLOTS, TQT_SLOT( slotPack() ), actionCollection(), "pack" );
SLOTS, TQ_SLOT( slotPack() ), actionCollection(), "pack" );
actUnpack = new TDEAction( i18n( "&Unpack..." ), "kr_arc_unpack", ALT + Key_U,
SLOTS, TQT_SLOT( slotUnpack() ), actionCollection() , "unpack" );
SLOTS, TQ_SLOT( slotUnpack() ), actionCollection() , "unpack" );
actSplit = new TDEAction( i18n( "Sp&lit File..." ), "kr_split", CTRL + Key_P,
SLOTS, TQT_SLOT( slotSplit() ), actionCollection(), "split" );
SLOTS, TQ_SLOT( slotSplit() ), actionCollection(), "split" );
actCombine = new TDEAction( i18n( "Com&bine Files..." ), "kr_combine", CTRL + Key_B,
SLOTS, TQT_SLOT( slotCombine() ), actionCollection() , "combine" );
SLOTS, TQ_SLOT( slotCombine() ), actionCollection() , "combine" );
actSelect = new TDEAction( i18n( "Select &Group..." ), "kr_select", CTRL + Key_Plus,
SLOTS, TQT_SLOT( markGroup() ), actionCollection(), "select group" );
SLOTS, TQ_SLOT( markGroup() ), actionCollection(), "select group" );
actSelectAll = new TDEAction( i18n( "&Select All" ), "kr_selectall", ALT + Key_Plus,
SLOTS, TQT_SLOT( markAll() ), actionCollection(), "select all" );
SLOTS, TQ_SLOT( markAll() ), actionCollection(), "select all" );
actUnselect = new TDEAction( i18n( "&Unselect Group..." ), "kr_unselect", CTRL + Key_Minus,
SLOTS, TQT_SLOT( unmarkGroup() ), actionCollection(), "unselect group" );
SLOTS, TQ_SLOT( unmarkGroup() ), actionCollection(), "unselect group" );
actUnselectAll = new TDEAction( i18n( "U&nselect All" ), "kr_unselectall", ALT + Key_Minus,
SLOTS, TQT_SLOT( unmarkAll() ), actionCollection(), "unselect all" );
SLOTS, TQ_SLOT( unmarkAll() ), actionCollection(), "unselect all" );
actInvert = new TDEAction( i18n( "&Invert Selection" ), "kr_invert", ALT + Key_Asterisk,
SLOTS, TQT_SLOT( invert() ), actionCollection(), "invert" );
SLOTS, TQ_SLOT( invert() ), actionCollection(), "invert" );
actCompDirs = new TDEAction( i18n( "&Compare Directories" ), "view_left_right", ALT + Key_C,
SLOTS, TQT_SLOT( compareDirs() ), actionCollection(), "compare dirs" );
SLOTS, TQ_SLOT( compareDirs() ), actionCollection(), "compare dirs" );
actSelectNewerAndSingle = new TDERadioAction( i18n( "&Select Newer and Single" ), 0,
SLOTS, TQT_SLOT( compareSetup() ), actionCollection(), "select_newer_and_single" );
SLOTS, TQ_SLOT( compareSetup() ), actionCollection(), "select_newer_and_single" );
actSelectNewer = new TDERadioAction( i18n( "Select &Newer" ), 0,
SLOTS, TQT_SLOT( compareSetup() ), actionCollection(), "select_newer" );
SLOTS, TQ_SLOT( compareSetup() ), actionCollection(), "select_newer" );
actSelectSingle = new TDERadioAction( i18n( "Select &Single" ), 0,
SLOTS, TQT_SLOT( compareSetup() ), actionCollection(), "select_single" );
SLOTS, TQ_SLOT( compareSetup() ), actionCollection(), "select_single" );
actSelectDifferentAndSingle = new TDERadioAction( i18n( "Select Different &and Single" ), 0,
SLOTS, TQT_SLOT( compareSetup() ), actionCollection(), "select_different_and_single" );
SLOTS, TQ_SLOT( compareSetup() ), actionCollection(), "select_different_and_single" );
actSelectDifferent = new TDERadioAction( i18n( "Select &Different" ), 0,
SLOTS, TQT_SLOT( compareSetup() ), actionCollection(), "select_different" );
SLOTS, TQ_SLOT( compareSetup() ), actionCollection(), "select_different" );
actSelectNewerAndSingle->setExclusiveGroup( "the_select_group" );
actSelectNewer->setExclusiveGroup( "the_select_group" );
actSelectSingle->setExclusiveGroup( "the_select_group" );
@ -663,23 +663,23 @@ void Krusader::setupActions() {
(*compareArray[ compareMode ])->setChecked( true );
actExecStartAndForget = new TDERadioAction(
i18n( "Start and &Forget" ), 0,
SLOTS, TQT_SLOT( execTypeSetup() ),
SLOTS, TQ_SLOT( execTypeSetup() ),
actionCollection(), "exec_start_and_forget" );
actExecCollectSeparate = new TDERadioAction(
i18n( "Display &Separated Standard and Error Output" ), 0,
SLOTS, TQT_SLOT( execTypeSetup() ),
SLOTS, TQ_SLOT( execTypeSetup() ),
actionCollection(), "exec_collect_separate" );
actExecCollectTogether = new TDERadioAction(
i18n( "Display &Mixed Standard and Error Output" ), 0,
SLOTS, TQT_SLOT( execTypeSetup() ),
SLOTS, TQ_SLOT( execTypeSetup() ),
actionCollection(), "exec_collect_together" );
actExecTerminalExternal = new TDERadioAction(
i18n( "Start in &New Terminal" ), 0,
SLOTS, TQT_SLOT( execTypeSetup() ),
SLOTS, TQ_SLOT( execTypeSetup() ),
actionCollection(), "exec_terminal_external" );
actExecTerminalEmbedded = new TDERadioAction(
i18n( "Send to &Embedded Terminal Emulator" ), 0,
SLOTS, TQT_SLOT( execTypeSetup() ),
SLOTS, TQ_SLOT( execTypeSetup() ),
actionCollection(), "exec_terminal_embedded" );
actExecStartAndForget->setExclusiveGroup("the_exec_type_group");
actExecCollectSeparate->setExclusiveGroup("the_exec_type_group");
@ -691,124 +691,124 @@ void Krusader::setupActions() {
actHomeTerminal = new TDEAction( i18n( "Start &Terminal" ), "terminal", 0,
SLOTS, TQT_SLOT( homeTerminal() ), actionCollection(), "terminal@home" );
SLOTS, TQ_SLOT( homeTerminal() ), actionCollection(), "terminal@home" );
actFTPDisconnect = new TDEAction( i18n( "Disconnect &from Net" ), "kr_ftp_disconnect", SHIFT + CTRL + Key_F,
SLOTS, TQT_SLOT( FTPDisconnect() ), actionCollection(), "ftp disconnect" );
SLOTS, TQ_SLOT( FTPDisconnect() ), actionCollection(), "ftp disconnect" );
#if KDE_IS_VERSION(3,2,0) /* new mountman feature is available in kde 3.2 only! */
actMountMan = new TDEToolBarPopupAction( i18n( "&MountMan..." ), "kr_mountman", ALT + Key_Slash,
SLOTS, TQT_SLOT( runMountMan() ), actionCollection(), "mountman" );
connect( ( ( TDEToolBarPopupAction* ) actMountMan ) ->popupMenu(), TQT_SIGNAL( aboutToShow() ),
mountMan, TQT_SLOT( quickList() ) );
SLOTS, TQ_SLOT( runMountMan() ), actionCollection(), "mountman" );
connect( ( ( TDEToolBarPopupAction* ) actMountMan ) ->popupMenu(), TQ_SIGNAL( aboutToShow() ),
mountMan, TQ_SLOT( quickList() ) );
#else
actMountMan = new TDEAction( i18n( "&MountMan..." ), "kr_mountman", ALT + Key_Slash,
SLOTS, TQT_SLOT( runMountMan() ), actionCollection(), "mountman" );
SLOTS, TQ_SLOT( runMountMan() ), actionCollection(), "mountman" );
#endif /* KDE 3.2 */
actFind = new TDEAction( i18n( "&Search..." ), "filefind", CTRL + Key_S,
SLOTS, TQT_SLOT( search() ), actionCollection(), "find" );
SLOTS, TQ_SLOT( search() ), actionCollection(), "find" );
actLocate = new TDEAction( i18n( "&Locate..." ), "edit-find", SHIFT+CTRL + Key_L,
SLOTS, TQT_SLOT( locate() ), actionCollection(), "locate" );
SLOTS, TQ_SLOT( locate() ), actionCollection(), "locate" );
actSyncDirs = new TDEAction( i18n( "Synchronize &Directories..." ), "kr_syncdirs", CTRL + Key_Y,
SLOTS, TQT_SLOT( slotSynchronizeDirs() ), actionCollection(), "sync dirs" );
SLOTS, TQ_SLOT( slotSynchronizeDirs() ), actionCollection(), "sync dirs" );
actSyncBrowse = new TDEAction( i18n( "S&ynchron Directory Changes" ), "kr_syncbrowse_off", ALT + Key_Y,
SLOTS, TQT_SLOT( slotSyncBrowse() ), actionCollection(), "sync browse" );
SLOTS, TQ_SLOT( slotSyncBrowse() ), actionCollection(), "sync browse" );
actDiskUsage = new TDEAction( i18n( "D&isk Usage..." ), "kr_diskusage", ALT + Key_D,
SLOTS, TQT_SLOT( slotDiskUsage() ), actionCollection(), "disk usage" );
SLOTS, TQ_SLOT( slotDiskUsage() ), actionCollection(), "disk usage" );
actKonfigurator = new TDEAction( i18n( "Configure &Krusader..." ), "configure", 0,
SLOTS, TQT_SLOT( startKonfigurator() ), actionCollection(), "konfigurator" );
SLOTS, TQ_SLOT( startKonfigurator() ), actionCollection(), "konfigurator" );
actBack = new TDEAction( i18n( "Back" ), "back", 0,
SLOTS, TQT_SLOT( back() ), actionCollection(), "back" );
SLOTS, TQ_SLOT( back() ), actionCollection(), "back" );
actRoot = new TDEAction( i18n( "Root" ), "go-top", CTRL + Key_Backspace,
SLOTS, TQT_SLOT( root() ), actionCollection(), "root" );
SLOTS, TQ_SLOT( root() ), actionCollection(), "root" );
actSavePosition = new TDEAction( i18n( "Save &Position" ), 0,
krApp, TQT_SLOT( savePosition() ), actionCollection(), "save position" );
krApp, TQ_SLOT( savePosition() ), actionCollection(), "save position" );
actAllFilter = new TDEAction( i18n( "&All Files" ), SHIFT + Key_F10,
SLOTS, TQT_SLOT( allFilter() ), actionCollection(), "all files" );
SLOTS, TQ_SLOT( allFilter() ), actionCollection(), "all files" );
//actExecFilter = new TDEAction( i18n( "&Executables" ), SHIFT + Key_F11,
// SLOTS, TQT_SLOT( execFilter() ), actionCollection(), "exec files" );
// SLOTS, TQ_SLOT( execFilter() ), actionCollection(), "exec files" );
actCustomFilter = new TDEAction( i18n( "&Custom" ), SHIFT + Key_F12,
SLOTS, TQT_SLOT( customFilter() ), actionCollection(), "custom files" );
SLOTS, TQ_SLOT( customFilter() ), actionCollection(), "custom files" );
actCompare = new TDEAction( i18n( "Compare b&y Content..." ), "application-vnd.tde.tdemultiple", 0,
SLOTS, TQT_SLOT( compareContent() ), actionCollection(), "compare" );
SLOTS, TQ_SLOT( compareContent() ), actionCollection(), "compare" );
actMultiRename = new TDEAction( i18n( "Multi &Rename..." ), "edit_rename", SHIFT + Key_F9,
SLOTS, TQT_SLOT( multiRename() ), actionCollection(), "multirename" );
SLOTS, TQ_SLOT( multiRename() ), actionCollection(), "multirename" );
new TDEAction( i18n( "Right-click Menu" ), Key_Menu,
SLOTS, TQT_SLOT( rightclickMenu() ), actionCollection(), "rightclick menu" );
SLOTS, TQ_SLOT( rightclickMenu() ), actionCollection(), "rightclick menu" );
new TDEAction( i18n( "Right Bookmarks" ), ALT + Key_Right,
SLOTS, TQT_SLOT( openRightBookmarks() ), actionCollection(), "right bookmarks" );
SLOTS, TQ_SLOT( openRightBookmarks() ), actionCollection(), "right bookmarks" );
new TDEAction( i18n( "Left Bookmarks" ), ALT + Key_Left,
SLOTS, TQT_SLOT( openLeftBookmarks() ), actionCollection(), "left bookmarks" );
SLOTS, TQ_SLOT( openLeftBookmarks() ), actionCollection(), "left bookmarks" );
new TDEAction( i18n( "Bookmarks" ), CTRL + Key_D,
SLOTS, TQT_SLOT( openBookmarks() ), actionCollection(), "bookmarks" );
SLOTS, TQ_SLOT( openBookmarks() ), actionCollection(), "bookmarks" );
new TDEAction( i18n( "Bookmark Current" ), CTRL + SHIFT + Key_D,
SLOTS, TQT_SLOT( bookmarkCurrent() ), actionCollection(), "bookmark current" );
SLOTS, TQ_SLOT( bookmarkCurrent() ), actionCollection(), "bookmark current" );
new TDEAction( i18n( "History" ), CTRL + Key_H,
SLOTS, TQT_SLOT( openHistory() ), actionCollection(), "history" );
SLOTS, TQ_SLOT( openHistory() ), actionCollection(), "history" );
new TDEAction( i18n( "Sync Panels" ), ALT + Key_O,
SLOTS, TQT_SLOT( syncPanels() ), actionCollection(), "sync panels");
SLOTS, TQ_SLOT( syncPanels() ), actionCollection(), "sync panels");
new TDEAction( i18n( "Left History" ), ALT + CTRL + Key_Left,
SLOTS, TQT_SLOT( openLeftHistory() ), actionCollection(), "left history" );
SLOTS, TQ_SLOT( openLeftHistory() ), actionCollection(), "left history" );
new TDEAction( i18n( "Right History" ), ALT + CTRL + Key_Right,
SLOTS, TQT_SLOT( openRightHistory() ), actionCollection(), "right history" );
SLOTS, TQ_SLOT( openRightHistory() ), actionCollection(), "right history" );
new TDEAction( i18n( "Media" ), CTRL + Key_M,
SLOTS, TQT_SLOT( openMedia() ), actionCollection(), "media" );
SLOTS, TQ_SLOT( openMedia() ), actionCollection(), "media" );
new TDEAction( i18n( "Left Media" ), CTRL + SHIFT + Key_Left,
SLOTS, TQT_SLOT( openLeftMedia() ), actionCollection(), "left media" );
SLOTS, TQ_SLOT( openLeftMedia() ), actionCollection(), "left media" );
new TDEAction( i18n( "Right Media" ), CTRL + SHIFT + Key_Right,
SLOTS, TQT_SLOT( openRightMedia() ), actionCollection(), "right media" );
SLOTS, TQ_SLOT( openRightMedia() ), actionCollection(), "right media" );
new TDEAction( i18n( "New Symlink..." ), CTRL + ALT + Key_S,
SLOTS, TQT_SLOT( newSymlink() ), actionCollection(), "new symlink");
SLOTS, TQ_SLOT( newSymlink() ), actionCollection(), "new symlink");
new TDEToggleAction( i18n( "Toggle Popup Panel" ), ALT + Key_Down, SLOTS,
TQT_SLOT( togglePopupPanel() ), actionCollection(), "toggle popup panel" );
TQ_SLOT( togglePopupPanel() ), actionCollection(), "toggle popup panel" );
actVerticalMode = new TDEToggleAction( i18n( "Vertical Mode" ), "view_top_bottom", ALT + CTRL + Key_R, MAIN_VIEW,
TQT_SLOT( toggleVerticalMode() ), actionCollection(), "toggle vertical mode" );
TQ_SLOT( toggleVerticalMode() ), actionCollection(), "toggle vertical mode" );
actNewTab = new TDEAction( i18n( "New Tab" ), "tab_new", ALT + CTRL + Key_N, SLOTS,
TQT_SLOT( newTab() ), actionCollection(), "new tab" );
TQ_SLOT( newTab() ), actionCollection(), "new tab" );
actDupTab = new TDEAction( i18n( "Duplicate Current Tab" ), "tab_duplicate", ALT + CTRL + SHIFT + Key_N, SLOTS,
TQT_SLOT( duplicateTab() ), actionCollection(), "duplicate tab" );
TQ_SLOT( duplicateTab() ), actionCollection(), "duplicate tab" );
actCloseTab = new TDEAction( i18n( "Close Current Tab" ), "tab_remove", CTRL + Key_W, SLOTS,
TQT_SLOT( closeTab() ), actionCollection(), "close tab" );
TQ_SLOT( closeTab() ), actionCollection(), "close tab" );
actNextTab = new TDEAction( i18n( "Next Tab" ), SHIFT + Key_Right, SLOTS,
TQT_SLOT( nextTab() ), actionCollection(), "next tab" );
TQ_SLOT( nextTab() ), actionCollection(), "next tab" );
actPreviousTab = new TDEAction( i18n( "Previous Tab" ), SHIFT + Key_Left, SLOTS,
TQT_SLOT( previousTab() ), actionCollection(), "previous tab" );
TQ_SLOT( previousTab() ), actionCollection(), "previous tab" );
/*
actUserMenu = new TDEAction( i18n( "User Menu" ), ALT + Key_QuoteLeft, SLOTS,
TQT_SLOT( userMenu() ), actionCollection(), "user menu" );
TQ_SLOT( userMenu() ), actionCollection(), "user menu" );
*/
actManageUseractions = new TDEAction( i18n( "Manage User Actions..." ), 0, SLOTS,
TQT_SLOT( manageUseractions() ), actionCollection(), "manage useractions" );
TQ_SLOT( manageUseractions() ), actionCollection(), "manage useractions" );
new KrRemoteEncodingMenu(i18n("Select Remote Charset"), "charset", actionCollection(), "changeremoteencoding");
// setup the Fn keys
actF2 = new TDEAction( i18n( "Start Terminal Here" ), "terminal", Key_F2,
SLOTS, TQT_SLOT( terminal() ) , actionCollection(), "F2_Terminal" );
SLOTS, TQ_SLOT( terminal() ) , actionCollection(), "F2_Terminal" );
actF3 = new TDEAction( i18n( "View File" ), Key_F3,
SLOTS, TQT_SLOT( view() ) , actionCollection(), "F3_View" );
SLOTS, TQ_SLOT( view() ) , actionCollection(), "F3_View" );
actF4 = new TDEAction( i18n( "Edit File" ), Key_F4,
SLOTS, TQT_SLOT( edit() ) , actionCollection(), "F4_Edit" );
SLOTS, TQ_SLOT( edit() ) , actionCollection(), "F4_Edit" );
actF5 = new TDEAction( i18n( "Copy..." ), Key_F5,
SLOTS, TQT_SLOT( copyFiles() ) , actionCollection(), "F5_Copy" );
SLOTS, TQ_SLOT( copyFiles() ) , actionCollection(), "F5_Copy" );
actF6 = new TDEAction( i18n( "Move..." ), Key_F6,
SLOTS, TQT_SLOT( moveFiles() ) , actionCollection(), "F6_Move" );
SLOTS, TQ_SLOT( moveFiles() ) , actionCollection(), "F6_Move" );
actF7 = new TDEAction( i18n( "New Directory..." ), "folder-new", Key_F7,
SLOTS, TQT_SLOT( mkdir() ) , actionCollection(), "F7_Mkdir" );
SLOTS, TQ_SLOT( mkdir() ) , actionCollection(), "F7_Mkdir" );
actF8 = new TDEAction( i18n( "Delete" ), "edit-delete", Key_F8,
SLOTS, TQT_SLOT( deleteFiles() ) , actionCollection(), "F8_Delete" );
SLOTS, TQ_SLOT( deleteFiles() ) , actionCollection(), "F8_Delete" );
actF9 = new TDEAction( i18n( "Rename" ), Key_F9,
SLOTS, TQT_SLOT( rename() ) , actionCollection(), "F9_Rename" );
SLOTS, TQ_SLOT( rename() ) , actionCollection(), "F9_Rename" );
actF10 = new TDEAction( i18n( "Quit" ), Key_F10,
this, TQT_SLOT( slotClose() ) , actionCollection(), "F10_Quit" );
this, TQ_SLOT( slotClose() ) , actionCollection(), "F10_Quit" );
actPopularUrls = new TDEAction( i18n("Popular URLs..."), CTRL+Key_Z,
popularUrls, TQT_SLOT( showDialog() ), actionCollection(), "Popular_Urls");
popularUrls, TQ_SLOT( showDialog() ), actionCollection(), "Popular_Urls");
actLocationBar = new TDEAction( i18n("Go to Location Bar"), CTRL+Key_L,
SLOTS, TQT_SLOT( slotLocationBar() ), actionCollection(), "location_bar");
SLOTS, TQ_SLOT( slotLocationBar() ), actionCollection(), "location_bar");
actJumpBack = new TDEAction( i18n("Jump Back"), "kr_jumpback", CTRL+Key_J,
SLOTS, TQT_SLOT( slotJumpBack() ), actionCollection(), "jump_back");
SLOTS, TQ_SLOT( slotJumpBack() ), actionCollection(), "jump_back");
actSetJumpBack = new TDEAction( i18n("Set Jump Back Point"), "kr_setjumpback", CTRL+SHIFT+Key_J,
SLOTS, TQT_SLOT( slotSetJumpBack() ), actionCollection(), "set_jump_back");
SLOTS, TQ_SLOT( slotSetJumpBack() ), actionCollection(), "set_jump_back");
actSwitchFullScreenTE = new TDEAction( i18n( "Toggle Fullwidget Terminal Emulator" ), 0, CTRL + Key_F,
MAIN_VIEW, TQT_SLOT( switchFullScreenTE() ), actionCollection(), "switch_fullscreen_te" );
MAIN_VIEW, TQ_SLOT( switchFullScreenTE() ), actionCollection(), "switch_fullscreen_te" );
// and at last we can set the tool-tips
actSelect->setToolTip( i18n( "Select files using a filter" ) );
@ -823,7 +823,7 @@ void Krusader::setupActions() {
userAction = new UserAction();
#ifdef __KJSEMBED__
actShowJSConsole = new TDEAction( i18n( "JavaScript Console..." ), ALT + CTRL + Key_J, SLOTS, TQT_SLOT( jsConsole() ), actionCollection(), "JS_Console" );
actShowJSConsole = new TDEAction( i18n( "JavaScript Console..." ), ALT + CTRL + Key_J, SLOTS, TQ_SLOT( jsConsole() ), actionCollection(), "JS_Console" );
#endif
}

10
krusader/krusaderview.cpp
Unescape View File

@ -165,8 +165,8 @@ void KrusaderView::createTE() {
factory->create( terminal_dock, "konsolepart",
"KParts::ReadOnlyPart" );
if( konsole_part ) { //loaded successfully
connect( konsole_part, TQT_SIGNAL( destroyed() ),
this, TQT_SLOT( killTerminalEmulator() ) );
connect( konsole_part, TQ_SIGNAL( destroyed() ),
this, TQ_SLOT( killTerminalEmulator() ) );
tqApp->installEventFilter( this );
} else {
tqApp->removeEventFilter( this );
@ -241,7 +241,7 @@ void KrusaderView::slotTerminalEmulator( bool show ) {
// BUGFIX: TE scrolling bug (see upper)
// show the Konsole part delayed
TQTimer::singleShot( 0, konsole_part->widget(), TQT_SLOT( show() ) );
TQTimer::singleShot( 0, konsole_part->widget(), TQ_SLOT( show() ) );
if( konsole_part->widget() ) {
konsole_part->widget()->setFocus();
@ -370,8 +370,8 @@ void KrusaderView::profiles( TQString profileName )
{
ProfileManager profileManager( "Panel" );
profileManager.hide();
connect( &profileManager, TQT_SIGNAL( saveToProfile( TQString ) ), this, TQT_SLOT( savePanelProfiles( TQString ) ) );
connect( &profileManager, TQT_SIGNAL( loadFromProfile( TQString ) ), this, TQT_SLOT( loadPanelProfiles( TQString ) ) );
connect( &profileManager, TQ_SIGNAL( saveToProfile( TQString ) ), this, TQ_SLOT( savePanelProfiles( TQString ) ) );
connect( &profileManager, TQ_SIGNAL( loadFromProfile( TQString ) ), this, TQ_SLOT( loadPanelProfiles( TQString ) ) );
if( profileName.isEmpty() )
profileManager.profilePopup();
else

4
krusader/main.cpp
Unescape View File

@ -231,8 +231,8 @@ int main(int argc, char *argv[]) {
signal(SIGHUP,sigterm_handler);
// make sure we receive X's focus in/out events
TQObject::connect(&app, TQT_SIGNAL(windowActive()), krusader.slot, TQT_SLOT(windowActive()));
TQObject::connect(&app, TQT_SIGNAL(windowInactive()), krusader.slot, TQT_SLOT(windowInactive()));
TQObject::connect(&app, TQ_SIGNAL(windowActive()), krusader.slot, TQ_SLOT(windowActive()));
TQObject::connect(&app, TQ_SIGNAL(windowInactive()), krusader.slot, TQ_SLOT(windowInactive()));
// and set krusader to be the main widget in it
app.setMainWidget(&krusader);

18
krusader/panelmanager.cpp
Unescape View File

@ -32,7 +32,7 @@ TQWidget( parent, "PanelManager" ), _layout( 0 ), _left( left ),
_newTab->setTextLabel( i18n( "Open a new tab in home" ) );
_newTab->setIconSet( SmallIcon( "tab_new" ) );
_newTab->adjustSize();
connect( _newTab, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotNewTab() ) );
connect( _newTab, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotNewTab() ) );
// close tab button
_closeTab = new TQToolButton( this );
@ -40,14 +40,14 @@ TQWidget( parent, "PanelManager" ), _layout( 0 ), _left( left ),
_closeTab->setTextLabel( i18n( "Close current tab" ) );
_closeTab->setIconSet( SmallIcon( "tab_remove" ) );
_closeTab->adjustSize();
connect( _closeTab, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotCloseTab() ) );
connect( _closeTab, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotCloseTab() ) );
_closeTab->setEnabled( false ); // disabled when there's only 1 tab
// tab-bar
_tabbar = new PanelTabBar( this );
connect( _tabbar, TQT_SIGNAL( changePanel( ListPanel* ) ), this, TQT_SLOT( slotChangePanel( ListPanel * ) ) );
connect( _tabbar, TQT_SIGNAL( closeCurrentTab() ), this, TQT_SLOT( slotCloseTab() ) );
connect( _tabbar, TQT_SIGNAL( newTab( const KURL& ) ), this, TQT_SLOT( slotNewTab( const KURL& ) ) );
connect( _tabbar, TQ_SIGNAL( changePanel( ListPanel* ) ), this, TQ_SLOT( slotChangePanel( ListPanel * ) ) );
connect( _tabbar, TQ_SIGNAL( closeCurrentTab() ), this, TQ_SLOT( slotCloseTab() ) );
connect( _tabbar, TQ_SIGNAL( newTab( const KURL& ) ), this, TQ_SLOT( slotNewTab( const KURL& ) ) );
_layout->addMultiCellWidget( _stack, 0, 0, 0, 2 );
_layout->addWidget( _newTab, 1, 0 );
@ -85,7 +85,7 @@ ListPanel* PanelManager::createPanel( TQString type, bool setCurrent ) {
_stack->raiseWidget( p );
// connect the activePanelChanged signal to enable/disable actions
connect( p, TQT_SIGNAL( activePanelChanged( ListPanel* ) ), this, TQT_SLOT( slotRefreshActions() ) );
connect( p, TQ_SIGNAL( activePanelChanged( ListPanel* ) ), this, TQ_SLOT( slotRefreshActions() ) );
return p;
}
@ -276,8 +276,8 @@ void PanelManager::slotRecreatePanels() {
_stack->removeWidget( oldPanel );
disconnect( oldPanel );
connect( newPanel, TQT_SIGNAL( activePanelChanged( ListPanel* ) ), this, TQT_SLOT( slotRefreshActions() ) );
connect( newPanel, TQT_SIGNAL( pathChanged(ListPanel*) ), _tabbar, TQT_SLOT(updateTab(ListPanel*)));
connect( newPanel, TQ_SIGNAL( activePanelChanged( ListPanel* ) ), this, TQ_SLOT( slotRefreshActions() ) );
connect( newPanel, TQ_SIGNAL( pathChanged(ListPanel*) ), _tabbar, TQ_SLOT(updateTab(ListPanel*)));
newPanel->otherPanel = _other;
if( _other->otherPanel == oldPanel )
@ -336,7 +336,7 @@ void PanelManager::deletePanel( ListPanel * p ) {
ACTIVE_PANEL = _self;
if( p && p->func && p->func->files() && !p->func->files()->vfs_canDelete() ) {
connect( p->func->files(), TQT_SIGNAL( deleteAllowed() ), p, TQT_SLOT( deleteLater() ) );
connect( p->func->files(), TQ_SIGNAL( deleteAllowed() ), p, TQ_SLOT( deleteLater() ) );
p->func->files()->vfs_requestDelete();
return;
}

4
krusader/paneltabbar.cpp
Unescape View File

@ -91,8 +91,8 @@ int PanelTabBar::addPanel(ListPanel *panel, bool setCurrent ) {
krCloseTab->setEnabled(true);
}
connect(dynamic_cast<PanelTab*>(tab(newId))->panel, TQT_SIGNAL(pathChanged(ListPanel*)),
this, TQT_SLOT(updateTab(ListPanel*)));
connect(dynamic_cast<PanelTab*>(tab(newId))->panel, TQ_SIGNAL(pathChanged(ListPanel*)),
this, TQ_SLOT(updateTab(ListPanel*)));
return newId;
}

Write Preview
Loading…
Cancel
Save