From d888cfa39e8b38abe17f3d425d19cb8235136a79 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Fri, 1 Feb 2013 17:25:43 -0600 Subject: Fix FTBFS --- tdeui/tdetoolbar.cpp | 2264 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2264 insertions(+) create mode 100644 tdeui/tdetoolbar.cpp (limited to 'tdeui/tdetoolbar.cpp') diff --git a/tdeui/tdetoolbar.cpp b/tdeui/tdetoolbar.cpp new file mode 100644 index 000000000..71d182275 --- /dev/null +++ b/tdeui/tdetoolbar.cpp @@ -0,0 +1,2264 @@ +/* This file is part of the KDE libraries + Copyright + (C) 2000 Reginald Stadlbauer (reggie@kde.org) + (C) 1997, 1998 Stephan Kulow (coolo@kde.org) + (C) 1997, 1998 Mark Donohoe (donohoe@kde.org) + (C) 1997, 1998 Sven Radej (radej@kde.org) + (C) 1997, 1998 Matthias Ettrich (ettrich@kde.org) + (C) 1999 Chris Schlaeger (cs@kde.org) + (C) 1999 Kurt Granroth (granroth@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 + +#ifdef KDE_USE_FINAL +#undef Always +#include +#endif + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +enum { + CONTEXT_TOP = 0, + CONTEXT_LEFT = 1, + CONTEXT_RIGHT = 2, + CONTEXT_BOTTOM = 3, + CONTEXT_FLOAT = 4, + CONTEXT_FLAT = 5, + CONTEXT_ICONS = 6, + CONTEXT_TEXT = 7, + CONTEXT_TEXTRIGHT = 8, + CONTEXT_TEXTUNDER = 9, + CONTEXT_ICONSIZES = 50 // starting point for the icon size list, put everything else before +}; + +class TDEToolBarPrivate +{ +public: + TDEToolBarPrivate() { + m_iconSize = 0; + m_iconText = TDEToolBar::IconOnly; + m_highlight = true; + m_transparent = true; + m_honorStyle = false; + + m_enableContext = true; + + m_xmlguiClient = 0; + + oldPos = TQt::DockUnmanaged; + + modified = m_isHorizontal = positioned = false; + + IconSizeDefault = 0; + IconTextDefault = "IconOnly"; + + NewLineDefault = false; + OffsetDefault = 0; + PositionDefault = "Top"; + HiddenDefault = false; + idleButtons.setAutoDelete(true); + } + + int m_iconSize; + TDEToolBar::IconText m_iconText; + bool m_highlight : 1; + bool m_transparent : 1; + bool m_honorStyle : 1; + bool m_isHorizontal : 1; + bool m_enableContext : 1; + bool modified : 1; + bool positioned : 1; + + TQWidget *m_parent; + + TQMainWindow::ToolBarDock oldPos; + + KXMLGUIClient *m_xmlguiClient; + + struct ToolBarInfo + { + ToolBarInfo() : index( -1 ), offset( -1 ), newline( false ), dock( TQt::DockTop ) {} + ToolBarInfo( TQt::Dock d, int i, bool n, int o ) : index( i ), offset( o ), newline( n ), dock( d ) {} + int index, offset; + bool newline; + TQt::Dock dock; + }; + + ToolBarInfo toolBarInfo; + TQValueList iconSizes; + TQTimer repaintTimer; + + // Default Values. + bool HiddenDefault; + int IconSizeDefault; + TQString IconTextDefault; + bool NewLineDefault; + int OffsetDefault; + TQString PositionDefault; + + TQPtrList idleButtons; +}; + +TDEToolBarSeparator::TDEToolBarSeparator(Orientation o , bool l, TQToolBar *parent, + const char* name ) + :TQFrame( parent, name ), line( l ) +{ + connect( parent, TQT_SIGNAL(orientationChanged(Orientation)), + this, TQT_SLOT(setOrientation(Orientation)) ); + setOrientation( o ); + setBackgroundMode( parent->backgroundMode() ); + setBackgroundOrigin( ParentOrigin ); +} + +void TDEToolBarSeparator::setOrientation( Orientation o ) +{ + orient = o; + setFrameStyle( NoFrame ); +} + +void TDEToolBarSeparator::drawContents( TQPainter* p ) +{ + if ( line ) { + TQStyle::SFlags flags = TQStyle::Style_Default; + + if ( orientation() == Qt::Horizontal ) + flags = flags | TQStyle::Style_Horizontal; + + style().tqdrawPrimitive(TQStyle::PE_DockWindowSeparator, p, + contentsRect(), colorGroup(), flags); + } else { + TQFrame::drawContents(p); + } +} + +void TDEToolBarSeparator::styleChange( TQStyle& ) +{ + setOrientation( orient ); +} + +TQSize TDEToolBarSeparator::sizeHint() const +{ + int dim = style().pixelMetric( TQStyle::PM_DockWindowSeparatorExtent, this ); + return orientation() == Qt::Vertical ? TQSize( 0, dim ) : TQSize( dim, 0 ); +} + +TQSizePolicy TDEToolBarSeparator::sizePolicy() const +{ + return TQSizePolicy( TQSizePolicy::Minimum, TQSizePolicy::Minimum ); +} + +TDEToolBar::TDEToolBar( TQWidget *parent, const char *name, bool honorStyle, bool readConfig ) + : TQToolBar( TQString::fromLatin1( name ), + tqt_dynamic_cast(parent), + parent, false, + name ? name : "mainToolBar") +{ + init( readConfig, honorStyle ); +} + +TDEToolBar::TDEToolBar( TQMainWindow *parentWindow, TQMainWindow::ToolBarDock dock, bool newLine, const char *name, bool honorStyle, bool readConfig ) + : TQToolBar( TQString::fromLatin1( name ), + parentWindow, dock, newLine, + name ? name : "mainToolBar") +{ + init( readConfig, honorStyle ); +} + +TDEToolBar::TDEToolBar( TQMainWindow *parentWindow, TQWidget *dock, bool newLine, const char *name, bool honorStyle, bool readConfig ) + : TQToolBar( TQString::fromLatin1( name ), + parentWindow, dock, newLine, + name ? name : "mainToolBar") +{ + init( readConfig, honorStyle ); +} + +TDEToolBar::~TDEToolBar() +{ + emit toolbarDestroyed(); + delete d; +} + +void TDEToolBar::init( bool readConfig, bool honorStyle ) +{ + d = new TDEToolBarPrivate; + setFullSize( true ); + d->m_honorStyle = honorStyle; + context = 0; + layoutTimer = new TQTimer( this ); + connect( layoutTimer, TQT_SIGNAL( timeout() ), + this, TQT_SLOT( rebuildLayout() ) ); + connect( &(d->repaintTimer), TQT_SIGNAL( timeout() ), + this, TQT_SLOT( slotRepaint() ) ); + + if ( kapp ) { // may be null when started inside designer + connect(kapp, TQT_SIGNAL(toolbarAppearanceChanged(int)), this, TQT_SLOT(slotAppearanceChanged())); + // request notification of changes in icon style + kapp->addKipcEventMask(KIPC::IconChanged); + connect(kapp, TQT_SIGNAL(iconChanged(int)), this, TQT_SLOT(slotIconChanged(int))); + } + + // finally, read in our configurable settings + if ( readConfig ) + slotReadConfig(); + + if ( mainWindow() ) + connect( mainWindow(), TQT_SIGNAL( toolBarPositionChanged( TQToolBar * ) ), + this, TQT_SLOT( toolBarPosChanged( TQToolBar * ) ) ); + + // Hack to make sure we recalculate our size when we dock. + connect( this, TQT_SIGNAL(placeChanged(TQDockWindow::Place)), TQT_SLOT(rebuildLayout()) ); +} + +int TDEToolBar::insertButton(const TQString& icon, int id, bool enabled, + const TQString& text, int index, TDEInstance *_instance ) +{ + TDEToolBarButton *button = new TDEToolBarButton( icon, id, this, 0, text, _instance ); + + insertWidgetInternal( button, index, id ); + button->setEnabled( enabled ); + doConnections( button ); + return index; +} + + +int TDEToolBar::insertButton(const TQString& icon, int id, const char *signal, + const TQObject *receiver, const char *slot, + bool enabled, const TQString& text, int index, TDEInstance *_instance ) +{ + TDEToolBarButton *button = new TDEToolBarButton( icon, id, this, 0, text, _instance); + insertWidgetInternal( button, index, id ); + button->setEnabled( enabled ); + connect( button, signal, receiver, slot ); + doConnections( button ); + return index; +} + + +int TDEToolBar::insertButton(const TQPixmap& pixmap, int id, bool enabled, + const TQString& text, int index ) +{ + TDEToolBarButton *button = new TDEToolBarButton( pixmap, id, this, 0, text); + insertWidgetInternal( button, index, id ); + button->setEnabled( enabled ); + doConnections( button ); + return index; +} + + +int TDEToolBar::insertButton(const TQPixmap& pixmap, int id, const char *signal, + const TQObject *receiver, const char *slot, + bool enabled, const TQString& text, + int index ) +{ + TDEToolBarButton *button = new TDEToolBarButton( pixmap, id, this, 0, text); + insertWidgetInternal( button, index, id ); + button->setEnabled( enabled ); + connect( button, signal, receiver, slot ); + doConnections( button ); + return index; +} + + +int TDEToolBar::insertButton(const TQString& icon, int id, TQPopupMenu *popup, + bool enabled, const TQString &text, int index ) +{ + TDEToolBarButton *button = new TDEToolBarButton( icon, id, this, 0, text ); + insertWidgetInternal( button, index, id ); + button->setEnabled( enabled ); + button->setPopup( popup ); + doConnections( button ); + return index; +} + + +int TDEToolBar::insertButton(const TQPixmap& pixmap, int id, TQPopupMenu *popup, + bool enabled, const TQString &text, int index ) +{ + TDEToolBarButton *button = new TDEToolBarButton( pixmap, id, this, 0, text ); + insertWidgetInternal( button, index, id ); + button->setEnabled( enabled ); + button->setPopup( popup ); + doConnections( button ); + return index; +} + + +int TDEToolBar::insertLined (const TQString& text, int id, + const char *signal, + const TQObject *receiver, const char *slot, + bool enabled , + const TQString& toolTipText, + int size, int index ) +{ + KLineEdit *lined = new KLineEdit ( this, 0 ); + if ( !toolTipText.isEmpty() ) + TQToolTip::add( lined, toolTipText ); + if ( size > 0 ) + lined->setMinimumWidth( size ); + insertWidgetInternal( lined, index, id ); + connect( lined, signal, receiver, slot ); + lined->setText(text); + lined->setEnabled( enabled ); + return index; +} + +int TDEToolBar::insertCombo (const TQStringList &list, int id, bool writable, + const char *signal, const TQObject *receiver, + const char *slot, bool enabled, + const TQString& tooltiptext, + int size, int index, + TQComboBox::Policy policy ) +{ + KComboBox *combo = new KComboBox ( writable, this ); + + insertWidgetInternal( combo, index, id ); + combo->insertStringList (list); + combo->setInsertionPolicy(policy); + combo->setEnabled( enabled ); + if ( size > 0 ) + combo->setMinimumWidth( size ); + if (!tooltiptext.isNull()) + TQToolTip::add( combo, tooltiptext ); + + if ( signal && receiver && slot ) + connect ( combo, signal, receiver, slot ); + return index; +} + + +int TDEToolBar::insertCombo (const TQString& text, int id, bool writable, + const char *signal, TQObject *receiver, + const char *slot, bool enabled, + const TQString& tooltiptext, + int size, int index, + TQComboBox::Policy policy ) +{ + KComboBox *combo = new KComboBox ( writable, this ); + insertWidgetInternal( combo, index, id ); + combo->insertItem (text); + combo->setInsertionPolicy(policy); + combo->setEnabled( enabled ); + if ( size > 0 ) + combo->setMinimumWidth( size ); + if (!tooltiptext.isNull()) + TQToolTip::add( combo, tooltiptext ); + connect (combo, signal, receiver, slot); + return index; +} + +int TDEToolBar::insertSeparator(int index, int id) +{ + TQWidget *w = new TDEToolBarSeparator( orientation(), false, this, "tool bar separator" ); + insertWidgetInternal( w, index, id ); + return index; +} + +int TDEToolBar::insertLineSeparator(int index, int id) +{ + TQWidget *w = new TDEToolBarSeparator( orientation(), true, this, "tool bar separator" ); + insertWidgetInternal( w, index, id ); + return index; +} + + +int TDEToolBar::insertWidget(int id, int /*width*/, TQWidget *widget, int index) +{ + removeWidgetInternal( widget ); // in case we already have it ? + insertWidgetInternal( widget, index, id ); + return index; +} + +int TDEToolBar::insertAnimatedWidget(int id, TQObject *receiver, const char *slot, + const TQString& icons, int index ) +{ + KAnimWidget *anim = new KAnimWidget( icons, d->m_iconSize, this ); + insertWidgetInternal( anim, index, id ); + + if ( receiver ) + connect( anim, TQT_SIGNAL(clicked()), receiver, slot); + + return index; +} + +KAnimWidget *TDEToolBar::animatedWidget( int id ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return 0; + KAnimWidget *aw = tqt_dynamic_cast(*it); + if ( aw ) + return aw; + TQObjectList *l = queryList( "KAnimWidget" ); + if ( !l || !l->first() ) { + delete l; + return 0; + } + + for ( TQObject *o = l->first(); o; o = l->next() ) { + KAnimWidget *aw = tqt_dynamic_cast(o); + if ( aw ) + { + delete l; + return aw; + } + } + + delete l; + return 0; +} + + +void TDEToolBar::addConnection (int id, const char *signal, + const TQObject *receiver, const char *slot) +{ + TQWidget* w = getWidget( id ); + if ( w ) + connect( w, signal, receiver, slot ); +} + +void TDEToolBar::setItemEnabled( int id, bool enabled ) +{ + TQWidget* w = getWidget( id ); + if ( w ) + w->setEnabled( enabled ); +} + + +void TDEToolBar::setButtonPixmap( int id, const TQPixmap& _pixmap ) +{ + TDEToolBarButton * button = getButton( id ); + if ( button ) + button->setPixmap( _pixmap ); +} + + +void TDEToolBar::setButtonIcon( int id, const TQString& _icon ) +{ + TDEToolBarButton * button = getButton( id ); + if ( button ) + button->setIcon( _icon ); +} + +void TDEToolBar::setButtonIconSet( int id, const TQIconSet& iconset ) +{ + TDEToolBarButton * button = getButton( id ); + if ( button ) + button->setIconSet( iconset ); +} + + +void TDEToolBar::setDelayedPopup (int id , TQPopupMenu *_popup, bool toggle ) +{ + TDEToolBarButton * button = getButton( id ); + if ( button ) + button->setDelayedPopup( _popup, toggle ); +} + + +void TDEToolBar::setAutoRepeat (int id, bool flag) +{ + TDEToolBarButton * button = getButton( id ); + if ( button ) + button->setAutoRepeat( flag ); +} + + +void TDEToolBar::setToggle (int id, bool flag ) +{ + TDEToolBarButton * button = getButton( id ); + if ( button ) + button->setToggle( flag ); +} + + +void TDEToolBar::toggleButton (int id) +{ + TDEToolBarButton * button = getButton( id ); + if ( button ) + button->toggle(); +} + + +void TDEToolBar::setButton (int id, bool flag) +{ + TDEToolBarButton * button = getButton( id ); + if ( button ) + button->on( flag ); +} + + +bool TDEToolBar::isButtonOn (int id) const +{ + TDEToolBarButton * button = const_cast( this )->getButton( id ); + return button ? button->isOn() : false; +} + + +void TDEToolBar::setLinedText (int id, const TQString& text) +{ + KLineEdit * lineEdit = getLined( id ); + if ( lineEdit ) + lineEdit->setText( text ); +} + + +TQString TDEToolBar::getLinedText (int id) const +{ + KLineEdit * lineEdit = const_cast( this )->getLined( id ); + return lineEdit ? lineEdit->text() : TQString::null; +} + + +void TDEToolBar::insertComboItem (int id, const TQString& text, int index) +{ + KComboBox * comboBox = getCombo( id ); + if (comboBox) + comboBox->insertItem( text, index ); +} + +void TDEToolBar::insertComboList (int id, const TQStringList &list, int index) +{ + KComboBox * comboBox = getCombo( id ); + if (comboBox) + comboBox->insertStringList( list, index ); +} + + +void TDEToolBar::removeComboItem (int id, int index) +{ + KComboBox * comboBox = getCombo( id ); + if (comboBox) + comboBox->removeItem( index ); +} + + +void TDEToolBar::setCurrentComboItem (int id, int index) +{ + KComboBox * comboBox = getCombo( id ); + if (comboBox) + comboBox->setCurrentItem( index ); +} + + +void TDEToolBar::changeComboItem (int id, const TQString& text, int index) +{ + KComboBox * comboBox = getCombo( id ); + if (comboBox) + comboBox->changeItem( text, index ); +} + + +void TDEToolBar::clearCombo (int id) +{ + KComboBox * comboBox = getCombo( id ); + if (comboBox) + comboBox->clear(); +} + + +TQString TDEToolBar::getComboItem (int id, int index) const +{ + KComboBox * comboBox = const_cast( this )->getCombo( id ); + return comboBox ? comboBox->text( index ) : TQString::null; +} + + +KComboBox * TDEToolBar::getCombo(int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return 0; + return tqt_dynamic_cast( *it ); +} + + +KLineEdit * TDEToolBar::getLined (int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return 0; + return tqt_dynamic_cast( *it ); +} + + +TDEToolBarButton * TDEToolBar::getButton (int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return 0; + return tqt_dynamic_cast( *it ); +} + + +void TDEToolBar::alignItemRight (int id, bool right ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; + if ( rightAligned && !right && (*it) == rightAligned ) + rightAligned = 0; + if ( (*it) && right ) + rightAligned = (*it); +} + + +TQWidget *TDEToolBar::getWidget (int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + return ( it == id2widget.end() ) ? 0 : (*it); +} + + +void TDEToolBar::setItemAutoSized (int id, bool yes ) +{ + TQWidget *w = getWidget(id); + if ( w && yes ) + setStretchableWidget( w ); +} + + +void TDEToolBar::clear () +{ + /* Delete any idle buttons, so TQToolBar doesn't delete them itself, making a mess */ + for(TQWidget *w=d->idleButtons.first(); w; w=d->idleButtons.next()) + w->blockSignals(false); + d->idleButtons.clear(); + + TQToolBar::clear(); + widget2id.clear(); + id2widget.clear(); +} + + +void TDEToolBar::removeItem(int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + { + kdDebug(220) << name() << " TDEToolBar::removeItem item " << id << " not found" << endl; + return; + } + TQWidget * w = (*it); + id2widget.remove( id ); + widget2id.remove( w ); + widgets.removeRef( w ); + delete w; +} + + +void TDEToolBar::removeItemDelayed(int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + { + kdDebug(220) << name() << " TDEToolBar::removeItem item " << id << " not found" << endl; + return; + } + TQWidget * w = (*it); + id2widget.remove( id ); + widget2id.remove( w ); + widgets.removeRef( w ); + + w->blockSignals(true); + d->idleButtons.append(w); + layoutTimer->start( 50, true ); +} + + +void TDEToolBar::hideItem (int id) +{ + TQWidget *w = getWidget(id); + if ( w ) + w->hide(); +} + + +void TDEToolBar::showItem (int id) +{ + TQWidget *w = getWidget(id); + if ( w ) + w->show(); +} + + +int TDEToolBar::itemIndex (int id) +{ + TQWidget *w = getWidget(id); + return w ? widgets.findRef(w) : -1; +} + +int TDEToolBar::idAt (int index) +{ + TQWidget *w = widgets.at(index); + return widget2id[w]; +} + +void TDEToolBar::setFullSize(bool flag ) +{ + setHorizontalStretchable( flag ); + setVerticalStretchable( flag ); +} + + +bool TDEToolBar::fullSize() const +{ + return isHorizontalStretchable() || isVerticalStretchable(); +} + + +void TDEToolBar::enableMoving(bool flag ) +{ + setMovingEnabled(flag); +} + + +void TDEToolBar::setBarPos (BarPosition bpos) +{ + if ( !mainWindow() ) + return; + mainWindow()->moveDockWindow( this, (Dock)bpos ); + //kdDebug(220) << name() << " setBarPos dockWindowIndex=" << dockWindowIndex() << endl; +} + + +TDEToolBar::BarPosition TDEToolBar::barPos() const +{ + if ( !this->mainWindow() ) + return place() == TQDockWindow::InDock ? TDEToolBar::Top : TDEToolBar::Floating; + Dock dock; + int dm1, dm2; + bool dm3; + this->mainWindow()->getLocation( (TQToolBar*)this, dock, dm1, dm3, dm2 ); + if ( dock == DockUnmanaged ) { + return (TDEToolBar::BarPosition)DockTop; + } + return (BarPosition)dock; +} + + +bool TDEToolBar::enable(BarStatus stat) +{ + bool mystat = isVisible(); + + if ( (stat == Toggle && mystat) || stat == Hide ) + hide(); + else + show(); + + return isVisible() == mystat; +} + + +void TDEToolBar::setMaxHeight ( int h ) +{ + setMaximumHeight( h ); +} + +int TDEToolBar::maxHeight() +{ + return maximumHeight(); +} + + +void TDEToolBar::setMaxWidth (int dw) +{ + setMaximumWidth( dw ); +} + + +int TDEToolBar::maxWidth() +{ + return maximumWidth(); +} + + +void TDEToolBar::setTitle (const TQString& _title) +{ + setLabel( _title ); +} + + +void TDEToolBar::enableFloating (bool ) +{ +} + + +void TDEToolBar::setIconText(IconText it) +{ + setIconText( it, true ); +} + + +void TDEToolBar::setIconText(IconText icontext, bool update) +{ + bool doUpdate=false; + + if (icontext != d->m_iconText) { + d->m_iconText = icontext; + doUpdate=true; + //kdDebug(220) << name() << " icontext has changed, doUpdate=true" << endl; + } + else { + //kdDebug(220) << name() << " icontext hasn't changed, doUpdate=false" << endl; + } + + if (!update) + return; + + if (doUpdate) + doModeChange(); // tell buttons what happened + + // ugly hack to force a TQMainWindow::triggerLayout( true ) + TQMainWindow *mw = mainWindow(); + if ( mw ) { + mw->setUpdatesEnabled( false ); +// mw->setToolBarsMovable( !mw->toolBarsMovable() ); // Old way +// mw->setToolBarsMovable( !mw->toolBarsMovable() ); + mw->setCentralWidget(mw->centralWidget()); // This is a faster hack + mw->setUpdatesEnabled( true ); + } +} + + +TDEToolBar::IconText TDEToolBar::iconText() const +{ + return d->m_iconText; +} + + +void TDEToolBar::setIconSize(int size) +{ + setIconSize( size, true ); +} + +void TDEToolBar::setIconSize(int size, bool update) +{ + bool doUpdate=false; + + if ( size != d->m_iconSize ) { + d->m_iconSize = size; + doUpdate=true; + } + + if (!update) + return; + + if (doUpdate) + doModeChange(); // tell buttons what happened + + // ugly hack to force a TQMainWindow::triggerLayout( true ) + if ( mainWindow() ) { + TQMainWindow *mw = mainWindow(); + mw->setUpdatesEnabled( false ); +// mw->setToolBarsMovable( !mw->toolBarsMovable() ); // Old way +// mw->setToolBarsMovable( !mw->toolBarsMovable() ); + mw->setCentralWidget(mw->centralWidget()); // This is a faster hack + mw->setUpdatesEnabled( true ); + } +} + +int TDEToolBar::iconSize() const +{ + if ( !d->m_iconSize ) // default value? + return iconSizeDefault(); + + return d->m_iconSize; +} + +int TDEToolBar::iconSizeDefault() const +{ + if (!::qstrcmp(name(), "mainToolBar")) + return TDEGlobal::iconLoader()->currentSize(KIcon::MainToolbar); + + return TDEGlobal::iconLoader()->currentSize(KIcon::Toolbar); +} + +void TDEToolBar::setEnableContextMenu(bool enable ) +{ + d->m_enableContext = enable; +} + + +bool TDEToolBar::contextMenuEnabled() const +{ + return d->m_enableContext; +} + + +void TDEToolBar::setItemNoStyle(int id, bool no_style ) +{ + TDEToolBarButton * button = getButton( id ); + if (button) + button->setNoStyle( no_style ); +} + + +void TDEToolBar::setFlat (bool flag) +{ + if ( !mainWindow() ) + return; + if ( flag ) + mainWindow()->moveDockWindow( this, DockMinimized ); + else + mainWindow()->moveDockWindow( this, DockTop ); + // And remember to save the new look later + TDEMainWindow *kmw = tqt_dynamic_cast(mainWindow()); + if ( kmw ) + kmw->setSettingsDirty(); +} + + +int TDEToolBar::count() const +{ + return id2widget.count(); +} + + +void TDEToolBar::saveState() +{ + // first, try to save to the xml file + if ( d->m_xmlguiClient && !d->m_xmlguiClient->xmlFile().isEmpty() ) { + //kdDebug(220) << name() << " saveState: saving to " << d->m_xmlguiClient->xmlFile() << endl; + TQString barname(!::qstrcmp(name(), "unnamed") ? "mainToolBar" : name()); + // try to find our toolbar + d->modified = false; + // go down one level to get to the right tags + TQDomElement current; + for( TQDomNode n = d->m_xmlguiClient->domDocument().documentElement().firstChild(); + !n.isNull(); n = n.nextSibling()) { + current = n.toElement(); + + if ( current.tagName().lower() != "toolbar" ) + continue; + + TQString curname(current.attribute( "name" )); + + if ( curname == barname ) { + saveState( current ); + break; + } + } + // if we didn't make changes, then just return + if ( !d->modified ) + return; + + // now we load in the (non-merged) local file + TQString local_xml(KXMLGUIFactory::readConfigFile(d->m_xmlguiClient->xmlFile(), true, d->m_xmlguiClient->instance())); + TQDomDocument local; + local.setContent(local_xml); + + // make sure we don't append if this toolbar already exists locally + bool just_append = true; + + for( TQDomNode n = local.documentElement().firstChild(); + !n.isNull(); n = n.nextSibling()) { + TQDomElement elem = n.toElement(); + + if ( elem.tagName().lower() != "toolbar" ) + continue; + + TQString curname(elem.attribute( "name" )); + + if ( curname == barname ) { + just_append = false; + local.documentElement().replaceChild( current, elem ); + break; + } + } + + if (just_append) + local.documentElement().appendChild( current ); + + KXMLGUIFactory::saveConfigFile(local, d->m_xmlguiClient->localXMLFile(), d->m_xmlguiClient->instance() ); + + return; + } + + // if that didn't work, we save to the config file + TDEConfig *config = TDEGlobal::config(); + saveSettings(config, TQString::null); + config->sync(); +} + +TQString TDEToolBar::settingsGroup() const +{ + TQString configGroup; + if (!::qstrcmp(name(), "unnamed") || !::qstrcmp(name(), "mainToolBar")) + configGroup = "Toolbar style"; + else + configGroup = TQString(name()) + " Toolbar style"; + if ( this->mainWindow() ) + { + configGroup.prepend(" "); + configGroup.prepend( this->mainWindow()->name() ); + } + return configGroup; +} + +void TDEToolBar::saveSettings(TDEConfig *config, const TQString &_configGroup) +{ + TQString configGroup = _configGroup; + if (configGroup.isEmpty()) + configGroup = settingsGroup(); + //kdDebug(220) << name() << " saveSettings() group=" << _configGroup << " -> " << configGroup << endl; + + TQString position, icontext; + int index; + getAttributes( position, icontext, index ); + + //kdDebug(220) << name() << " position=" << position << " index=" << index << " offset=" << offset() << " newLine=" << newLine() << endl; + + TDEConfigGroupSaver saver(config, configGroup); + + if(!config->hasDefault("Position") && position == d->PositionDefault ) + config->revertToDefault("Position"); + else + config->writeEntry("Position", position); + + //kdDebug(220) << name() << " icontext=" << icontext << " hasDefault:" << config->hasDefault( "IconText" ) << " d->IconTextDefault=" << d->IconTextDefault << endl; + + if(d->m_honorStyle && icontext == d->IconTextDefault && !config->hasDefault("IconText") ) + { + //kdDebug(220) << name() << " reverting icontext to default" << endl; + config->revertToDefault("IconText"); + } + else + { + //kdDebug(220) << name() << " writing icontext " << icontext << endl; + config->writeEntry("IconText", icontext); + } + + if(!config->hasDefault("IconSize") && iconSize() == iconSizeDefault() ) + config->revertToDefault("IconSize"); + else + config->writeEntry("IconSize", iconSize()); + + if(!config->hasDefault("Hidden") && isHidden() == d->HiddenDefault ) + config->revertToDefault("Hidden"); + else + config->writeEntry("Hidden", isHidden()); + + // Note that index, unlike the other settings, depends on the other toolbars + // So on the first run with a clean local config file, even the usual + // hasDefault/==IndexDefault test would save the toolbar indexes + // (IndexDefault was 0, whereas index is the real index in the GUI) + // + // Saving the whole set of indexes is necessary though. When moving only + // one toolbar, if we only saved the changed indexes, the toolbars wouldn't + // reappear at the same position the next time. + // The whole set of indexes has to be saved. + //kdDebug(220) << name() << " writing index " << index << endl; + TDEMainWindow *kmw = tqt_dynamic_cast(mainWindow()); + // don't save if there's only one toolbar + + // Don't use kmw->toolBarIterator() because you might + // mess up someone else's iterator. Make the list on your own + TQPtrList toolbarList; + TQPtrList lst; + for ( int i = (int)TQMainWindow::DockUnmanaged; i <= (int)DockMinimized; ++i ) { + lst = kmw->toolBars( (ToolBarDock)i ); + for ( TQToolBar *tb = lst.first(); tb; tb = lst.next() ) { + if ( !tb->inherits( "TDEToolBar" ) ) + continue; + toolbarList.append( (TDEToolBar*)tb ); + } + } + TQPtrListIterator toolbarIterator( toolbarList ); + if ( !kmw || toolbarIterator.count() > 1 ) + config->writeEntry("Index", index); + else + config->revertToDefault("Index"); + + if(!config->hasDefault("Offset") && offset() == d->OffsetDefault ) + config->revertToDefault("Offset"); + else + config->writeEntry("Offset", offset()); + + if(!config->hasDefault("NewLine") && newLine() == d->NewLineDefault ) + config->revertToDefault("NewLine"); + else + config->writeEntry("NewLine", newLine()); +} + + +void TDEToolBar::setXMLGUIClient( KXMLGUIClient *client ) +{ + d->m_xmlguiClient = client; +} + +void TDEToolBar::setText( const TQString & txt ) +{ + setLabel( txt + " (" + kapp->caption() + ") " ); +} + + +TQString TDEToolBar::text() const +{ + return label(); +} + + +void TDEToolBar::doConnections( TDEToolBarButton *button ) +{ + connect(button, TQT_SIGNAL(clicked(int)), this, TQT_SIGNAL( clicked( int ) ) ); + connect(button, TQT_SIGNAL(doubleClicked(int)), this, TQT_SIGNAL( doubleClicked( int ) ) ); + connect(button, TQT_SIGNAL(released(int)), this, TQT_SIGNAL( released( int ) ) ); + connect(button, TQT_SIGNAL(pressed(int)), this, TQT_SIGNAL( pressed( int ) ) ); + connect(button, TQT_SIGNAL(toggled(int)), this, TQT_SIGNAL( toggled( int ) ) ); + connect(button, TQT_SIGNAL(highlighted(int, bool)), this, TQT_SIGNAL( highlighted( int, bool ) ) ); +} + +void TDEToolBar::mousePressEvent ( TQMouseEvent *m ) +{ + if ( !mainWindow() ) + return; + TQMainWindow *mw = mainWindow(); + if ( mw->toolBarsMovable() && d->m_enableContext ) { + if ( m->button() == Qt::RightButton ) { + TQGuardedPtr guard( this ); + int i = contextMenu()->exec( m->globalPos(), 0 ); + // "Configure Toolbars" recreates toolbars, so we might not exist anymore. + if ( guard ) + slotContextAboutToHide(); + switch ( i ) { + case -1: + return; // popup canceled + case CONTEXT_LEFT: + mw->moveDockWindow( this, DockLeft ); + break; + case CONTEXT_RIGHT: + mw->moveDockWindow( this, DockRight ); + break; + case CONTEXT_TOP: + mw->moveDockWindow( this, DockTop ); + break; + case CONTEXT_BOTTOM: + mw->moveDockWindow( this, DockBottom ); + break; + case CONTEXT_FLOAT: + mw->moveDockWindow( this, DockTornOff ); + break; + case CONTEXT_FLAT: + mw->moveDockWindow( this, DockMinimized ); + break; + case CONTEXT_ICONS: + setIconText( IconOnly ); + break; + case CONTEXT_TEXTRIGHT: + setIconText( IconTextRight ); + break; + case CONTEXT_TEXT: + setIconText( TextOnly ); + break; + case CONTEXT_TEXTUNDER: + setIconText( IconTextBottom ); + break; + default: + if ( i >= CONTEXT_ICONSIZES ) + setIconSize( i - CONTEXT_ICONSIZES ); + else + return; // assume this was an action handled elsewhere, no need for setSettingsDirty() + } + TDEMainWindow *kmw = tqt_dynamic_cast(mw); + if ( kmw ) + kmw->setSettingsDirty(); + } + } +} + +void TDEToolBar::doModeChange() +{ + for(TQWidget *w=d->idleButtons.first(); w; w=d->idleButtons.next()) + w->blockSignals(false); + d->idleButtons.clear(); + + emit modechange(); +} + +void TDEToolBar::rebuildLayout() +{ + for(TQWidget *w=d->idleButtons.first(); w; w=d->idleButtons.next()) + w->blockSignals(false); + d->idleButtons.clear(); + + layoutTimer->stop(); + TQApplication::sendPostedEvents( this, TQEvent::ChildInserted ); + TQBoxLayout *l = boxLayout(); + + // clear the old layout + TQLayoutIterator it = l->iterator(); + while ( it.current() ) + it.deleteCurrent(); + + for ( TQWidget *w = widgets.first(); w; w = widgets.next() ) { + if ( w == rightAligned ) + continue; + TDEToolBarSeparator *ktbs = tqt_dynamic_cast(w); + if ( ktbs && !ktbs->showLine() ) { + l->addSpacing( orientation() == Qt::Vertical ? w->sizeHint().height() : w->sizeHint().width() ); + w->hide(); + continue; + } + if ( tqt_dynamic_cast(w) ) // w is a QPopupMenu? + continue; + l->addWidget( w ); + w->show(); + if ((orientation() == Qt::Horizontal) && tqt_dynamic_cast(w)) // w is TQLineEdit ? + l->addSpacing(2); // A little bit extra spacing behind it. + } + if ( rightAligned ) { + l->addStretch(); + l->addWidget( rightAligned ); + rightAligned->show(); + } + + if ( fullSize() ) { + if ( !rightAligned ) + l->addStretch(); + if ( stretchableWidget ) + l->setStretchFactor( stretchableWidget, 10 ); + } + l->invalidate(); + TQApplication::postEvent( this, new TQEvent( TQEvent::LayoutHint ) ); +} + +void TDEToolBar::childEvent( TQChildEvent *e ) +{ + if ( e->child()->isWidgetType() ) { + TQWidget * w = tqt_dynamic_cast(e->child()); + if (!w || !(::qstrcmp( "qt_dockwidget_internal", w->name()))) + { + TQToolBar::childEvent( e ); + return; + } + if ( e->type() == TQEvent::ChildInserted ) { + if ( !tqt_dynamic_cast(w)) { // e->child() is not a QPopupMenu + // prevent items that have been explicitly inserted by insert*() from + // being inserted again + if ( !widget2id.contains( w ) ) + { + int dummy = -1; + insertWidgetInternal( w, dummy, -1 ); + } + } + } else { + removeWidgetInternal( w ); + } + if ( isVisibleTo( 0 ) ) + { + layoutTimer->start( 50, true ); + TQBoxLayout *l = boxLayout(); + + // clear the old layout so that we don't get unnecessary layout + // changes until we have rebuilt the thing + TQLayoutIterator it = l->iterator(); + while ( it.current() ) + it.deleteCurrent(); + } + } + TQToolBar::childEvent( e ); +} + +void TDEToolBar::insertWidgetInternal( TQWidget *w, int &index, int id ) +{ + // we can't have it in widgets, or something is really wrong + //widgets.removeRef( w ); + + connect( w, TQT_SIGNAL( destroyed() ), + this, TQT_SLOT( widgetDestroyed() ) ); + if ( index == -1 || index > (int)widgets.count() ) { + index = (int)widgets.count(); + widgets.append( w ); + } + else + widgets.insert( index, w ); + if ( id == -1 ) + id = id2widget.count(); + id2widget.insert( id, w ); + widget2id.insert( w, id ); +} + +void TDEToolBar::showEvent( TQShowEvent *e ) +{ + TQToolBar::showEvent( e ); + rebuildLayout(); +} + +void TDEToolBar::setStretchableWidget( TQWidget *w ) +{ + TQToolBar::setStretchableWidget( w ); + stretchableWidget = w; +} + +TQSizePolicy TDEToolBar::sizePolicy() const +{ + if ( orientation() == Qt::Horizontal ) + return TQSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Fixed ); + else + return TQSizePolicy( TQSizePolicy::Fixed, TQSizePolicy::Expanding ); +} + +TQSize TDEToolBar::sizeHint() const +{ + TQSize minSize(0,0); + TDEToolBar *ncThis = const_cast(this); + + ncThis->polish(); + + int margin = static_cast(ncThis)->layout()->margin() + frameWidth(); + switch( barPos() ) + { + case TDEToolBar::Top: + case TDEToolBar::Bottom: + for ( TQWidget *w = ncThis->widgets.first(); w; w = ncThis->widgets.next() ) + { + TQSize sh = w->sizeHint(); + if ( w->sizePolicy().horData() == TQSizePolicy::Ignored ) + sh.setWidth( 1 ); + if ( w->sizePolicy().verData() == TQSizePolicy::Ignored ) + sh.setHeight( 1 ); + sh = sh.boundedTo( w->maximumSize() ) + .expandedTo( w->minimumSize() ).expandedTo( TQSize(1, 1) ); + + minSize = minSize.expandedTo(TQSize(0, sh.height())); + minSize += TQSize(sh.width()+1, 0); + if (tqt_dynamic_cast(w)) // w is a TQLineEdit ? + minSize += TQSize(2, 0); // A little bit extra spacing behind it. + } + + minSize += TQSize(TQApplication::style().pixelMetric( TQStyle::PM_DockWindowHandleExtent ), 0); + minSize += TQSize(margin*2, margin*2); + break; + + case TDEToolBar::Left: + case TDEToolBar::Right: + for ( TQWidget *w = ncThis->widgets.first(); w; w = ncThis->widgets.next() ) + { + TQSize sh = w->sizeHint(); + if ( w->sizePolicy().horData() == TQSizePolicy::Ignored ) + sh.setWidth( 1 ); + if ( w->sizePolicy().verData() == TQSizePolicy::Ignored ) + sh.setHeight( 1 ); + sh = sh.boundedTo( w->maximumSize() ) + .expandedTo( w->minimumSize() ).expandedTo( TQSize(1, 1) ); + + minSize = minSize.expandedTo(TQSize(sh.width(), 0)); + minSize += TQSize(0, sh.height()+1); + } + minSize += TQSize(0, TQApplication::style().pixelMetric( TQStyle::PM_DockWindowHandleExtent )); + minSize += TQSize(margin*2, margin*2); + break; + + default: + minSize = TQToolBar::sizeHint(); + break; + } + return minSize; +} + +TQSize TDEToolBar::minimumSize() const +{ + return minimumSizeHint(); +} + +TQSize TDEToolBar::minimumSizeHint() const +{ + return sizeHint(); +} + +bool TDEToolBar::highlight() const +{ + return d->m_highlight; +} + +void TDEToolBar::hide() +{ + TQToolBar::hide(); +} + +void TDEToolBar::show() +{ + TQToolBar::show(); +} + +void TDEToolBar::resizeEvent( TQResizeEvent *e ) +{ + bool b = isUpdatesEnabled(); + setUpdatesEnabled( false ); + TQToolBar::resizeEvent( e ); + if (b) + { + if (layoutTimer->isActive()) + { + // Wait with repainting till layout is complete. + d->repaintTimer.start( 100, true ); + } + else + { + // Repaint now + slotRepaint(); + } + } +// else { +// printf("[WARNING] In TDEToolBar::resizeEvent, but this code block should not be executing. Preventing toolbar lockup. [Code 0045]\n\r"); +// setUpdatesEnabled( true ); +// } +} + +void TDEToolBar::slotIconChanged(int group) +{ + if ((group != KIcon::Toolbar) && (group != KIcon::MainToolbar)) + return; + if ((group == KIcon::MainToolbar) != !::qstrcmp(name(), "mainToolBar")) + return; + + doModeChange(); + + if (isVisible()) + updateGeometry(); +} + +void TDEToolBar::slotReadConfig() +{ + //kdDebug(220) << name() << " slotReadConfig" << endl; + // Read appearance settings (hmm, we used to do both here, + // but a well behaved application will call applyMainWindowSettings + // anyway, right ?) + applyAppearanceSettings(TDEGlobal::config(), TQString::null ); +} + +void TDEToolBar::slotAppearanceChanged() +{ + // Read appearance settings from global file. + applyAppearanceSettings(TDEGlobal::config(), TQString::null, true /* lose local settings */ ); + + // And remember to save the new look later + TDEMainWindow *kmw = tqt_dynamic_cast(mainWindow()); + if ( kmw ) + kmw->setSettingsDirty(); +} + +//static +bool TDEToolBar::highlightSetting() +{ + TQString grpToolbar(TQString::fromLatin1("Toolbar style")); + TDEConfigGroupSaver saver(TDEGlobal::config(), grpToolbar); + return TDEGlobal::config()->readBoolEntry(TQString::fromLatin1("Highlighting"),true); +} + +//static +bool TDEToolBar::transparentSetting() +{ + TQString grpToolbar(TQString::fromLatin1("Toolbar style")); + TDEConfigGroupSaver saver(TDEGlobal::config(), grpToolbar); + return TDEGlobal::config()->readBoolEntry(TQString::fromLatin1("TransparentMoving"),true); +} + +//static +TDEToolBar::IconText TDEToolBar::iconTextSetting() +{ + TQString grpToolbar(TQString::fromLatin1("Toolbar style")); + TDEConfigGroupSaver saver(TDEGlobal::config(), grpToolbar); + TQString icontext = TDEGlobal::config()->readEntry(TQString::fromLatin1("IconText"),TQString::fromLatin1("IconOnly")); + if ( icontext == "IconTextRight" ) + return IconTextRight; + else if ( icontext == "IconTextBottom" ) + return IconTextBottom; + else if ( icontext == "TextOnly" ) + return TextOnly; + else + return IconOnly; +} + +void TDEToolBar::applyAppearanceSettings(TDEConfig *config, const TQString &_configGroup, bool forceGlobal) +{ + TQString configGroup = _configGroup.isEmpty() ? settingsGroup() : _configGroup; + //kdDebug(220) << name() << " applyAppearanceSettings: configGroup=" << configGroup << " forceGlobal=" << forceGlobal << endl; + + // If we have application-specific settings in the XML file, + // and nothing in the application's config file, then + // we don't apply the global defaults, the XML ones are preferred + // (see applySettings for a full explanation) + // This is the reason for the xmlgui tests below. + bool xmlgui = d->m_xmlguiClient && !d->m_xmlguiClient->xmlFile().isEmpty(); + + TDEConfig *gconfig = TDEGlobal::config(); + + static const TQString &attrIconText = TDEGlobal::staticQString("IconText"); + static const TQString &attrHighlight = TDEGlobal::staticQString("Highlighting"); + static const TQString &attrTrans = TDEGlobal::staticQString("TransparentMoving"); + static const TQString &attrIconSize = TDEGlobal::staticQString("IconSize"); + + // we actually do this in two steps. + // First, we read in the global styles [Toolbar style] (from the KControl module). + // Then, if the toolbar is NOT 'mainToolBar', we will also try to read in [barname Toolbar style] + bool highlight; + int transparent; + bool applyIconText = !xmlgui; // if xmlgui is used, global defaults won't apply + bool applyIconSize = !xmlgui; + + int iconSize = d->IconSizeDefault; + TQString iconText = d->IconTextDefault; + + // this is the first iteration + TQString grpToolbar(TQString::fromLatin1("Toolbar style")); + { // start block for TDEConfigGroupSaver + TDEConfigGroupSaver saver(gconfig, grpToolbar); + + // first, get the generic settings + highlight = gconfig->readBoolEntry(attrHighlight, true); + transparent = gconfig->readBoolEntry(attrTrans, true); + + // we read in the IconText property *only* if we intend on actually + // honoring it + if (d->m_honorStyle) + d->IconTextDefault = gconfig->readEntry(attrIconText, d->IconTextDefault); + else + d->IconTextDefault = "IconOnly"; + + // Use the default icon size for toolbar icons. + d->IconSizeDefault = gconfig->readNumEntry(attrIconSize, d->IconSizeDefault); + + iconSize = d->IconSizeDefault; + iconText = d->IconTextDefault; + + if ( !forceGlobal && config->hasGroup(configGroup) ) + { + config->setGroup(configGroup); + + // first, get the generic settings + highlight = config->readBoolEntry(attrHighlight, highlight); + transparent = config->readBoolEntry(attrTrans, transparent); + + // read in the IconText property + if ( config->hasKey( attrIconText ) ) { + iconText = config->readEntry(attrIconText); + applyIconText = true; + //kdDebug(220) << name() << " read icontext=" << d->IconTextDefault << ", that will be the default" << endl; + } + + // now get the size + if ( config->hasKey( attrIconSize ) ) { + iconSize = config->readNumEntry(attrIconSize); + applyIconSize = true; + } + } + + // revert back to the old group + } // end block for TDEConfigGroupSaver + + bool doUpdate = false; + + IconText icon_text; + if ( iconText == "IconTextRight" ) + icon_text = IconTextRight; + else if ( iconText == "IconTextBottom" ) + icon_text = IconTextBottom; + else if ( iconText == "TextOnly" ) + icon_text = TextOnly; + else + icon_text = IconOnly; + + // check if the icon/text has changed + if (icon_text != d->m_iconText && applyIconText) { + //kdDebug(220) << name() << " applyAppearanceSettings setIconText " << icon_text << endl; + setIconText(icon_text, false); + doUpdate = true; + } + + // ...and check if the icon size has changed + if (iconSize != d->m_iconSize && applyIconSize) { + setIconSize(iconSize, false); + doUpdate = true; + } + + TQMainWindow *mw = mainWindow(); + + // ...and if we should highlight + if ( highlight != d->m_highlight ) { + d->m_highlight = highlight; + doUpdate = true; + } + + // ...and if we should move transparently + if ( mw && transparent != (!mw->opaqueMoving()) ) { + mw->setOpaqueMoving( !transparent ); + } + + if (doUpdate) + doModeChange(); // tell buttons what happened + + if (isVisible ()) + updateGeometry(); +} + +void TDEToolBar::applySettings(TDEConfig *config, const TQString &_configGroup) +{ + return applySettings(config,_configGroup,false); +} + +void TDEToolBar::applySettings(TDEConfig *config, const TQString &_configGroup, bool force) +{ + //kdDebug(220) << name() << " applySettings group=" << _configGroup << endl; + + TQString configGroup = _configGroup.isEmpty() ? settingsGroup() : _configGroup; + + /* + Let's explain this a bit more in details. + The order in which we apply settings is : + Global config / user settings if no XMLGUI is used + Global config / App-XML attributes / user settings if XMLGUI is used + + So in the first case, we simply read everything from TDEConfig as below, + but in the second case we don't do anything here if there is no app-specific config, + and the XMLGUI-related code (loadState()) uses the static methods of this class + to get the global defaults. + + Global config doesn't include position (index, offset, newline and hidden/shown). + */ + + // First the appearance stuff - the one which has a global config + applyAppearanceSettings( config, configGroup ); + + // ...and now the position stuff + if ( config->hasGroup(configGroup) || force ) + { + TDEConfigGroupSaver cgs(config, configGroup); + + static const TQString &attrPosition = TDEGlobal::staticQString("Position"); + static const TQString &attrIndex = TDEGlobal::staticQString("Index"); + static const TQString &attrOffset = TDEGlobal::staticQString("Offset"); + static const TQString &attrNewLine = TDEGlobal::staticQString("NewLine"); + static const TQString &attrHidden = TDEGlobal::staticQString("Hidden"); + + TQString position = config->readEntry(attrPosition, d->PositionDefault); + int index = config->readNumEntry(attrIndex, -1); + int offset = config->readNumEntry(attrOffset, d->OffsetDefault); + bool newLine = config->readBoolEntry(attrNewLine, d->NewLineDefault); + bool hidden = config->readBoolEntry(attrHidden, d->HiddenDefault); + + Dock pos(DockTop); + if ( position == "Top" ) + pos = DockTop; + else if ( position == "Bottom" ) + pos = DockBottom; + else if ( position == "Left" ) + pos = DockLeft; + else if ( position == "Right" ) + pos = DockRight; + else if ( position == "Floating" ) + pos = DockTornOff; + else if ( position == "Flat" ) + pos = DockMinimized; + + //kdDebug(220) << name() << " applySettings hidden=" << hidden << endl; + if (hidden) + hide(); + else + show(); + + if ( mainWindow() ) + { + //kdDebug(220) << name() << " applySettings updating ToolbarInfo" << endl; + d->toolBarInfo = TDEToolBarPrivate::ToolBarInfo( pos, index, newLine, offset ); + positionYourself( true ); + } + if (isVisible ()) + updateGeometry(); + } +} + +bool TDEToolBar::event( TQEvent *e ) +{ + if ( (e->type() == TQEvent::LayoutHint) && isUpdatesEnabled() ) + d->repaintTimer.start( 100, true ); + + if (e->type() == TQEvent::ChildInserted ) + { + // Bypass TQToolBar::event, + // it will show() the inserted child and we don't want to + // do that until we have rebuilt the layout. + childEvent((TQChildEvent *)e); + return true; + } + + return TQToolBar::event( e ); +} + +void TDEToolBar::slotRepaint() +{ + setUpdatesEnabled( false ); + // Send a resizeEvent to update the "toolbar extension arrow" + // (The button you get when your toolbar-items don't fit in + // the available space) + TQResizeEvent ev(size(), size()); + resizeEvent(&ev); + TQApplication::sendPostedEvents( this, TQEvent::LayoutHint ); + setUpdatesEnabled( true ); + repaint( true ); +} + +void TDEToolBar::toolBarPosChanged( TQToolBar *tb ) +{ + if ( tb != this ) + return; + if ( d->oldPos == DockMinimized ) + rebuildLayout(); + d->oldPos = (TQMainWindow::ToolBarDock)barPos(); + TDEMainWindow *kmw = tqt_dynamic_cast(mainWindow()); + if ( kmw ) + kmw->setSettingsDirty(); +} + +static TDEToolBar::Dock stringToDock( const TQString& attrPosition ) +{ + TDEToolBar::Dock dock = TDEToolBar::DockTop; + if ( !attrPosition.isEmpty() ) { + if ( attrPosition == "top" ) + dock = TDEToolBar::DockTop; + else if ( attrPosition == "left" ) + dock = TDEToolBar::DockLeft; + else if ( attrPosition == "right" ) + dock = TDEToolBar::DockRight; + else if ( attrPosition == "bottom" ) + dock = TDEToolBar::DockBottom; + else if ( attrPosition == "floating" ) + dock = TDEToolBar::DockTornOff; + else if ( attrPosition == "flat" ) + dock = TDEToolBar::DockMinimized; + } + return dock; +} + + +void TDEToolBar::loadState( const TQDomElement &element ) +{ + TQMainWindow *mw = mainWindow(); + + if ( !mw ) + return; + + { + TQCString text = element.namedItem( "text" ).toElement().text().utf8(); + if ( text.isEmpty() ) + text = element.namedItem( "Text" ).toElement().text().utf8(); + if ( !text.isEmpty() ) + setText( i18n( text ) ); + } + + { + TQCString attrFullWidth = element.attribute( "fullWidth" ).lower().latin1(); + if ( !attrFullWidth.isEmpty() ) + setFullSize( attrFullWidth == "true" ); + } + + /* + This method is called in order to load toolbar settings from XML. + However this can be used in two rather different cases: + - for the initial loading of the app's XML. In that case the settings + are only the defaults, the user's TDEConfig settings will override them + (KDE4 TODO: how about saving those user settings into the local XML file instead? + Then this whole thing would be simpler, no TDEConfig settings to apply afterwards. + OTOH we'd have to migrate those settings when the .rc version increases, + like we do for shortcuts) + + - for later re-loading when switching between parts in KXMLGUIFactory. + In that case the XML contains the final settings, not the defaults. + We do need the defaults, and the toolbar might have been completely + deleted and recreated meanwhile. So we store the app-default settings + into the XML. + */ + bool loadingAppDefaults = true; + if ( element.hasAttribute( "offsetDefault" ) ) + { + // this isn't the first time, so the defaults have been saved into the (in-memory) XML + loadingAppDefaults = false; + d->OffsetDefault = element.attribute( "offsetDefault" ).toInt(); + d->NewLineDefault = element.attribute( "newlineDefault" ) == "true"; + d->HiddenDefault = element.attribute( "hiddenDefault" ) == "true"; + d->IconSizeDefault = element.attribute( "iconSizeDefault" ).toInt(); + d->PositionDefault = element.attribute( "positionDefault" ); + d->IconTextDefault = element.attribute( "iconTextDefault" ); + } + //kdDebug(220) << name() << " loadState loadingAppDefaults=" << loadingAppDefaults << endl; + + Dock dock = stringToDock( element.attribute( "position" ).lower() ); + + { + TQCString attrIconText = element.attribute( "iconText" ).lower().latin1(); + if ( !attrIconText.isEmpty() ) { + //kdDebug(220) << name() << " loadState attrIconText=" << attrIconText << endl; + if ( attrIconText == "icontextright" ) + setIconText( TDEToolBar::IconTextRight ); + else if ( attrIconText == "textonly" ) + setIconText( TDEToolBar::TextOnly ); + else if ( attrIconText == "icontextbottom" ) + setIconText( TDEToolBar::IconTextBottom ); + else if ( attrIconText == "icononly" ) + setIconText( TDEToolBar::IconOnly ); + } else + { + //kdDebug(220) << name() << " loadState no iconText attribute in XML, using iconTextSetting=" << iconTextSetting() << endl; + // Use global setting + if (d->m_honorStyle) + setIconText( iconTextSetting() ); + else + setIconText( d->IconTextDefault ); + } + } + + TQString attrIconSize = element.attribute( "iconSize" ).lower(); + int iconSize = d->IconSizeDefault; + if ( !attrIconSize.isEmpty() ) + iconSize = attrIconSize.toInt(); + setIconSize( iconSize ); + + int index = -1; // append by default. This is very important, otherwise + // with all 0 indexes, we keep reversing the toolbars. + { + TQString attrIndex = element.attribute( "index" ).lower(); + if ( !attrIndex.isEmpty() ) + index = attrIndex.toInt(); + } + + int offset = d->OffsetDefault; + bool newLine = d->NewLineDefault; + bool hidden = d->HiddenDefault; + + { + TQString attrOffset = element.attribute( "offset" ); + if ( !attrOffset.isEmpty() ) + offset = attrOffset.toInt(); + } + + { + TQString attrNewLine = element.attribute( "newline" ).lower(); + if ( !attrNewLine.isEmpty() ) + newLine = attrNewLine == "true"; + } + + { + TQString attrHidden = element.attribute( "hidden" ).lower(); + if ( !attrHidden.isEmpty() ) { + hidden = attrHidden == "true"; + } + } + + d->toolBarInfo = TDEToolBarPrivate::ToolBarInfo( dock, index, newLine, offset ); + mw->addDockWindow( this, dock, newLine ); + mw->moveDockWindow( this, dock, newLine, index, offset ); + + // Apply the highlight button setting + d->m_highlight = highlightSetting(); + + if ( hidden ) + hide(); + else + show(); + + if ( loadingAppDefaults ) + { + getAttributes( d->PositionDefault, d->IconTextDefault, index ); + //kdDebug(220) << name() << " loadState IconTextDefault=" << d->IconTextDefault << endl; + d->OffsetDefault = offset; + d->NewLineDefault = newLine; + d->HiddenDefault = hidden; + d->IconSizeDefault = iconSize; + } + //kdDebug(220) << name() << " loadState hidden=" << hidden << endl; + + // Apply transparent-toolbar-moving setting (ok, this is global to the mainwindow, + // but we do it only if there are toolbars...) + // KDE4: move to TDEMainWindow + if ( transparentSetting() != !mw->opaqueMoving() ) + mw->setOpaqueMoving( !transparentSetting() ); +} + +int TDEToolBar::dockWindowIndex() +{ + int index = 0; + Q_ASSERT( mainWindow() ); + if ( mainWindow() ) { + TQMainWindow::ToolBarDock dock; + bool newLine; + int offset; + mainWindow()->getLocation( this, dock, index, newLine, offset ); + } + return index; +} + +void TDEToolBar::getAttributes( TQString &position, TQString &icontext, int &index ) +{ + // get all of the stuff to save + switch ( barPos() ) { + case TDEToolBar::Flat: + position = "Flat"; + break; + case TDEToolBar::Bottom: + position = "Bottom"; + break; + case TDEToolBar::Left: + position = "Left"; + break; + case TDEToolBar::Right: + position = "Right"; + break; + case TDEToolBar::Floating: + position = "Floating"; + break; + case TDEToolBar::Top: + default: + position = "Top"; + break; + } + + index = dockWindowIndex(); + + switch (d->m_iconText) { + case TDEToolBar::IconTextRight: + icontext = "IconTextRight"; + break; + case TDEToolBar::IconTextBottom: + icontext = "IconTextBottom"; + break; + case TDEToolBar::TextOnly: + icontext = "TextOnly"; + break; + case TDEToolBar::IconOnly: + default: + icontext = "IconOnly"; + break; + } + //kdDebug(220) << name() << " getAttributes: icontext=" << icontext << endl; +} + +void TDEToolBar::saveState( TQDomElement ¤t ) +{ + Q_ASSERT( !current.isNull() ); + TQString position, icontext; + int index = -1; + getAttributes( position, icontext, index ); + + current.setAttribute( "noMerge", "1" ); + current.setAttribute( "position", position ); + current.setAttribute( "iconText", icontext ); + current.setAttribute( "index", index ); + current.setAttribute( "offset", offset() ); + current.setAttribute( "newline", newLine() ); + if ( isHidden() ) + current.setAttribute( "hidden", "true" ); + d->modified = true; + + // TODO if this method is used by more than KXMLGUIBuilder, e.g. to save XML settings to *disk*, + // then the stuff below shouldn't always be done. + current.setAttribute( "offsetDefault", d->OffsetDefault ); + current.setAttribute( "newlineDefault", d->NewLineDefault ); + current.setAttribute( "hiddenDefault", d->HiddenDefault ? "true" : "false" ); + current.setAttribute( "iconSizeDefault", d->IconSizeDefault ); + current.setAttribute( "positionDefault", d->PositionDefault ); + current.setAttribute( "iconTextDefault", d->IconTextDefault ); + + //kdDebug(220) << name() << " saveState: saving index=" << index << " iconText=" << icontext << " hidden=" << isHidden() << endl; +} + +// Called by TDEMainWindow::finalizeGUI +void TDEToolBar::positionYourself( bool force ) +{ + if (force) + d->positioned = false; + + if ( d->positioned || !mainWindow() ) + { + //kdDebug(220) << name() << " positionYourself d->positioned=true ALREADY DONE" << endl; + return; + } + // we can't test for ForceHide after moveDockWindow because QDockArea + // does a reparent() with showIt == true + bool hidden = isHidden(); + //kdDebug(220) << name() << " positionYourself dock=" << d->toolBarInfo.dock << " newLine=" << d->toolBarInfo.newline << " index=" << d->toolBarInfo.index << " offset=" << d->toolBarInfo.offset << endl; + mainWindow()->moveDockWindow( this, d->toolBarInfo.dock, + d->toolBarInfo.newline, + d->toolBarInfo.index, + d->toolBarInfo.offset ); + + //kdDebug(220) << name() << " positionYourself dockWindowIndex=" << dockWindowIndex() << endl; + if ( hidden ) + hide(); + else + show(); + // This method can only have an effect once - unless force is set + d->positioned = true; +} + +TDEPopupMenu *TDEToolBar::contextMenu() +{ + if ( context ) + return context; + // Construct our context popup menu. Name it qt_dockwidget_internal so it + // won't be deleted by TQToolBar::clear(). + context = new TDEPopupMenu( this, "qt_dockwidget_internal" ); + context->insertTitle(i18n("Toolbar Menu")); + + TDEPopupMenu *orient = new TDEPopupMenu( context, "orient" ); + orient->insertItem( i18n("toolbar position string","Top"), CONTEXT_TOP ); + orient->insertItem( i18n("toolbar position string","Left"), CONTEXT_LEFT ); + orient->insertItem( i18n("toolbar position string","Right"), CONTEXT_RIGHT ); + orient->insertItem( i18n("toolbar position string","Bottom"), CONTEXT_BOTTOM ); + orient->insertSeparator(-1); + orient->insertItem( i18n("toolbar position string","Floating"), CONTEXT_FLOAT ); + orient->insertItem( i18n("min toolbar", "Flat"), CONTEXT_FLAT ); + + TDEPopupMenu *mode = new TDEPopupMenu( context, "mode" ); + mode->insertItem( i18n("Icons Only"), CONTEXT_ICONS ); + mode->insertItem( i18n("Text Only"), CONTEXT_TEXT ); + mode->insertItem( i18n("Text Alongside Icons"), CONTEXT_TEXTRIGHT ); + mode->insertItem( i18n("Text Under Icons"), CONTEXT_TEXTUNDER ); + + TDEPopupMenu *size = new TDEPopupMenu( context, "size" ); + size->insertItem( i18n("Default"), CONTEXT_ICONSIZES ); + // Query the current theme for available sizes + KIconTheme *theme = TDEGlobal::instance()->iconLoader()->theme(); + TQValueList avSizes; + if (theme) + { + if (!::qstrcmp(name(), "mainToolBar")) + avSizes = theme->querySizes( KIcon::MainToolbar); + else + avSizes = theme->querySizes( KIcon::Toolbar); + } + + d->iconSizes = avSizes; + qHeapSort(avSizes); + + TQValueList::Iterator it; + if (avSizes.count() < 10) { + // Fixed or threshold type icons + TQValueList::Iterator end(avSizes.end()); + for (it=avSizes.begin(); it!=end; ++it) { + TQString text; + if ( *it < 19 ) + text = i18n("Small (%1x%2)").arg(*it).arg(*it); + else if (*it < 25) + text = i18n("Medium (%1x%2)").arg(*it).arg(*it); + else if (*it < 35) + text = i18n("Large (%1x%2)").arg(*it).arg(*it); + else + text = i18n("Huge (%1x%2)").arg(*it).arg(*it); + //we use the size as an id, with an offset + size->insertItem( text, CONTEXT_ICONSIZES + *it ); + } + } + else { + // Scalable icons. + const int progression[] = {16, 22, 32, 48, 64, 96, 128, 192, 256}; + + it = avSizes.begin(); + for (uint i = 0; i < 9; i++) { + while (it++ != avSizes.end()) { + if (*it >= progression[i]) { + TQString text; + if ( *it < 19 ) + text = i18n("Small (%1x%2)").arg(*it).arg(*it); + else if (*it < 25) + text = i18n("Medium (%1x%2)").arg(*it).arg(*it); + else if (*it < 35) + text = i18n("Large (%1x%2)").arg(*it).arg(*it); + else + text = i18n("Huge (%1x%2)").arg(*it).arg(*it); + //we use the size as an id, with an offset + size->insertItem( text, CONTEXT_ICONSIZES + *it ); + break; + } + } + } + } + + context->insertItem( i18n("Orientation"), orient ); + orient->setItemChecked(CONTEXT_TOP, true); + context->insertItem( i18n("Text Position"), mode ); + context->setItemChecked(CONTEXT_ICONS, true); + context->insertItem( i18n("Icon Size"), size ); + + connect( context, TQT_SIGNAL( aboutToShow() ), this, TQT_SLOT( slotContextAboutToShow() ) ); + // Unplugging a submenu from abouttohide leads to the popupmenu floating around + // So better simply call that code from after exec() returns (DF) + //connect( context, TQT_SIGNAL( aboutToHide() ), this, TQT_SLOT( slotContextAboutToHide() ) ); + return context; +} + +void TDEToolBar::slotContextAboutToShow() +{ + // The idea here is to reuse the "static" part of the menu to save time. + // But the "Toolbars" action is dynamic (can be a single action or a submenu) + // and ToolBarHandler::setupActions() deletes it, so better not keep it around. + // So we currently plug/unplug the last two actions of the menu. + // Another way would be to keep around the actions and plug them all into a (new each time) popupmenu. + TDEMainWindow *kmw = tqt_dynamic_cast(mainWindow()); + if ( kmw ) { + kmw->setupToolbarMenuActions(); + // Only allow hiding a toolbar if the action is also plugged somewhere else (e.g. menubar) + TDEAction *tbAction = kmw->toolBarMenuAction(); + if ( tbAction && tbAction->containerCount() > 0 ) + tbAction->plug(context); + } + + // try to find "configure toolbars" action + TDEAction *configureAction = 0; + const char* actionName = KStdAction::name(KStdAction::ConfigureToolbars); + if ( d->m_xmlguiClient ) + configureAction = d->m_xmlguiClient->actionCollection()->action(actionName); + if ( !configureAction && kmw ) + configureAction = kmw->actionCollection()->action(actionName); + if ( configureAction ) + configureAction->plug(context); + KEditToolbar::setDefaultToolbar(name()); + + for(int i = CONTEXT_ICONS; i <= CONTEXT_TEXTUNDER; ++i) + context->setItemChecked(i, false); + + switch( d->m_iconText ) + { + case IconOnly: + default: + context->setItemChecked(CONTEXT_ICONS, true); + break; + case IconTextRight: + context->setItemChecked(CONTEXT_TEXTRIGHT, true); + break; + case TextOnly: + context->setItemChecked(CONTEXT_TEXT, true); + break; + case IconTextBottom: + context->setItemChecked(CONTEXT_TEXTUNDER, true); + break; + } + + TQValueList::ConstIterator iIt = d->iconSizes.begin(); + TQValueList::ConstIterator iEnd = d->iconSizes.end(); + for (; iIt != iEnd; ++iIt ) + context->setItemChecked( CONTEXT_ICONSIZES + *iIt, false ); + + context->setItemChecked( CONTEXT_ICONSIZES, false ); + + context->setItemChecked( CONTEXT_ICONSIZES + d->m_iconSize, true ); + + for ( int i = CONTEXT_TOP; i <= CONTEXT_FLAT; ++i ) + context->setItemChecked( i, false ); + + switch ( barPos() ) + { + case TDEToolBar::Flat: + context->setItemChecked( CONTEXT_FLAT, true ); + break; + case TDEToolBar::Bottom: + context->setItemChecked( CONTEXT_BOTTOM, true ); + break; + case TDEToolBar::Left: + context->setItemChecked( CONTEXT_LEFT, true ); + break; + case TDEToolBar::Right: + context->setItemChecked( CONTEXT_RIGHT, true ); + break; + case TDEToolBar::Floating: + context->setItemChecked( CONTEXT_FLOAT, true ); + break; + case TDEToolBar::Top: + context->setItemChecked( CONTEXT_TOP, true ); + break; + default: break; + } +} + +void TDEToolBar::slotContextAboutToHide() +{ + // We have to unplug whatever slotContextAboutToShow plugged into the menu. + // Unplug the toolbar menu action + TDEMainWindow *kmw = tqt_dynamic_cast(mainWindow()); + if ( kmw && kmw->toolBarMenuAction() ) + if ( kmw->toolBarMenuAction()->containerCount() > 1 ) + kmw->toolBarMenuAction()->unplug(context); + + // Unplug the configure toolbars action too, since it's afterwards anyway + TDEAction *configureAction = 0; + const char* actionName = KStdAction::name(KStdAction::ConfigureToolbars); + if ( d->m_xmlguiClient ) + configureAction = d->m_xmlguiClient->actionCollection()->action(actionName); + if ( !configureAction && kmw ) + configureAction = kmw->actionCollection()->action(actionName); + if ( configureAction ) + configureAction->unplug(context); + + TQPtrListIterator it( widgets ); + TQWidget *wdg; + while ( ( wdg = it.current() ) != 0 ) { + if ( wdg->inherits( TQTOOLBUTTON_OBJECT_NAME_STRING ) ) + static_cast( wdg )->setDown( false ); + ++it; + } +} + +void TDEToolBar::widgetDestroyed() +{ + removeWidgetInternal( (TQWidget*)sender() ); +} + +void TDEToolBar::removeWidgetInternal( TQWidget * w ) +{ + widgets.removeRef( w ); + TQMap< TQWidget*, int >::Iterator it = widget2id.find( w ); + if ( it == widget2id.end() ) + return; + id2widget.remove( *it ); + widget2id.remove( it ); +} + +void TDEToolBar::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +#include "ktoolbar.moc" + -- cgit v1.2.3