You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2420 lines
68 KiB
2420 lines
68 KiB
/* This file is part of the KDE libraries
|
|
Copyright (C) 1999 Reginald Stadlbauer <reggie@kde.org>
|
|
(C) 1999 Simon Hausmann <hausmann@kde.org>
|
|
(C) 2000 Nicolas Hadacek <haadcek@kde.org>
|
|
(C) 2000 Kurt Granroth <granroth@kde.org>
|
|
(C) 2000 Michael Koch <koch@kde.org>
|
|
(C) 2001 Holger Freyther <freyther@kde.org>
|
|
(C) 2002 Ellis Whitehead <ellis@kde.org>
|
|
(C) 2002 Joseph Wenninger <jowenn@kde.org>
|
|
(C) 2003 Andras Mantia <amantia@kde.org>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License version 2 as published by the Free Software Foundation.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "tdeactionclasses.h"
|
|
|
|
#include <assert.h>
|
|
#include <ft2build.h>
|
|
#include <fontconfig/fontconfig.h>
|
|
|
|
#include <tqcursor.h>
|
|
#include <tqclipboard.h>
|
|
#include <tqfontdatabase.h>
|
|
#include <tqobjectlist.h>
|
|
#include <tqwhatsthis.h>
|
|
#include <tqtimer.h>
|
|
#include <tqfile.h>
|
|
#include <tqregexp.h>
|
|
|
|
#include <dcopclient.h>
|
|
#include <dcopref.h>
|
|
#include <tdeaccel.h>
|
|
#include <tdeapplication.h>
|
|
#include <tdeconfig.h>
|
|
#include <kdebug.h>
|
|
#include <tdefontcombo.h>
|
|
#include <tdefontdialog.h>
|
|
#include <tdelocale.h>
|
|
#include <tdemainwindow.h>
|
|
#include <tdemenubar.h>
|
|
#include <tdepopupmenu.h>
|
|
#include <tdetoolbar.h>
|
|
#include <tdetoolbarbutton.h>
|
|
#include <kurl.h>
|
|
#include <kstandarddirs.h>
|
|
#include <kstringhandler.h>
|
|
|
|
class TDEToggleAction::TDEToggleActionPrivate
|
|
{
|
|
public:
|
|
TDEToggleActionPrivate()
|
|
{
|
|
m_checked = false;
|
|
m_checkedGuiItem = 0;
|
|
}
|
|
|
|
bool m_checked;
|
|
TQString m_exclusiveGroup;
|
|
KGuiItem* m_checkedGuiItem;
|
|
};
|
|
|
|
TDEToggleAction::TDEToggleAction( const TQString& text, const TDEShortcut& cut,
|
|
TQObject* parent,
|
|
const char* name )
|
|
: TDEAction( text, cut, parent, name )
|
|
{
|
|
d = new TDEToggleActionPrivate;
|
|
}
|
|
|
|
TDEToggleAction::TDEToggleAction( const TQString& text, const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDEToggleActionPrivate;
|
|
}
|
|
|
|
TDEToggleAction::TDEToggleAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEToggleActionPrivate;
|
|
}
|
|
|
|
TDEToggleAction::TDEToggleAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEToggleActionPrivate;
|
|
}
|
|
|
|
TDEToggleAction::TDEToggleAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDEAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDEToggleActionPrivate;
|
|
}
|
|
|
|
TDEToggleAction::TDEToggleAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDEAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDEToggleActionPrivate;
|
|
}
|
|
|
|
TDEToggleAction::TDEToggleAction( TQObject* parent, const char* name )
|
|
: TDEAction( parent, name )
|
|
{
|
|
d = new TDEToggleActionPrivate;
|
|
}
|
|
|
|
TDEToggleAction::~TDEToggleAction()
|
|
{
|
|
delete d->m_checkedGuiItem;
|
|
delete d;
|
|
}
|
|
|
|
int TDEToggleAction::plug( TQWidget* widget, int index )
|
|
{
|
|
if ( !::tqt_cast<TQPopupMenu *>( widget ) && !::tqt_cast<TDEToolBar *>( widget ) )
|
|
{
|
|
kdWarning() << "Can not plug TDEToggleAction in " << widget->className() << endl;
|
|
return -1;
|
|
}
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
|
|
int _index = TDEAction::plug( widget, index );
|
|
if ( _index == -1 )
|
|
return _index;
|
|
|
|
if ( ::tqt_cast<TDEToolBar *>( widget ) ) {
|
|
TDEToolBar *bar = static_cast<TDEToolBar *>( widget );
|
|
|
|
bar->setToggle( itemId( _index ), true );
|
|
bar->setButton( itemId( _index ), isChecked() );
|
|
}
|
|
|
|
if ( d->m_checked )
|
|
updateChecked( _index );
|
|
|
|
return _index;
|
|
}
|
|
|
|
void TDEToggleAction::setChecked( bool c )
|
|
{
|
|
if ( c == d->m_checked )
|
|
return;
|
|
//kdDebug(129) << "TDEToggleAction::setChecked(" << c << ") " << this << " " << name() << endl;
|
|
|
|
d->m_checked = c;
|
|
|
|
int len = containerCount();
|
|
|
|
for( int i = 0; i < len; ++i )
|
|
updateChecked( i );
|
|
|
|
if ( c && parent() && !exclusiveGroup().isEmpty() ) {
|
|
const TQObjectList list = parent()->childrenListObject();
|
|
if ( !list.isEmpty() ) {
|
|
TQObjectListIt it( list );
|
|
for( ; it.current(); ++it ) {
|
|
if ( ::tqt_cast<TDEToggleAction *>( it.current() ) && it.current() != this &&
|
|
static_cast<TDEToggleAction*>(it.current())->exclusiveGroup() == exclusiveGroup() ) {
|
|
TDEToggleAction *a = static_cast<TDEToggleAction*>(it.current());
|
|
if( a->isChecked() ) {
|
|
a->setChecked( false );
|
|
emit a->toggled( false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDEToggleAction::updateChecked( int id )
|
|
{
|
|
TQWidget *w = container( id );
|
|
|
|
if ( ::tqt_cast<TQPopupMenu *>( w ) ) {
|
|
TQPopupMenu* pm = static_cast<TQPopupMenu*>(w);
|
|
int itemId_ = itemId( id );
|
|
if ( !d->m_checkedGuiItem )
|
|
pm->setItemChecked( itemId_, d->m_checked );
|
|
else {
|
|
const KGuiItem* gui = d->m_checked ? d->m_checkedGuiItem : &guiItem();
|
|
if ( d->m_checkedGuiItem->hasIcon() )
|
|
pm->changeItem( itemId_, gui->iconSet( TDEIcon::Small ), gui->text() );
|
|
else
|
|
pm->changeItem( itemId_, gui->text() );
|
|
|
|
// If the text doesn't change, then set the icon to be "pressed", otherwise
|
|
// there is too little difference between checked and unchecked.
|
|
if ( d->m_checkedGuiItem->text() == guiItem().text() )
|
|
pm->setItemChecked( itemId_, d->m_checked );
|
|
|
|
if ( !d->m_checkedGuiItem->whatsThis().isEmpty() ) // if empty, we keep the initial one
|
|
pm->TQMenuData::setWhatsThis( itemId_, gui->whatsThis() );
|
|
updateShortcut( pm, itemId_ );
|
|
}
|
|
}
|
|
else if ( ::tqt_cast<TQMenuBar *>( w ) ) // not handled in plug...
|
|
static_cast<TQMenuBar*>(w)->setItemChecked( itemId( id ), d->m_checked );
|
|
else if ( ::tqt_cast<TDEToolBar *>( w ) )
|
|
{
|
|
TQWidget* r = static_cast<TDEToolBar*>( w )->getButton( itemId( id ) );
|
|
if ( r && ::tqt_cast<TDEToolBarButton *>( r ) ) {
|
|
static_cast<TDEToolBar*>( w )->setButton( itemId( id ), d->m_checked );
|
|
if ( d->m_checkedGuiItem && d->m_checkedGuiItem->hasIcon() ) {
|
|
const KGuiItem* gui = d->m_checked ? d->m_checkedGuiItem : &guiItem();
|
|
static_cast<TDEToolBar*>( w )->setButtonIconSet( itemId( id ), gui->iconSet( TDEIcon::Toolbar ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDEToggleAction::slotActivated()
|
|
{
|
|
setChecked( !isChecked() );
|
|
TDEAction::slotActivated();
|
|
emit toggled( isChecked() );
|
|
}
|
|
|
|
bool TDEToggleAction::isChecked() const
|
|
{
|
|
return d->m_checked;
|
|
}
|
|
|
|
void TDEToggleAction::setExclusiveGroup( const TQString& name )
|
|
{
|
|
d->m_exclusiveGroup = name;
|
|
}
|
|
|
|
TQString TDEToggleAction::exclusiveGroup() const
|
|
{
|
|
return d->m_exclusiveGroup;
|
|
}
|
|
|
|
void TDEToggleAction::setCheckedState( const KGuiItem& checkedItem )
|
|
{
|
|
delete d->m_checkedGuiItem;
|
|
d->m_checkedGuiItem = new KGuiItem( checkedItem );
|
|
}
|
|
|
|
TQString TDEToggleAction::toolTip() const
|
|
{
|
|
if ( d->m_checkedGuiItem && d->m_checked )
|
|
return d->m_checkedGuiItem->toolTip();
|
|
else
|
|
return TDEAction::toolTip();
|
|
}
|
|
|
|
TDERadioAction::TDERadioAction( const TQString& text, const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEToggleAction( text, cut, parent, name )
|
|
{
|
|
}
|
|
|
|
TDERadioAction::TDERadioAction( const TQString& text, const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDEToggleAction( text, cut, receiver, slot, parent, name )
|
|
{
|
|
}
|
|
|
|
TDERadioAction::TDERadioAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEToggleAction( text, pix, cut, parent, name )
|
|
{
|
|
}
|
|
|
|
TDERadioAction::TDERadioAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEToggleAction( text, pix, cut, parent, name )
|
|
{
|
|
}
|
|
|
|
TDERadioAction::TDERadioAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDEToggleAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
}
|
|
|
|
TDERadioAction::TDERadioAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDEToggleAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
}
|
|
|
|
TDERadioAction::TDERadioAction( TQObject* parent, const char* name )
|
|
: TDEToggleAction( parent, name )
|
|
{
|
|
}
|
|
|
|
void TDERadioAction::slotActivated()
|
|
{
|
|
if ( isChecked() )
|
|
{
|
|
const TQObject *senderObj = sender();
|
|
|
|
if ( !senderObj || !::tqt_cast<const TDEToolBarButton *>( senderObj ) )
|
|
return;
|
|
|
|
const_cast<TDEToolBarButton *>( static_cast<const TDEToolBarButton *>( senderObj ) )->on( true );
|
|
|
|
return;
|
|
}
|
|
|
|
TDEToggleAction::slotActivated();
|
|
}
|
|
|
|
class TDESelectAction::TDESelectActionPrivate
|
|
{
|
|
public:
|
|
TDESelectActionPrivate()
|
|
{
|
|
m_edit = false;
|
|
m_menuAccelsEnabled = true;
|
|
m_menu = 0;
|
|
m_current = -1;
|
|
m_comboWidth = -1;
|
|
m_maxComboViewCount = -1;
|
|
}
|
|
bool m_edit;
|
|
bool m_menuAccelsEnabled;
|
|
TQPopupMenu *m_menu;
|
|
int m_current;
|
|
int m_comboWidth;
|
|
TQStringList m_list;
|
|
int m_maxComboViewCount;
|
|
|
|
TQString makeMenuText( const TQString &_text )
|
|
{
|
|
if ( m_menuAccelsEnabled )
|
|
return _text;
|
|
TQString text = _text;
|
|
uint i = 0;
|
|
while ( i < text.length() ) {
|
|
if ( text[ i ] == '&' ) {
|
|
text.insert( i, '&' );
|
|
i += 2;
|
|
}
|
|
else
|
|
++i;
|
|
}
|
|
return text;
|
|
}
|
|
};
|
|
|
|
TDESelectAction::TDESelectAction( const TQString& text, const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, cut, parent, name )
|
|
{
|
|
d = new TDESelectActionPrivate;
|
|
}
|
|
|
|
TDESelectAction::TDESelectAction( const TQString& text, const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDESelectActionPrivate;
|
|
}
|
|
|
|
TDESelectAction::TDESelectAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDESelectActionPrivate;
|
|
}
|
|
|
|
TDESelectAction::TDESelectAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDESelectActionPrivate;
|
|
}
|
|
|
|
TDESelectAction::TDESelectAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDEAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDESelectActionPrivate;
|
|
}
|
|
|
|
TDESelectAction::TDESelectAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDEAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDESelectActionPrivate;
|
|
}
|
|
|
|
TDESelectAction::TDESelectAction( TQObject* parent, const char* name )
|
|
: TDEAction( parent, name )
|
|
{
|
|
d = new TDESelectActionPrivate;
|
|
}
|
|
|
|
TDESelectAction::~TDESelectAction()
|
|
{
|
|
assert(d);
|
|
delete d->m_menu;
|
|
delete d; d = 0;
|
|
}
|
|
|
|
void TDESelectAction::setCurrentItem( int id )
|
|
{
|
|
if ( id >= (int)d->m_list.count() ) {
|
|
Q_ASSERT(id < (int)d->m_list.count());
|
|
return;
|
|
}
|
|
|
|
if ( d->m_menu )
|
|
{
|
|
if ( d->m_current >= 0 )
|
|
d->m_menu->setItemChecked( d->m_current, false );
|
|
if ( id >= 0 )
|
|
d->m_menu->setItemChecked( id, true );
|
|
}
|
|
|
|
d->m_current = id;
|
|
|
|
int len = containerCount();
|
|
|
|
for( int i = 0; i < len; ++i )
|
|
updateCurrentItem( i );
|
|
|
|
// emit TDEAction::activated();
|
|
// emit activated( currentItem() );
|
|
// emit activated( currentText() );
|
|
}
|
|
|
|
void TDESelectAction::setComboWidth( int width )
|
|
{
|
|
if ( width < 0 )
|
|
return;
|
|
|
|
d->m_comboWidth=width;
|
|
|
|
int len = containerCount();
|
|
|
|
for( int i = 0; i < len; ++i )
|
|
updateComboWidth( i );
|
|
|
|
}
|
|
|
|
void TDESelectAction::setMaxComboViewCount( int n )
|
|
{
|
|
d->m_maxComboViewCount = n;
|
|
}
|
|
|
|
TQPopupMenu* TDESelectAction::popupMenu() const
|
|
{
|
|
kdDebug(129) << "TDEAction::popupMenu()" << endl; // remove -- ellis
|
|
if ( !d->m_menu )
|
|
{
|
|
d->m_menu = new TDEPopupMenu(0L, "TDESelectAction::popupMenu()");
|
|
setupMenu();
|
|
if ( d->m_current >= 0 )
|
|
d->m_menu->setItemChecked( d->m_current, true );
|
|
}
|
|
|
|
return d->m_menu;
|
|
}
|
|
|
|
void TDESelectAction::setupMenu() const
|
|
{
|
|
if ( !d->m_menu )
|
|
return;
|
|
d->m_menu->clear();
|
|
|
|
TQStringList::ConstIterator it = d->m_list.begin();
|
|
for( uint id = 0; it != d->m_list.end(); ++it, ++id ) {
|
|
TQString text = *it;
|
|
if ( !text.isEmpty() )
|
|
d->m_menu->insertItem( d->makeMenuText( text ), this, TQ_SLOT( slotActivated( int ) ), 0, id );
|
|
else
|
|
d->m_menu->insertSeparator();
|
|
}
|
|
}
|
|
|
|
void TDESelectAction::changeItem( int index, const TQString& text )
|
|
{
|
|
if ( index < 0 || index >= (int)d->m_list.count() )
|
|
{
|
|
kdWarning() << "TDESelectAction::changeItem Index out of scope" << endl;
|
|
return;
|
|
}
|
|
|
|
d->m_list[ index ] = text;
|
|
|
|
if ( d->m_menu )
|
|
d->m_menu->changeItem( index, d->makeMenuText( text ) );
|
|
|
|
int len = containerCount();
|
|
for( int i = 0; i < len; ++i )
|
|
changeItem( i, index, text );
|
|
}
|
|
|
|
void TDESelectAction::changeItem( int id, int index, const TQString& text)
|
|
{
|
|
if ( index < 0 )
|
|
return;
|
|
|
|
TQWidget* w = container( id );
|
|
if ( ::tqt_cast<TDEToolBar *>( w ) )
|
|
{
|
|
TQWidget* r = (static_cast<TDEToolBar*>( w ))->getWidget( itemId( id ) );
|
|
if ( ::tqt_cast<TQComboBox *>( r ) )
|
|
{
|
|
TQComboBox *b = static_cast<TQComboBox*>( r );
|
|
b->changeItem(text, index );
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDESelectAction::setItems( const TQStringList &lst )
|
|
{
|
|
d->m_list = lst;
|
|
d->m_current = -1;
|
|
|
|
setupMenu();
|
|
|
|
int len = containerCount();
|
|
for( int i = 0; i < len; ++i )
|
|
updateItems( i );
|
|
|
|
// Disable if empty and not editable
|
|
setEnabled ( lst.count() > 0 || d->m_edit );
|
|
}
|
|
|
|
TQStringList TDESelectAction::items() const
|
|
{
|
|
return d->m_list;
|
|
}
|
|
|
|
TQString TDESelectAction::currentText() const
|
|
{
|
|
if ( currentItem() < 0 )
|
|
return TQString::null;
|
|
|
|
return d->m_list[ currentItem() ];
|
|
}
|
|
|
|
int TDESelectAction::currentItem() const
|
|
{
|
|
return d->m_current;
|
|
}
|
|
|
|
void TDESelectAction::updateCurrentItem( int id )
|
|
{
|
|
if ( d->m_current < 0 )
|
|
return;
|
|
|
|
TQWidget* w = container( id );
|
|
if ( ::tqt_cast<TDEToolBar *>( w ) ) {
|
|
TQWidget* r = static_cast<TDEToolBar*>( w )->getWidget( itemId( id ) );
|
|
if ( ::tqt_cast<TQComboBox *>( r ) ) {
|
|
TQComboBox *b = static_cast<TQComboBox*>( r );
|
|
b->setCurrentItem( d->m_current );
|
|
}
|
|
}
|
|
}
|
|
|
|
int TDESelectAction::comboWidth() const
|
|
{
|
|
return d->m_comboWidth;
|
|
}
|
|
|
|
void TDESelectAction::updateComboWidth( int id )
|
|
{
|
|
TQWidget* w = container( id );
|
|
if ( ::tqt_cast<TDEToolBar *>( w ) ) {
|
|
TQWidget* r = static_cast<TDEToolBar*>( w )->getWidget( itemId( id ) );
|
|
if ( ::tqt_cast<TQComboBox *>( r ) ) {
|
|
TQComboBox *cb = static_cast<TQComboBox*>( r );
|
|
cb->setMinimumWidth( d->m_comboWidth );
|
|
cb->setMaximumWidth( d->m_comboWidth );
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDESelectAction::updateItems( int id )
|
|
{
|
|
kdDebug(129) << "TDEAction::updateItems( " << id << ", lst )" << endl; // remove -- ellis
|
|
TQWidget* w = container( id );
|
|
if ( ::tqt_cast<TDEToolBar *>( w ) ) {
|
|
TQWidget* r = static_cast<TDEToolBar*>( w )->getWidget( itemId( id ) );
|
|
if ( ::tqt_cast<TQComboBox *>( r ) ) {
|
|
TQComboBox *cb = static_cast<TQComboBox*>( r );
|
|
cb->clear();
|
|
TQStringList lst = comboItems();
|
|
TQStringList::ConstIterator it = lst.begin();
|
|
for( ; it != lst.end(); ++it )
|
|
cb->insertItem( *it );
|
|
// qt caches and never recalculates the sizeHint()
|
|
// qcombobox.cpp recommends calling setFont to invalidate the sizeHint
|
|
// setFont sets own_font = True, so we're a bit mean and calll
|
|
// unsetFont which calls setFont and then overwrites the own_font
|
|
cb->unsetFont();
|
|
}
|
|
}
|
|
}
|
|
|
|
int TDESelectAction::plug( TQWidget *widget, int index )
|
|
{
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
kdDebug(129) << "TDESelectAction::plug( " << widget << ", " << index << " )" << endl; // remove -- ellis
|
|
if ( ::tqt_cast<TQPopupMenu *>( widget) )
|
|
{
|
|
// Create the PopupMenu and store it in m_menu
|
|
(void)popupMenu();
|
|
|
|
TQPopupMenu* menu = static_cast<TQPopupMenu*>( widget );
|
|
int id;
|
|
if ( hasIcon() )
|
|
id = menu->insertItem( iconSet(), text(), d->m_menu, -1, index );
|
|
else
|
|
id = menu->insertItem( text(), d->m_menu, -1, index );
|
|
|
|
if ( !isEnabled() )
|
|
menu->setItemEnabled( id, false );
|
|
|
|
TQString wth = whatsThis();
|
|
if ( !wth.isEmpty() )
|
|
menu->TQMenuData::setWhatsThis( id, wth );
|
|
|
|
addContainer( menu, id );
|
|
connect( menu, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
else if ( ::tqt_cast<TDEToolBar *>( widget ) )
|
|
{
|
|
TDEToolBar* bar = static_cast<TDEToolBar*>( widget );
|
|
int id_ = TDEAction::getToolButtonID();
|
|
bar->insertCombo( comboItems(), id_, isEditable(),
|
|
TQ_SIGNAL( activated( const TQString & ) ), this,
|
|
TQ_SLOT( slotActivated( const TQString & ) ), isEnabled(),
|
|
toolTip(), -1, index );
|
|
|
|
TQComboBox *cb = bar->getCombo( id_ );
|
|
if ( cb )
|
|
{
|
|
if (!isEditable()) cb->setFocusPolicy(TQWidget::NoFocus);
|
|
cb->setMinimumWidth( cb->sizeHint().width() );
|
|
if ( d->m_comboWidth > 0 )
|
|
{
|
|
cb->setMinimumWidth( d->m_comboWidth );
|
|
cb->setMaximumWidth( d->m_comboWidth );
|
|
}
|
|
cb->setInsertionPolicy( TQComboBox::NoInsertion );
|
|
TQWhatsThis::add( cb, whatsThis() );
|
|
if ( d->m_maxComboViewCount != -1 ) cb->setSizeLimit( d->m_maxComboViewCount );
|
|
}
|
|
|
|
addContainer( bar, id_ );
|
|
|
|
connect( bar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
updateCurrentItem( containerCount() - 1 );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
else if ( ::tqt_cast<TQMenuBar *>( widget ) )
|
|
{
|
|
// Create the PopupMenu and store it in m_menu
|
|
(void)popupMenu();
|
|
|
|
TQMenuBar* menu = static_cast<TQMenuBar*>( widget );
|
|
int id = menu->insertItem( text(), d->m_menu, -1, index );
|
|
|
|
if ( !isEnabled() )
|
|
menu->setItemEnabled( id, false );
|
|
|
|
TQString wth = whatsThis();
|
|
if ( !wth.isEmpty() )
|
|
menu->TQMenuData::setWhatsThis( id, wth );
|
|
|
|
addContainer( menu, id );
|
|
connect( menu, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
|
|
kdWarning() << "Can not plug TDEAction in " << widget->className() << endl;
|
|
return -1;
|
|
}
|
|
|
|
TQStringList TDESelectAction::comboItems() const
|
|
{
|
|
if( d->m_menuAccelsEnabled ) {
|
|
TQStringList lst;
|
|
TQStringList::ConstIterator it = d->m_list.begin();
|
|
for( ; it != d->m_list.end(); ++it )
|
|
{
|
|
TQString item = *it;
|
|
int i = item.find( '&' );
|
|
if ( i > -1 )
|
|
item = item.remove( i, 1 );
|
|
lst.append( item );
|
|
}
|
|
return lst;
|
|
}
|
|
else
|
|
return d->m_list;
|
|
}
|
|
|
|
void TDESelectAction::clear()
|
|
{
|
|
if ( d->m_menu )
|
|
d->m_menu->clear();
|
|
|
|
int len = containerCount();
|
|
for( int i = 0; i < len; ++i )
|
|
updateClear( i );
|
|
}
|
|
|
|
void TDESelectAction::updateClear( int id )
|
|
{
|
|
TQWidget* w = container( id );
|
|
if ( ::tqt_cast<TDEToolBar *>( w ) ) {
|
|
TQWidget* r = static_cast<TDEToolBar*>( w )->getWidget( itemId( id ) );
|
|
if ( ::tqt_cast<TQComboBox *>( r ) ) {
|
|
TQComboBox *b = static_cast<TQComboBox*>( r );
|
|
b->clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDESelectAction::slotActivated( int id )
|
|
{
|
|
if ( d->m_current == id )
|
|
return;
|
|
|
|
setCurrentItem( id );
|
|
// Delay this. Especially useful when the slot connected to activated() will re-create
|
|
// the menu, e.g. in the recent files action. This prevents a crash.
|
|
TQTimer::singleShot( 0, this, TQ_SLOT( slotActivated() ) );
|
|
}
|
|
|
|
void TDESelectAction::slotActivated( const TQString &text )
|
|
{
|
|
if ( isEditable() )
|
|
{
|
|
TQStringList lst = d->m_list;
|
|
if(!lst.contains(text))
|
|
{
|
|
lst.append( text );
|
|
setItems( lst );
|
|
}
|
|
}
|
|
|
|
int i = d->m_list.findIndex( text );
|
|
if ( i > -1 )
|
|
setCurrentItem( i );
|
|
else
|
|
setCurrentItem( comboItems().findIndex( text ) );
|
|
// Delay this. Especially useful when the slot connected to activated() will re-create
|
|
// the menu, e.g. in the recent files action. This prevents a crash.
|
|
TQTimer::singleShot( 0, this, TQ_SLOT( slotActivated() ) );
|
|
}
|
|
|
|
void TDESelectAction::slotActivated()
|
|
{
|
|
TDEAction::slotActivated();
|
|
kdDebug(129) << "TDESelectAction::slotActivated currentItem=" << currentItem() << " currentText=" << currentText() << endl;
|
|
emit activated( currentItem() );
|
|
emit activated( currentText() );
|
|
}
|
|
|
|
void TDESelectAction::setEditable( bool edit )
|
|
{
|
|
d->m_edit = edit;
|
|
}
|
|
|
|
bool TDESelectAction::isEditable() const
|
|
{
|
|
return d->m_edit;
|
|
}
|
|
|
|
void TDESelectAction::setRemoveAmpersandsInCombo( bool b )
|
|
{
|
|
setMenuAccelsEnabled( b );
|
|
}
|
|
|
|
bool TDESelectAction::removeAmpersandsInCombo() const
|
|
{
|
|
return menuAccelsEnabled( );
|
|
}
|
|
|
|
void TDESelectAction::setMenuAccelsEnabled( bool b )
|
|
{
|
|
d->m_menuAccelsEnabled = b;
|
|
}
|
|
|
|
bool TDESelectAction::menuAccelsEnabled() const
|
|
{
|
|
return d->m_menuAccelsEnabled;
|
|
}
|
|
|
|
class TDEListAction::TDEListActionPrivate
|
|
{
|
|
public:
|
|
TDEListActionPrivate()
|
|
{
|
|
m_current = 0;
|
|
}
|
|
int m_current;
|
|
};
|
|
|
|
TDEListAction::TDEListAction( const TQString& text, const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, cut, parent, name )
|
|
{
|
|
d = new TDEListActionPrivate;
|
|
}
|
|
|
|
TDEListAction::TDEListAction( const TQString& text, const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, cut, parent, name )
|
|
{
|
|
d = new TDEListActionPrivate;
|
|
if ( receiver )
|
|
connect( this, TQ_SIGNAL( activated( int ) ), receiver, slot );
|
|
}
|
|
|
|
TDEListAction::TDEListAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEListActionPrivate;
|
|
}
|
|
|
|
TDEListAction::TDEListAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEListActionPrivate;
|
|
}
|
|
|
|
TDEListAction::TDEListAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut, const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEListActionPrivate;
|
|
if ( receiver )
|
|
connect( this, TQ_SIGNAL( activated( int ) ), receiver, slot );
|
|
}
|
|
|
|
TDEListAction::TDEListAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut, const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEListActionPrivate;
|
|
if ( receiver )
|
|
connect( this, TQ_SIGNAL( activated( int ) ), receiver, slot );
|
|
}
|
|
|
|
TDEListAction::TDEListAction( TQObject* parent, const char* name )
|
|
: TDESelectAction( parent, name )
|
|
{
|
|
d = new TDEListActionPrivate;
|
|
}
|
|
|
|
TDEListAction::~TDEListAction()
|
|
{
|
|
delete d; d = 0;
|
|
}
|
|
|
|
void TDEListAction::setCurrentItem( int index )
|
|
{
|
|
TDESelectAction::setCurrentItem( index );
|
|
d->m_current = index;
|
|
|
|
// emit TDEAction::activated();
|
|
// emit activated( currentItem() );
|
|
// emit activated( currentText() );
|
|
}
|
|
|
|
TQString TDEListAction::currentText() const
|
|
{
|
|
return TDESelectAction::currentText();
|
|
}
|
|
|
|
int TDEListAction::currentItem() const
|
|
{
|
|
return d->m_current;
|
|
}
|
|
|
|
class TDERecentFilesAction::TDERecentFilesActionPrivate
|
|
{
|
|
public:
|
|
TDERecentFilesActionPrivate()
|
|
{
|
|
m_maxItems = 0;
|
|
m_popup = 0;
|
|
}
|
|
uint m_maxItems;
|
|
TDEPopupMenu *m_popup;
|
|
TQMap<TQString, TQString> m_shortNames;
|
|
TQMap<TQString, KURL> m_urls;
|
|
};
|
|
|
|
TDERecentFilesAction::TDERecentFilesAction( const TQString& text,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name,
|
|
uint maxItems )
|
|
: TDEListAction( text, cut, parent, name)
|
|
{
|
|
d = new TDERecentFilesActionPrivate;
|
|
d->m_maxItems = maxItems;
|
|
|
|
init();
|
|
}
|
|
|
|
TDERecentFilesAction::TDERecentFilesAction( const TQString& text,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot,
|
|
TQObject* parent, const char* name,
|
|
uint maxItems )
|
|
: TDEListAction( text, cut, parent, name)
|
|
{
|
|
d = new TDERecentFilesActionPrivate;
|
|
d->m_maxItems = maxItems;
|
|
|
|
init();
|
|
|
|
if ( receiver )
|
|
connect( this, TQ_SIGNAL(urlSelected(const KURL&)),
|
|
receiver, slot );
|
|
}
|
|
|
|
TDERecentFilesAction::TDERecentFilesAction( const TQString& text,
|
|
const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name,
|
|
uint maxItems )
|
|
: TDEListAction( text, pix, cut, parent, name)
|
|
{
|
|
d = new TDERecentFilesActionPrivate;
|
|
d->m_maxItems = maxItems;
|
|
|
|
init();
|
|
}
|
|
|
|
TDERecentFilesAction::TDERecentFilesAction( const TQString& text,
|
|
const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name,
|
|
uint maxItems )
|
|
: TDEListAction( text, pix, cut, parent, name)
|
|
{
|
|
d = new TDERecentFilesActionPrivate;
|
|
d->m_maxItems = maxItems;
|
|
|
|
init();
|
|
}
|
|
|
|
TDERecentFilesAction::TDERecentFilesAction( const TQString& text,
|
|
const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot,
|
|
TQObject* parent, const char* name,
|
|
uint maxItems )
|
|
: TDEListAction( text, pix, cut, parent, name)
|
|
{
|
|
d = new TDERecentFilesActionPrivate;
|
|
d->m_maxItems = maxItems;
|
|
|
|
init();
|
|
|
|
if ( receiver )
|
|
connect( this, TQ_SIGNAL(urlSelected(const KURL&)),
|
|
receiver, slot );
|
|
}
|
|
|
|
TDERecentFilesAction::TDERecentFilesAction( const TQString& text,
|
|
const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot,
|
|
TQObject* parent, const char* name,
|
|
uint maxItems )
|
|
: TDEListAction( text, pix, cut, parent, name)
|
|
{
|
|
d = new TDERecentFilesActionPrivate;
|
|
d->m_maxItems = maxItems;
|
|
|
|
init();
|
|
|
|
if ( receiver )
|
|
connect( this, TQ_SIGNAL(urlSelected(const KURL&)),
|
|
receiver, slot );
|
|
}
|
|
|
|
TDERecentFilesAction::TDERecentFilesAction( TQObject* parent, const char* name,
|
|
uint maxItems )
|
|
: TDEListAction( parent, name )
|
|
{
|
|
d = new TDERecentFilesActionPrivate;
|
|
d->m_maxItems = maxItems;
|
|
|
|
init();
|
|
}
|
|
|
|
void TDERecentFilesAction::init()
|
|
{
|
|
TDERecentFilesAction *that = const_cast<TDERecentFilesAction*>(this);
|
|
that->d->m_popup = new TDEPopupMenu;
|
|
connect(d->m_popup, TQ_SIGNAL(aboutToShow()), this, TQ_SLOT(menuAboutToShow()));
|
|
connect(d->m_popup, TQ_SIGNAL(activated(int)), this, TQ_SLOT(menuItemActivated(int)));
|
|
connect( this, TQ_SIGNAL( activated( const TQString& ) ),
|
|
this, TQ_SLOT( itemSelected( const TQString& ) ) );
|
|
|
|
setMenuAccelsEnabled( false );
|
|
}
|
|
|
|
TDERecentFilesAction::~TDERecentFilesAction()
|
|
{
|
|
delete d->m_popup;
|
|
delete d; d = 0;
|
|
}
|
|
|
|
uint TDERecentFilesAction::maxItems() const
|
|
{
|
|
return d->m_maxItems;
|
|
}
|
|
|
|
void TDERecentFilesAction::setMaxItems( uint maxItems )
|
|
{
|
|
TQStringList lst = TDESelectAction::items();
|
|
uint oldCount = lst.count();
|
|
|
|
// set new maxItems
|
|
d->m_maxItems = maxItems;
|
|
|
|
// remove all items that are too much
|
|
while( lst.count() > maxItems )
|
|
{
|
|
// remove last item
|
|
TQString lastItem = lst.last();
|
|
d->m_shortNames.erase( lastItem );
|
|
d->m_urls.erase( lastItem );
|
|
lst.remove( lastItem );
|
|
}
|
|
|
|
// set new list if changed
|
|
if( lst.count() != oldCount )
|
|
setItems( lst );
|
|
}
|
|
|
|
void TDERecentFilesAction::addURL( const KURL& url )
|
|
{
|
|
addURL( url, url.fileName() );
|
|
}
|
|
|
|
void TDERecentFilesAction::addURL( const KURL& url, const TQString& name )
|
|
{
|
|
if ( url.isLocalFile() && !TDEGlobal::dirs()->relativeLocation("tmp", url.path()).startsWith("/"))
|
|
return;
|
|
const TQString file = url.pathOrURL();
|
|
TQStringList lst = TDESelectAction::items();
|
|
|
|
// remove file if already in list
|
|
const TQStringList::Iterator end = lst.end();
|
|
for ( TQStringList::Iterator it = lst.begin(); it != end; ++it )
|
|
{
|
|
TQString title = (*it);
|
|
if ( title.endsWith( file + "]" ) )
|
|
{
|
|
lst.remove( it );
|
|
d->m_urls.erase( title );
|
|
d->m_shortNames.erase( title );
|
|
break;
|
|
}
|
|
}
|
|
// remove last item if already maxitems in list
|
|
if( lst.count() == d->m_maxItems )
|
|
{
|
|
// remove last item
|
|
const TQString lastItem = lst.last();
|
|
d->m_shortNames.erase( lastItem );
|
|
d->m_urls.erase( lastItem );
|
|
lst.remove( lastItem );
|
|
}
|
|
|
|
// add file to list
|
|
const TQString title = name + " [" + file + "]";
|
|
d->m_shortNames.insert( title, name );
|
|
d->m_urls.insert( title, url );
|
|
lst.prepend( title );
|
|
setItems( lst );
|
|
}
|
|
|
|
void TDERecentFilesAction::removeURL( const KURL& url )
|
|
{
|
|
TQStringList lst = TDESelectAction::items();
|
|
TQString file = url.pathOrURL();
|
|
|
|
// remove url
|
|
TQStringList::Iterator end = lst.end();
|
|
for ( TQStringList::Iterator it = lst.begin(); it != end; ++it )
|
|
{
|
|
if ( (*it).endsWith( file + "]" ))
|
|
{
|
|
d->m_shortNames.erase( (*it) );
|
|
d->m_urls.erase( (*it) );
|
|
lst.remove( it );
|
|
setItems( lst );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDERecentFilesAction::clearURLList()
|
|
{
|
|
clear();
|
|
d->m_shortNames.clear();
|
|
d->m_urls.clear();
|
|
}
|
|
|
|
void TDERecentFilesAction::loadEntries( TDEConfig* config, TQString groupname)
|
|
{
|
|
TQString key;
|
|
TQString value;
|
|
TQString nameKey;
|
|
TQString nameValue;
|
|
TQString title;
|
|
TQString oldGroup;
|
|
TQStringList lst;
|
|
KURL url;
|
|
|
|
oldGroup = config->group();
|
|
|
|
if (groupname.isEmpty())
|
|
groupname = "RecentFiles";
|
|
config->setGroup( groupname );
|
|
|
|
// read file list
|
|
for( unsigned int i = 1 ; i <= d->m_maxItems ; i++ )
|
|
{
|
|
key = TQString( "File%1" ).arg( i );
|
|
value = config->readPathEntry( key );
|
|
url = KURL::fromPathOrURL( value );
|
|
|
|
// Don't restore if file doesn't exist anymore
|
|
if (url.isLocalFile() && !TQFile::exists(url.path()))
|
|
continue;
|
|
|
|
nameKey = TQString( "Name%1" ).arg( i );
|
|
nameValue = config->readPathEntry( nameKey, url.fileName() );
|
|
title = nameValue + " [" + value + "]";
|
|
if (!value.isNull())
|
|
{
|
|
lst.append( title );
|
|
d->m_shortNames.insert( title, nameValue );
|
|
d->m_urls.insert( title, url );
|
|
}
|
|
}
|
|
|
|
// set file
|
|
setItems( lst );
|
|
|
|
config->setGroup( oldGroup );
|
|
}
|
|
|
|
void TDERecentFilesAction::saveEntries( TDEConfig* config, TQString groupname )
|
|
{
|
|
TQString key;
|
|
TQString value;
|
|
TQString oldGroup;
|
|
TQStringList lst = TDESelectAction::items();
|
|
|
|
oldGroup = config->group();
|
|
|
|
if (groupname.isEmpty())
|
|
groupname = "RecentFiles";
|
|
config->deleteGroup( groupname, true );
|
|
config->setGroup( groupname );
|
|
|
|
// write file list
|
|
for( unsigned int i = 1 ; i <= lst.count() ; i++ )
|
|
{
|
|
//kdDebug(129) << "Entry for " << lst[i-1] << d->m_urls[ lst[ i - 1 ] ] << endl;
|
|
key = TQString( "File%1" ).arg( i );
|
|
value = d->m_urls[ lst[ i - 1 ] ].pathOrURL();
|
|
config->writePathEntry( key, value );
|
|
key = TQString( "Name%1" ).arg( i );
|
|
value = d->m_shortNames[ lst[ i - 1 ] ];
|
|
config->writePathEntry( key, value );
|
|
}
|
|
|
|
config->setGroup( oldGroup );
|
|
}
|
|
|
|
void TDERecentFilesAction::itemSelected( const TQString& text )
|
|
{
|
|
//return a copy of the URL since the slot where it is connected might call
|
|
//addURL or removeURL where the d->m_urls.erase( title ) could destroy the
|
|
//d->m_urls[ text ] and the emitted URL will be invalid in the rest of the slot
|
|
emit urlSelected( KURL(d->m_urls[ text ]) );
|
|
}
|
|
|
|
void TDERecentFilesAction::menuItemActivated( int id )
|
|
{
|
|
TQString text = d->m_popup->text(id);
|
|
//return a copy of the URL since the slot where it is connected might call
|
|
//addURL or removeURL where the d->m_urls.erase( title ) could destroy the
|
|
//d->m_urls[ text ] and the emitted URL will be invalid in the rest of the slot
|
|
emit urlSelected( KURL(d->m_urls[ text ]) );
|
|
}
|
|
|
|
void TDERecentFilesAction::menuAboutToShow()
|
|
{
|
|
TDEPopupMenu *menu = d->m_popup;
|
|
menu->clear();
|
|
TQStringList list = TDESelectAction::items();
|
|
for ( TQStringList::Iterator it = list.begin(); it != list.end(); ++it )
|
|
{
|
|
menu->insertItem(*it);
|
|
}
|
|
}
|
|
|
|
int TDERecentFilesAction::plug( TQWidget *widget, int index )
|
|
{
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
// This is very related to TDEActionMenu::plug.
|
|
// In fact this class could be an interesting base class for TDEActionMenu
|
|
if ( ::tqt_cast<TDEToolBar *>( widget ) )
|
|
{
|
|
TDEToolBar *bar = (TDEToolBar *)widget;
|
|
|
|
int id_ = TDEAction::getToolButtonID();
|
|
|
|
TDEInstance * instance;
|
|
if ( m_parentCollection )
|
|
instance = m_parentCollection->instance();
|
|
else
|
|
instance = TDEGlobal::instance();
|
|
|
|
bar->insertButton( icon(), id_, TQ_SIGNAL( clicked() ), this,
|
|
TQ_SLOT( slotClicked() ), isEnabled(), plainText(),
|
|
index, instance );
|
|
|
|
addContainer( bar, id_ );
|
|
|
|
connect( bar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
bar->setDelayedPopup( id_, d->m_popup, true);
|
|
|
|
if ( !whatsThis().isEmpty() )
|
|
TQWhatsThis::add( bar->getButton( id_ ), whatsThisWithIcon() );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
|
|
return TDEListAction::plug( widget, index );
|
|
}
|
|
|
|
void TDERecentFilesAction::slotClicked()
|
|
{
|
|
TDEAction::slotActivated();
|
|
}
|
|
|
|
void TDERecentFilesAction::slotActivated(const TQString& text)
|
|
{
|
|
TDEListAction::slotActivated(text);
|
|
}
|
|
|
|
|
|
void TDERecentFilesAction::slotActivated(int id)
|
|
{
|
|
TDEListAction::slotActivated(id);
|
|
}
|
|
|
|
|
|
void TDERecentFilesAction::slotActivated()
|
|
{
|
|
emit activated( currentItem() );
|
|
emit activated( currentText() );
|
|
}
|
|
|
|
//KDE4: rename to urls() and return a KURL::List
|
|
TQStringList TDERecentFilesAction::items() const
|
|
{
|
|
TQStringList lst = TDESelectAction::items();
|
|
TQStringList result;
|
|
|
|
for( unsigned int i = 1 ; i <= lst.count() ; i++ )
|
|
{
|
|
result += d->m_urls[ lst[ i - 1 ] ].prettyURL(0, KURL::StripFileProtocol);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//KDE4: remove
|
|
TQStringList TDERecentFilesAction::completeItems() const
|
|
{
|
|
return TDESelectAction::items();
|
|
}
|
|
|
|
|
|
class TDEFontAction::TDEFontActionPrivate
|
|
{
|
|
public:
|
|
TDEFontActionPrivate()
|
|
{
|
|
}
|
|
TQStringList m_fonts;
|
|
};
|
|
|
|
TDEFontAction::TDEFontAction( const TQString& text,
|
|
const TDEShortcut& cut, TQObject* parent,
|
|
const char* name )
|
|
: TDESelectAction( text, cut, parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, 0 );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::TDEFontAction( const TQString& text, const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, 0 );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::TDEFontAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, 0 );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::TDEFontAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, 0 );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::TDEFontAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, 0 );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::TDEFontAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, 0 );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::TDEFontAction( uint fontListCriteria, const TQString& text,
|
|
const TDEShortcut& cut, TQObject* parent,
|
|
const char* name )
|
|
: TDESelectAction( text, cut, parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, fontListCriteria );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::TDEFontAction( uint fontListCriteria, const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, fontListCriteria );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::TDEFontAction( TQObject* parent, const char* name )
|
|
: TDESelectAction( parent, name )
|
|
{
|
|
d = new TDEFontActionPrivate;
|
|
TDEFontChooser::getFontList( d->m_fonts, 0 );
|
|
TDESelectAction::setItems( d->m_fonts );
|
|
setEditable( true );
|
|
}
|
|
|
|
TDEFontAction::~TDEFontAction()
|
|
{
|
|
delete d;
|
|
d = 0;
|
|
}
|
|
|
|
/*
|
|
* Maintenance note: Keep in sync with TDEFontCombo::setCurrentFont()
|
|
*/
|
|
void TDEFontAction::setFont( const TQString &family )
|
|
{
|
|
TQString lowerName = family.lower();
|
|
int i = 0;
|
|
for ( TQStringList::Iterator it = d->m_fonts.begin(); it != d->m_fonts.end(); ++it, ++i )
|
|
{
|
|
if ((*it).lower() == lowerName)
|
|
{
|
|
setCurrentItem(i);
|
|
return;
|
|
}
|
|
}
|
|
i = lowerName.find(" [");
|
|
if (i>-1)
|
|
{
|
|
lowerName = lowerName.left(i);
|
|
i = 0;
|
|
for ( TQStringList::Iterator it = d->m_fonts.begin(); it != d->m_fonts.end(); ++it, ++i )
|
|
{
|
|
if ((*it).lower() == lowerName)
|
|
{
|
|
setCurrentItem(i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
lowerName += " [";
|
|
i = 0;
|
|
for ( TQStringList::Iterator it = d->m_fonts.begin(); it != d->m_fonts.end(); ++it, ++i )
|
|
{
|
|
if ((*it).lower().startsWith(lowerName))
|
|
{
|
|
setCurrentItem(i);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// nothing matched yet, try a fontconfig reverse lookup and
|
|
// check again to solve an alias
|
|
FcPattern *pattern = NULL;
|
|
FcConfig *config = NULL;
|
|
FcResult result;
|
|
TQString realFamily;
|
|
TQRegExp regExp("[-:]");
|
|
pattern = FcNameParse( (unsigned char*) family.ascii() );
|
|
FcDefaultSubstitute(pattern);
|
|
FcConfigSubstitute (config, pattern, FcMatchPattern);
|
|
pattern = FcFontMatch(NULL, pattern, &result);
|
|
realFamily = (char*)FcNameUnparse(pattern);
|
|
realFamily.remove(realFamily.find(regExp), realFamily.length());
|
|
|
|
if ( !realFamily.isEmpty() && realFamily != family )
|
|
setFont( realFamily );
|
|
else
|
|
kdDebug(129) << "Font not found " << family.lower() << endl;
|
|
}
|
|
|
|
int TDEFontAction::plug( TQWidget *w, int index )
|
|
{
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
if ( ::tqt_cast<TDEToolBar *>( w ) )
|
|
{
|
|
TDEToolBar* bar = static_cast<TDEToolBar*>( w );
|
|
int id_ = TDEAction::getToolButtonID();
|
|
TDEFontCombo *cb = new TDEFontCombo( items(), bar );
|
|
connect( cb, TQ_SIGNAL( activated( const TQString & ) ),
|
|
TQ_SLOT( slotActivated( const TQString & ) ) );
|
|
cb->setEnabled( isEnabled() );
|
|
bar->insertWidget( id_, comboWidth(), cb, index );
|
|
cb->setMinimumWidth( cb->sizeHint().width() );
|
|
|
|
addContainer( bar, id_ );
|
|
|
|
connect( bar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
updateCurrentItem( containerCount() - 1 );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
else return TDESelectAction::plug( w, index );
|
|
}
|
|
|
|
class TDEFontSizeAction::TDEFontSizeActionPrivate
|
|
{
|
|
public:
|
|
TDEFontSizeActionPrivate()
|
|
{
|
|
}
|
|
};
|
|
|
|
TDEFontSizeAction::TDEFontSizeAction( const TQString& text,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, cut, parent, name )
|
|
{
|
|
init();
|
|
}
|
|
|
|
TDEFontSizeAction::TDEFontSizeAction( const TQString& text,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, cut, receiver, slot, parent, name )
|
|
{
|
|
init();
|
|
}
|
|
|
|
TDEFontSizeAction::TDEFontSizeAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
init();
|
|
}
|
|
|
|
TDEFontSizeAction::TDEFontSizeAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDESelectAction( text, pix, cut, parent, name )
|
|
{
|
|
init();
|
|
}
|
|
|
|
TDEFontSizeAction::TDEFontSizeAction( const TQString& text, const TQIconSet& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDESelectAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
init();
|
|
}
|
|
|
|
TDEFontSizeAction::TDEFontSizeAction( const TQString& text, const TQString& pix,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDESelectAction( text, pix, cut, receiver, slot, parent, name )
|
|
{
|
|
init();
|
|
}
|
|
|
|
TDEFontSizeAction::TDEFontSizeAction( TQObject* parent, const char* name )
|
|
: TDESelectAction( parent, name )
|
|
{
|
|
init();
|
|
}
|
|
|
|
TDEFontSizeAction::~TDEFontSizeAction()
|
|
{
|
|
delete d;
|
|
d = 0;
|
|
}
|
|
|
|
void TDEFontSizeAction::init()
|
|
{
|
|
d = new TDEFontSizeActionPrivate;
|
|
|
|
setEditable( true );
|
|
TQFontDatabase fontDB;
|
|
TQValueList<int> sizes = fontDB.standardSizes();
|
|
TQStringList lst;
|
|
for ( TQValueList<int>::Iterator it = sizes.begin(); it != sizes.end(); ++it )
|
|
lst.append( TQString::number( *it ) );
|
|
|
|
setItems( lst );
|
|
}
|
|
|
|
void TDEFontSizeAction::setFontSize( int size )
|
|
{
|
|
if ( size == fontSize() ) {
|
|
setCurrentItem( items().findIndex( TQString::number( size ) ) );
|
|
return;
|
|
}
|
|
|
|
if ( size < 1 ) {
|
|
kdWarning() << "TDEFontSizeAction: Size " << size << " is out of range" << endl;
|
|
return;
|
|
}
|
|
|
|
int index = items().findIndex( TQString::number( size ) );
|
|
if ( index == -1 ) {
|
|
// Insert at the correct position in the list (to keep sorting)
|
|
TQValueList<int> lst;
|
|
// Convert to list of ints
|
|
TQStringList itemsList = items();
|
|
for (TQStringList::Iterator it = itemsList.begin() ; it != itemsList.end() ; ++it)
|
|
lst.append( (*it).toInt() );
|
|
// New size
|
|
lst.append( size );
|
|
// Sort the list
|
|
qHeapSort( lst );
|
|
// Convert back to string list
|
|
TQStringList strLst;
|
|
for (TQValueList<int>::Iterator it = lst.begin() ; it != lst.end() ; ++it)
|
|
strLst.append( TQString::number(*it) );
|
|
TDESelectAction::setItems( strLst );
|
|
// Find new current item
|
|
index = lst.findIndex( size );
|
|
setCurrentItem( index );
|
|
}
|
|
else
|
|
setCurrentItem( index );
|
|
|
|
|
|
//emit TDEAction::activated();
|
|
//emit activated( index );
|
|
//emit activated( TQString::number( size ) );
|
|
//emit fontSizeChanged( size );
|
|
}
|
|
|
|
int TDEFontSizeAction::fontSize() const
|
|
{
|
|
return currentText().toInt();
|
|
}
|
|
|
|
void TDEFontSizeAction::slotActivated( int index )
|
|
{
|
|
TDESelectAction::slotActivated( index );
|
|
|
|
emit fontSizeChanged( items()[ index ].toInt() );
|
|
}
|
|
|
|
void TDEFontSizeAction::slotActivated( const TQString& size )
|
|
{
|
|
setFontSize( size.toInt() ); // insert sorted first
|
|
TDESelectAction::slotActivated( size );
|
|
emit fontSizeChanged( size.toInt() );
|
|
}
|
|
|
|
class TDEActionMenu::TDEActionMenuPrivate
|
|
{
|
|
public:
|
|
TDEActionMenuPrivate()
|
|
{
|
|
m_popup = new TDEPopupMenu(0L,"TDEActionMenu::TDEActionMenuPrivate");
|
|
m_delayed = true;
|
|
m_stickyMenu = true;
|
|
}
|
|
~TDEActionMenuPrivate()
|
|
{
|
|
delete m_popup; m_popup = 0;
|
|
}
|
|
TDEPopupMenu *m_popup;
|
|
bool m_delayed;
|
|
bool m_stickyMenu;
|
|
};
|
|
|
|
TDEActionMenu::TDEActionMenu( TQObject* parent, const char* name )
|
|
: TDEAction( parent, name )
|
|
{
|
|
d = new TDEActionMenuPrivate;
|
|
setShortcutConfigurable( false );
|
|
}
|
|
|
|
TDEActionMenu::TDEActionMenu( const TQString& text, TQObject* parent,
|
|
const char* name )
|
|
: TDEAction( text, 0, parent, name )
|
|
{
|
|
d = new TDEActionMenuPrivate;
|
|
setShortcutConfigurable( false );
|
|
}
|
|
|
|
TDEActionMenu::TDEActionMenu( const TQString& text, const TQIconSet& icon,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, icon, 0, parent, name )
|
|
{
|
|
d = new TDEActionMenuPrivate;
|
|
setShortcutConfigurable( false );
|
|
}
|
|
|
|
TDEActionMenu::TDEActionMenu( const TQString& text, const TQString& icon,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, icon, 0, parent, name )
|
|
{
|
|
d = new TDEActionMenuPrivate;
|
|
setShortcutConfigurable( false );
|
|
}
|
|
|
|
TDEActionMenu::~TDEActionMenu()
|
|
{
|
|
unplugAll();
|
|
kdDebug(129) << "TDEActionMenu::~TDEActionMenu()" << endl; // ellis
|
|
delete d; d = 0;
|
|
}
|
|
|
|
void TDEActionMenu::popup( const TQPoint& global )
|
|
{
|
|
popupMenu()->popup( global );
|
|
}
|
|
|
|
TDEPopupMenu* TDEActionMenu::popupMenu() const
|
|
{
|
|
return d->m_popup;
|
|
}
|
|
|
|
void TDEActionMenu::insert( TDEAction* cmd, int index )
|
|
{
|
|
if ( cmd )
|
|
cmd->plug( d->m_popup, index );
|
|
}
|
|
|
|
void TDEActionMenu::remove( TDEAction* cmd )
|
|
{
|
|
if ( cmd )
|
|
cmd->unplug( d->m_popup );
|
|
}
|
|
|
|
bool TDEActionMenu::delayed() const {
|
|
return d->m_delayed;
|
|
}
|
|
|
|
void TDEActionMenu::setDelayed(bool _delayed) {
|
|
d->m_delayed = _delayed;
|
|
}
|
|
|
|
bool TDEActionMenu::stickyMenu() const {
|
|
return d->m_stickyMenu;
|
|
}
|
|
|
|
void TDEActionMenu::setStickyMenu(bool sticky) {
|
|
d->m_stickyMenu = sticky;
|
|
}
|
|
|
|
int TDEActionMenu::plug( TQWidget* widget, int index )
|
|
{
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
kdDebug(129) << "TDEActionMenu::plug( " << widget << ", " << index << " )" << endl; // remove -- ellis
|
|
if ( ::tqt_cast<TQPopupMenu *>( widget ) )
|
|
{
|
|
TQPopupMenu* menu = static_cast<TQPopupMenu*>( widget );
|
|
int id;
|
|
if ( hasIcon() )
|
|
id = menu->insertItem( iconSet(), text(), d->m_popup, -1, index );
|
|
else
|
|
id = menu->insertItem( text(), d->m_popup, -1, index );
|
|
|
|
if ( !isEnabled() )
|
|
menu->setItemEnabled( id, false );
|
|
|
|
addContainer( menu, id );
|
|
connect( menu, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
if ( m_parentCollection )
|
|
m_parentCollection->connectHighlight( menu, this );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
else if ( ::tqt_cast<TDEToolBar *>( widget ) )
|
|
{
|
|
TDEToolBar *bar = static_cast<TDEToolBar *>( widget );
|
|
|
|
int id_ = TDEAction::getToolButtonID();
|
|
|
|
if ( icon().isEmpty() && !iconSet().isNull() )
|
|
bar->insertButton( iconSet().pixmap(), id_, TQ_SIGNAL( clicked() ), this,
|
|
TQ_SLOT( slotActivated() ), isEnabled(), plainText(),
|
|
index );
|
|
else
|
|
{
|
|
TDEInstance *instance;
|
|
|
|
if ( m_parentCollection )
|
|
instance = m_parentCollection->instance();
|
|
else
|
|
instance = TDEGlobal::instance();
|
|
|
|
bar->insertButton( icon(), id_, TQ_SIGNAL( clicked() ), this,
|
|
TQ_SLOT( slotActivated() ), isEnabled(), plainText(),
|
|
index, instance );
|
|
}
|
|
|
|
addContainer( bar, id_ );
|
|
|
|
if (!whatsThis().isEmpty())
|
|
TQWhatsThis::add( bar->getButton(id_), whatsThis() );
|
|
|
|
connect( bar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
if (delayed()) {
|
|
bar->setDelayedPopup( id_, popupMenu(), stickyMenu() );
|
|
} else {
|
|
bar->getButton(id_)->setPopup(popupMenu(), stickyMenu() );
|
|
}
|
|
|
|
if ( m_parentCollection )
|
|
m_parentCollection->connectHighlight( bar, this );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
else if ( ::tqt_cast<TQMenuBar *>( widget ) )
|
|
{
|
|
TQMenuBar *bar = static_cast<TQMenuBar *>( widget );
|
|
|
|
int id;
|
|
|
|
id = bar->insertItem( text(), popupMenu(), -1, index );
|
|
|
|
if ( !isEnabled() )
|
|
bar->setItemEnabled( id, false );
|
|
|
|
addContainer( bar, id );
|
|
connect( bar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
////////
|
|
|
|
TDEToolBarPopupAction::TDEToolBarPopupAction( const TQString& text,
|
|
const TQString& icon,
|
|
const TDEShortcut& cut,
|
|
TQObject* parent, const char* name )
|
|
: TDEAction( text, icon, cut, parent, name )
|
|
{
|
|
m_popup = 0;
|
|
m_delayed = true;
|
|
m_stickyMenu = true;
|
|
}
|
|
|
|
TDEToolBarPopupAction::TDEToolBarPopupAction( const TQString& text,
|
|
const TQString& icon,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name )
|
|
: TDEAction( text, icon, cut, receiver, slot, parent, name )
|
|
{
|
|
m_popup = 0;
|
|
m_delayed = true;
|
|
m_stickyMenu = true;
|
|
}
|
|
|
|
TDEToolBarPopupAction::TDEToolBarPopupAction( const KGuiItem& item,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TDEActionCollection* parent,
|
|
const char* name )
|
|
: TDEAction( item, cut, receiver, slot, parent, name )
|
|
{
|
|
m_popup = 0;
|
|
m_delayed = true;
|
|
m_stickyMenu = true;
|
|
}
|
|
|
|
TDEToolBarPopupAction::~TDEToolBarPopupAction()
|
|
{
|
|
delete m_popup;
|
|
}
|
|
|
|
bool TDEToolBarPopupAction::delayed() const {
|
|
return m_delayed;
|
|
}
|
|
|
|
void TDEToolBarPopupAction::setDelayed(bool delayed) {
|
|
m_delayed = delayed;
|
|
}
|
|
|
|
bool TDEToolBarPopupAction::stickyMenu() const {
|
|
return m_stickyMenu;
|
|
}
|
|
|
|
void TDEToolBarPopupAction::setStickyMenu(bool sticky) {
|
|
m_stickyMenu = sticky;
|
|
}
|
|
|
|
int TDEToolBarPopupAction::plug( TQWidget *widget, int index )
|
|
{
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
// This is very related to TDEActionMenu::plug.
|
|
// In fact this class could be an interesting base class for TDEActionMenu
|
|
if ( ::tqt_cast<TDEToolBar *>( widget ) )
|
|
{
|
|
TDEToolBar *bar = (TDEToolBar *)widget;
|
|
|
|
int id_ = TDEAction::getToolButtonID();
|
|
|
|
if ( icon().isEmpty() && !iconSet().isNull() ) {
|
|
bar->insertButton( iconSet().pixmap(), id_, TQ_SIGNAL( buttonClicked(int, TQt::ButtonState) ), this,
|
|
TQ_SLOT( slotButtonClicked(int, TQt::ButtonState) ),
|
|
isEnabled(), plainText(),
|
|
index );
|
|
} else {
|
|
TDEInstance * instance;
|
|
if ( m_parentCollection )
|
|
instance = m_parentCollection->instance();
|
|
else
|
|
instance = TDEGlobal::instance();
|
|
|
|
bar->insertButton( icon(), id_, TQ_SIGNAL( buttonClicked(int, TQt::ButtonState) ), this,
|
|
TQ_SLOT( slotButtonClicked(int, TQt::ButtonState) ),
|
|
isEnabled(), plainText(),
|
|
index, instance );
|
|
}
|
|
|
|
addContainer( bar, id_ );
|
|
|
|
connect( bar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
if (delayed()) {
|
|
bar->setDelayedPopup( id_, popupMenu(), stickyMenu() );
|
|
} else {
|
|
bar->getButton(id_)->setPopup(popupMenu(), stickyMenu());
|
|
}
|
|
|
|
if ( !whatsThis().isEmpty() )
|
|
TQWhatsThis::add( bar->getButton( id_ ), whatsThisWithIcon() );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
|
|
return TDEAction::plug( widget, index );
|
|
}
|
|
|
|
TDEPopupMenu *TDEToolBarPopupAction::popupMenu() const
|
|
{
|
|
if ( !m_popup ) {
|
|
TDEToolBarPopupAction *that = const_cast<TDEToolBarPopupAction*>(this);
|
|
that->m_popup = new TDEPopupMenu;
|
|
}
|
|
return m_popup;
|
|
}
|
|
|
|
////////
|
|
|
|
TDEToggleToolBarAction::TDEToggleToolBarAction( const char* toolBarName,
|
|
const TQString& text, TDEActionCollection* parent, const char* name )
|
|
: TDEToggleAction( text, TDEShortcut(), parent, name )
|
|
, m_toolBarName( toolBarName )
|
|
, m_toolBar( 0L )
|
|
{
|
|
}
|
|
|
|
TDEToggleToolBarAction::TDEToggleToolBarAction( TDEToolBar *toolBar, const TQString &text,
|
|
TDEActionCollection *parent, const char *name )
|
|
: TDEToggleAction( text, TDEShortcut(), parent, name )
|
|
, m_toolBarName( 0 ), m_toolBar( toolBar )
|
|
{
|
|
}
|
|
|
|
TDEToggleToolBarAction::~TDEToggleToolBarAction()
|
|
{
|
|
}
|
|
|
|
int TDEToggleToolBarAction::plug( TQWidget* w, int index )
|
|
{
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
|
|
if ( !m_toolBar ) {
|
|
// Note: topLevelWidget() stops too early, we can't use it.
|
|
TQWidget * tl = w;
|
|
TQWidget * n;
|
|
while ( !tl->isDialog() && ( n = tl->parentWidget() ) ) // lookup parent and store
|
|
tl = n;
|
|
|
|
TDEMainWindow * mw = dynamic_cast<TDEMainWindow *>(tl); // try to see if it's a tdemainwindow
|
|
|
|
if ( mw )
|
|
m_toolBar = mw->toolBar( m_toolBarName );
|
|
}
|
|
|
|
if( m_toolBar ) {
|
|
setChecked( m_toolBar->isVisible() );
|
|
connect( m_toolBar, TQ_SIGNAL(visibilityChanged(bool)), this, TQ_SLOT(setChecked(bool)) );
|
|
// Also emit toggled when the toolbar's visibility changes (see comment in header)
|
|
connect( m_toolBar, TQ_SIGNAL(visibilityChanged(bool)), this, TQ_SIGNAL(toggled(bool)) );
|
|
} else {
|
|
setEnabled( false );
|
|
}
|
|
|
|
return TDEToggleAction::plug( w, index );
|
|
}
|
|
|
|
void TDEToggleToolBarAction::setChecked( bool c )
|
|
{
|
|
if( m_toolBar && c != m_toolBar->isVisible() ) {
|
|
if( c ) {
|
|
m_toolBar->show();
|
|
} else {
|
|
m_toolBar->hide();
|
|
}
|
|
TQMainWindow* mw = m_toolBar->mainWindow();
|
|
if ( mw && ::tqt_cast<TDEMainWindow *>( mw ) )
|
|
static_cast<TDEMainWindow *>( mw )->setSettingsDirty();
|
|
}
|
|
TDEToggleAction::setChecked( c );
|
|
}
|
|
|
|
////////
|
|
|
|
TDEToggleFullScreenAction::TDEToggleFullScreenAction( const TDEShortcut &cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TQObject* parent, TQWidget* window,
|
|
const char* name )
|
|
: TDEToggleAction( TQString::null, cut, receiver, slot, parent, name ),
|
|
window( NULL )
|
|
{
|
|
setWindow( window );
|
|
}
|
|
|
|
TDEToggleFullScreenAction::~TDEToggleFullScreenAction()
|
|
{
|
|
}
|
|
|
|
void TDEToggleFullScreenAction::setWindow( TQWidget* w )
|
|
{
|
|
if( window )
|
|
window->removeEventFilter( this );
|
|
window = w;
|
|
if( window )
|
|
window->installEventFilter( this );
|
|
}
|
|
|
|
void TDEToggleFullScreenAction::setChecked( bool c )
|
|
{
|
|
if (c)
|
|
{
|
|
setText(i18n("Exit F&ull Screen Mode"));
|
|
setIcon("view-restore");
|
|
}
|
|
else
|
|
{
|
|
setText(i18n("F&ull Screen Mode"));
|
|
setIcon("view-fullscreen");
|
|
}
|
|
TDEToggleAction::setChecked( c );
|
|
}
|
|
|
|
bool TDEToggleFullScreenAction::eventFilter( TQObject* o, TQEvent* e )
|
|
{
|
|
if( o == window )
|
|
if( e->type() == TQEvent::WindowStateChange )
|
|
{
|
|
if( window->isFullScreen() != isChecked())
|
|
slotActivated(); // setChecked( window->isFullScreen()) wouldn't emit signals
|
|
}
|
|
return false;
|
|
}
|
|
|
|
////////
|
|
|
|
KWidgetAction::KWidgetAction( TQWidget* widget,
|
|
const TQString& text, const TDEShortcut& cut,
|
|
const TQObject* receiver, const char* slot,
|
|
TDEActionCollection* parent, const char* name )
|
|
: TDEAction( text, cut, receiver, slot, parent, name )
|
|
, m_widget( widget )
|
|
, m_autoSized( false )
|
|
{
|
|
connect( this, TQ_SIGNAL(enabled(bool)), widget, TQ_SLOT(setEnabled(bool)) );
|
|
}
|
|
|
|
KWidgetAction::~KWidgetAction()
|
|
{
|
|
}
|
|
|
|
void KWidgetAction::setAutoSized( bool autoSized )
|
|
{
|
|
if( m_autoSized == autoSized )
|
|
return;
|
|
|
|
m_autoSized = autoSized;
|
|
|
|
if( !m_widget || !isPlugged() )
|
|
return;
|
|
|
|
TDEToolBar* toolBar = (TDEToolBar*)m_widget->parent();
|
|
int i = findContainer( toolBar );
|
|
if ( i == -1 )
|
|
return;
|
|
int id = itemId( i );
|
|
|
|
toolBar->setItemAutoSized( id, m_autoSized );
|
|
}
|
|
|
|
int KWidgetAction::plug( TQWidget* w, int index )
|
|
{
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
|
|
if ( !::tqt_cast<TDEToolBar *>( w ) ) {
|
|
kdError() << "KWidgetAction::plug: KWidgetAction must be plugged into TDEToolBar." << endl;
|
|
return -1;
|
|
}
|
|
if ( !m_widget ) {
|
|
kdError() << "KWidgetAction::plug: Widget was deleted or null!" << endl;
|
|
return -1;
|
|
}
|
|
|
|
TDEToolBar* toolBar = static_cast<TDEToolBar*>( w );
|
|
|
|
int id = TDEAction::getToolButtonID();
|
|
|
|
m_widget->reparent( toolBar, TQPoint() );
|
|
toolBar->insertWidget( id, 0, m_widget, index );
|
|
toolBar->setItemAutoSized( id, m_autoSized );
|
|
|
|
TQWhatsThis::add( m_widget, whatsThis() );
|
|
addContainer( toolBar, id );
|
|
|
|
connect( toolBar, TQ_SIGNAL( toolbarDestroyed() ), this, TQ_SLOT( slotToolbarDestroyed() ) );
|
|
connect( toolBar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
|
|
void KWidgetAction::unplug( TQWidget *w )
|
|
{
|
|
if( !m_widget || !isPlugged() )
|
|
return;
|
|
|
|
TDEToolBar* toolBar = (TDEToolBar*)m_widget->parent();
|
|
if ( toolBar == w )
|
|
{
|
|
disconnect( toolBar, TQ_SIGNAL( toolbarDestroyed() ), this, TQ_SLOT( slotToolbarDestroyed() ) );
|
|
m_widget->reparent( 0L, TQPoint(), false /*showIt*/ );
|
|
}
|
|
TDEAction::unplug( w );
|
|
}
|
|
|
|
void KWidgetAction::slotToolbarDestroyed()
|
|
{
|
|
//Q_ASSERT( m_widget ); // When exiting the app the widget could be destroyed before the toolbar.
|
|
Q_ASSERT( isPlugged() );
|
|
if( !m_widget || !isPlugged() )
|
|
return;
|
|
|
|
// Don't let a toolbar being destroyed, delete my widget.
|
|
m_widget->reparent( 0L, TQPoint(), false /*showIt*/ );
|
|
}
|
|
|
|
////////
|
|
|
|
TDEActionSeparator::TDEActionSeparator( TQObject *parent, const char *name )
|
|
: TDEAction( parent, name )
|
|
{
|
|
}
|
|
|
|
TDEActionSeparator::~TDEActionSeparator()
|
|
{
|
|
}
|
|
|
|
int TDEActionSeparator::plug( TQWidget *widget, int index )
|
|
{
|
|
if ( ::tqt_cast<TQPopupMenu *>( widget) )
|
|
{
|
|
TQPopupMenu* menu = static_cast<TQPopupMenu*>( widget );
|
|
|
|
int id = menu->insertSeparator( index );
|
|
|
|
addContainer( menu, id );
|
|
connect( menu, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
else if ( ::tqt_cast<TQMenuBar *>( widget ) )
|
|
{
|
|
TQMenuBar *menuBar = static_cast<TQMenuBar *>( widget );
|
|
|
|
int id = menuBar->insertSeparator( index );
|
|
|
|
addContainer( menuBar, id );
|
|
|
|
connect( menuBar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
else if ( ::tqt_cast<TDEToolBar *>( widget ) )
|
|
{
|
|
TDEToolBar *toolBar = static_cast<TDEToolBar *>( widget );
|
|
|
|
int id = toolBar->insertSeparator( index );
|
|
|
|
addContainer( toolBar, id );
|
|
|
|
connect( toolBar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
TDEPasteTextAction::TDEPasteTextAction( const TQString& text,
|
|
const TQString& icon,
|
|
const TDEShortcut& cut,
|
|
const TQObject* receiver,
|
|
const char* slot, TQObject* parent,
|
|
const char* name)
|
|
: TDEAction( text, icon, cut, receiver, slot, parent, name )
|
|
{
|
|
m_popup = new TDEPopupMenu;
|
|
connect(m_popup, TQ_SIGNAL(aboutToShow()), this, TQ_SLOT(menuAboutToShow()));
|
|
connect(m_popup, TQ_SIGNAL(activated(int)), this, TQ_SLOT(menuItemActivated(int)));
|
|
m_popup->setCheckable(true);
|
|
m_mixedMode = true;
|
|
}
|
|
|
|
TDEPasteTextAction::~TDEPasteTextAction()
|
|
{
|
|
delete m_popup;
|
|
}
|
|
|
|
void TDEPasteTextAction::setMixedMode(bool mode)
|
|
{
|
|
m_mixedMode = mode;
|
|
}
|
|
|
|
int TDEPasteTextAction::plug( TQWidget *widget, int index )
|
|
{
|
|
if (kapp && !kapp->authorizeTDEAction(name()))
|
|
return -1;
|
|
if ( ::tqt_cast<TDEToolBar *>( widget ) )
|
|
{
|
|
TDEToolBar *bar = (TDEToolBar *)widget;
|
|
|
|
int id_ = TDEAction::getToolButtonID();
|
|
|
|
TDEInstance * instance;
|
|
if ( m_parentCollection )
|
|
instance = m_parentCollection->instance();
|
|
else
|
|
instance = TDEGlobal::instance();
|
|
|
|
bar->insertButton( icon(), id_, TQ_SIGNAL( clicked() ), this,
|
|
TQ_SLOT( slotActivated() ), isEnabled(), plainText(),
|
|
index, instance );
|
|
|
|
addContainer( bar, id_ );
|
|
|
|
connect( bar, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDestroyed() ) );
|
|
|
|
bar->setDelayedPopup( id_, m_popup, true );
|
|
|
|
if ( !whatsThis().isEmpty() )
|
|
TQWhatsThis::add( bar->getButton( id_ ), whatsThisWithIcon() );
|
|
|
|
return containerCount() - 1;
|
|
}
|
|
|
|
return TDEAction::plug( widget, index );
|
|
}
|
|
|
|
void TDEPasteTextAction::menuAboutToShow()
|
|
{
|
|
m_popup->clear();
|
|
TQStringList list;
|
|
DCOPClient *client = kapp->dcopClient();
|
|
if (client->isAttached() && client->isApplicationRegistered("klipper")) {
|
|
DCOPRef klipper("klipper","klipper");
|
|
DCOPReply reply = klipper.call("getClipboardHistoryMenu");
|
|
if (reply.isValid())
|
|
list = reply;
|
|
}
|
|
TQString clipboardText = tqApp->clipboard()->text(TQClipboard::Clipboard);
|
|
if (list.isEmpty())
|
|
list << clipboardText;
|
|
bool found = false;
|
|
for ( TQStringList::ConstIterator it = list.begin(); it != list.end(); ++it )
|
|
{
|
|
TQString text = KStringHandler::cEmSqueeze((*it).simplifyWhiteSpace(), m_popup->fontMetrics(), 20);
|
|
text.replace("&", "&&");
|
|
int id = m_popup->insertItem(text);
|
|
if (!found && *it == clipboardText)
|
|
{
|
|
m_popup->setItemChecked(id, true);
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDEPasteTextAction::menuItemActivated( int id)
|
|
{
|
|
DCOPClient *client = kapp->dcopClient();
|
|
if (client->isAttached() && client->isApplicationRegistered("klipper")) {
|
|
DCOPRef klipper("klipper","klipper");
|
|
DCOPReply reply = klipper.call("getClipboardHistoryItem(int)", m_popup->indexOf(id));
|
|
if (!reply.isValid())
|
|
return;
|
|
TQString clipboardText = reply;
|
|
reply = klipper.call("setClipboardContents(TQString)", clipboardText);
|
|
if (reply.isValid())
|
|
kdDebug(129) << "Clipboard: " << TQString(tqApp->clipboard()->text(TQClipboard::Clipboard)) << endl;
|
|
}
|
|
TQTimer::singleShot(20, this, TQ_SLOT(slotActivated()));
|
|
}
|
|
|
|
void TDEPasteTextAction::slotActivated()
|
|
{
|
|
if (!m_mixedMode) {
|
|
TQWidget *w = tqApp->widgetAt(TQCursor::pos(), true);
|
|
TQMimeSource *data = TQApplication::clipboard()->data();
|
|
if (!data->provides("text/plain") && w) {
|
|
m_popup->popup(w->mapToGlobal(TQPoint(0, w->height())));
|
|
} else
|
|
TDEAction::slotActivated();
|
|
} else
|
|
TDEAction::slotActivated();
|
|
}
|
|
|
|
|
|
void TDEToggleAction::virtual_hook( int id, void* data )
|
|
{ TDEAction::virtual_hook( id, data ); }
|
|
|
|
void TDERadioAction::virtual_hook( int id, void* data )
|
|
{ TDEToggleAction::virtual_hook( id, data ); }
|
|
|
|
void TDESelectAction::virtual_hook( int id, void* data )
|
|
{ TDEAction::virtual_hook( id, data ); }
|
|
|
|
void TDEListAction::virtual_hook( int id, void* data )
|
|
{ TDESelectAction::virtual_hook( id, data ); }
|
|
|
|
void TDERecentFilesAction::virtual_hook( int id, void* data )
|
|
{ TDEListAction::virtual_hook( id, data ); }
|
|
|
|
void TDEFontAction::virtual_hook( int id, void* data )
|
|
{ TDESelectAction::virtual_hook( id, data ); }
|
|
|
|
void TDEFontSizeAction::virtual_hook( int id, void* data )
|
|
{ TDESelectAction::virtual_hook( id, data ); }
|
|
|
|
void TDEActionMenu::virtual_hook( int id, void* data )
|
|
{ TDEAction::virtual_hook( id, data ); }
|
|
|
|
void TDEToolBarPopupAction::virtual_hook( int id, void* data )
|
|
{ TDEAction::virtual_hook( id, data ); }
|
|
|
|
void TDEToggleToolBarAction::virtual_hook( int id, void* data )
|
|
{ TDEToggleAction::virtual_hook( id, data ); }
|
|
|
|
void TDEToggleFullScreenAction::virtual_hook( int id, void* data )
|
|
{ TDEToggleAction::virtual_hook( id, data ); }
|
|
|
|
void KWidgetAction::virtual_hook( int id, void* data )
|
|
{ TDEAction::virtual_hook( id, data ); }
|
|
|
|
void TDEActionSeparator::virtual_hook( int id, void* data )
|
|
{ TDEAction::virtual_hook( id, data ); }
|
|
|
|
void TDEPasteTextAction::virtual_hook( int id, void* data )
|
|
{ TDEAction::virtual_hook( id, data ); }
|
|
|
|
#include "tdeactionclasses.moc"
|