fixes

4 files changed, 4 insertions, 11 deletions

diff --git a/microkde/kapplication.cpp b/microkde/kapplication.cpp
index 21aa0a4..f05b91b 100644
--- a/microkde/kapplication.cpp
+++ b/microkde/kapplication.cpp
@@ -1,110 +1,111 @@
 #include <stdlib.h>
 #include <stdio.h>
 
 #include "kapplication.h"
 #include "ktextedit.h"
 #include <qapplication.h>
 #include <qstring.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qdialog.h>
 #include <qlayout.h>
 #include <qtextbrowser.h>
 
 int KApplication::random()
 {
   return rand();
 }
 
 //US
 QString KApplication::randomString(int length)
 {
    if (length <=0 ) return QString::null;
 
    QString str;
    while (length--)
    {
       int r=random() % 62;
       r+=48;
       if (r>57) r+=7;
       if (r>90) r+=6;
       str += char(r);
       // so what if I work backwards?
    }
    return str;
 }
 int KApplication::execDialog( QDialog* d )
 {
     if (QApplication::desktop()->width() <= 640 )    
         d->showMaximized();
     else
         ;//d->resize( 800, 600 );
     return d->exec();
 }
 void KApplication::showLicence()
 {
    KApplication::showFile( "KDE-Pim/Pi licence", "kdepim/licence.txt" );
 }
 
 void KApplication::showFile(QString caption, QString fn)
 {
     QString text;
     QString fileName;
 #ifndef DESKTOP_VERSION
    fileName = getenv("QPEDIR");
    fileName += "/pics/" + fn ;
 #else
    fileName  = qApp->applicationDirPath () + "/" + fn;
 #endif 
     QFile file( fileName );
     if (!file.open( IO_ReadOnly ) ) {
         return ;
     } 
     QTextStream ts( &file );
     text = ts.read();
     file.close();
     KApplication::showText( caption, text );
   
 }
  
 bool KApplication::convert2latin1(QString fileName)
 {
     QString text;
     QFile file( fileName );
     if (!file.open( IO_ReadOnly ) ) {
         return false;
         
     } 
     QTextStream ts( &file );
     ts.setEncoding( QTextStream::UnicodeUTF8 );
     text = ts.read();
     file.close();  
     if (!file.open( IO_WriteOnly ) ) {
         return false;
     }
     QTextStream tsIn( &file );
     tsIn.setEncoding( QTextStream::Latin1 );
     tsIn << text.latin1();
     file.close();  
+    return true; 
  
 
 }
 void KApplication::showText(QString caption, QString text)
 {
     QDialog dia( 0, "name", true ); ;
     dia.setCaption( caption );
     QVBoxLayout* lay = new QVBoxLayout( &dia );
     lay->setSpacing( 3 );
     lay->setMargin( 3 );
     KTextEdit tb ( &dia );
     tb.setWordWrap( QMultiLineEdit::WidgetWidth );
     lay->addWidget( &tb ); 
     tb.setText( text );
 #ifdef DESKTOP_VERSION
     dia.resize( 640, 480);
 #else
     dia.showMaximized();
 #endif
     dia.exec();
 
 }
diff --git a/microkde/kdecore/klibloader.cpp b/microkde/kdecore/klibloader.cpp
index 1394154..6d0475a 100644
--- a/microkde/kdecore/klibloader.cpp
+++ b/microkde/kdecore/klibloader.cpp
@@ -371,266 +371,258 @@ QString KLibLoader::findLibrary( const char * name/*US , const KInstance * insta
     // (mhk, 20000228)
     int pos = libname.findRev('/');
     if (pos < 0)
       pos = 0;
 /*US      
     if (libname.find('.', pos) < 0) {
       libname += ".la";
     }
 */    
 //US in the microedition we work only with shared libraries.
 
     if (libname.find('.', pos) < 0) {
 #ifdef _WIN32_
       libname += ".dll";
 #else
       libname += ".so";
 #endif
     }
 
     // only look up the file if it is not an absolute filename
     // (mhk, 20000228)
     QString libfile;
     if (libname[0] == '/')
       libfile = libname;
     else
     {
 //US at this point the libname must exist as real filesname. No expansions will be made later
 // in findResources. Because of that we prepend the lib prefix here to the name 
 //US I add also the "lib" prefix. I do not how could this could have worked before without it?
 #ifndef _WIN32_
     libname.insert(pos, "lib");
 #endif
     
     
 //US      libfile = instance->dirs()->findResource( "module", libname );
     //qDebug("libname = %s ",libname.data() );
       libfile = KGlobal::dirs()->findResource( "module", libname );
       //qDebug("libfile = %s ",libfile.latin1() );
 
       if ( libfile.isEmpty() )
       {
 //US        libfile = instance->dirs()->findResource( "lib", libname );
         libfile = KGlobal::dirs()->findResource( "lib", libname );
         //qDebug("libfile2 = %s ",libfile.latin1() );
 #ifndef NDEBUG
         if ( !libfile.isEmpty() && libname.left(3) == "lib" ) // don't warn for kdeinit modules
           kdDebug(150) << "library " << libname << " not found under 'module' but under 'lib'" << endl;
 #endif
       }
       if ( libfile.isEmpty() )
       {
 #ifndef NDEBUG
         kdDebug(150) << "library=" << libname << ": No file names " << libname.data() << " found in paths." << endl;
         self()->d->errorMessage = i18n("Library files for \"%1\" not found in paths").arg(libname); 
             
         qDebug("KLibLoader::library could not find library: %s", libname.data());
 #endif
             
       }
       else
             self()->d->errorMessage = QString::null;
     }
 
     //qDebug("return libfile = %s ",libfile.latin1() );
     return libfile;
 }
 
 
 KLibrary* KLibLoader::globalLibrary( const char *name )
 {
 KLibrary *tmp;
 /*US
 int olt_dlopen_flag = lt_dlopen_flag;
 
    lt_dlopen_flag |= LT_GLOBAL;
    kdDebug(150) << "Loading the next library global with flag " 
                 << lt_dlopen_flag
                 << "." << endl;
 */                
    tmp = library(name);
 /*US   
    lt_dlopen_flag = olt_dlopen_flag;
 */
 return tmp;
 }
 
 
 KLibrary* KLibLoader::library( const char *name )
 {
     if (!name)
         return 0;
 
     KLibWrapPrivate* wrap = m_libs[name];
     if (wrap) {
       /* Nothing to do to load the library.  */
       wrap->ref_count++;
       return wrap->lib;
     }
 
     /* Test if this library was loaded at some time, but got
        unloaded meanwhile, whithout being dlclose()'ed.  */
     QPtrListIterator<KLibWrapPrivate> it(d->loaded_stack);
     for (; it.current(); ++it) {
       if (it.current()->name == name)
         wrap = it.current();
     }
 
     if (wrap) {
       d->pending_close.removeRef(wrap);
       if (!wrap->lib) {
         /* This lib only was in loaded_stack, but not in m_libs.  */
         wrap->lib = new KLibrary( name, wrap->filename, wrap->handle );
       }
       wrap->ref_count++;
     } else {
       QString libfile = findLibrary( name );
       if ( libfile.isEmpty() )
         return 0;
 #ifdef DESKTOP_VERSION
       QLibrary *qlib = new QLibrary( libfile.latin1() );
 #else
       QLibrary *qlib = new QLibrary( libfile.latin1(), QLibrary::Immediately );
 #endif
         
 //US      lt_dlhandle handle = lt_dlopen( libfile.latin1() );
 //US      if ( !handle )
       if ( !qlib )
       {
-//US        const char* errmsg = lt_dlerror();
-        char* errmsg;
-        sprintf(errmsg, "KLibLoader::library could not load library: %s", libfile.latin1());
-        qDebug(errmsg);
-        
-        if(errmsg)
-            d->errorMessage = QString::fromLatin1(errmsg);
-        else
+          qDebug( "KLibLoader::library could not load library: %s", libfile.latin1());
             d->errorMessage = QString::null;
-        kdWarning(150) << "library=" << name << ": file=" << libfile << ": " << d->errorMessage << endl;
         return 0;
       }
       else
         d->errorMessage = QString::null;
 
       KLibrary *lib = new KLibrary( name, libfile, qlib );
       wrap = new KLibWrapPrivate(lib, qlib);
       d->loaded_stack.prepend(wrap);
     }
     m_libs.insert( name, wrap );
 
     connect( wrap->lib, SIGNAL( destroyed() ),
              this, SLOT( slotLibraryDestroyed() ) );
 
     return wrap->lib;
 }
 
 QString KLibLoader::lastErrorMessage() const
 {
     return d->errorMessage;
 }
 
 void KLibLoader::unloadLibrary( const char *libname )
 {
   KLibWrapPrivate *wrap = m_libs[ libname ];
   if (!wrap)
     return;
   if (--wrap->ref_count)
     return;
 
 //  kdDebug(150) << "closing library " << libname << endl;
 
   m_libs.remove( libname );
 
   disconnect( wrap->lib, SIGNAL( destroyed() ),
               this, SLOT( slotLibraryDestroyed() ) );
   close_pending( wrap );
 }
 
 KLibFactory* KLibLoader::factory( const char* name )
 {
     KLibrary* lib = library( name );
     if ( !lib )
         return 0;
 
     return lib->factory();
 }
 
 void KLibLoader::slotLibraryDestroyed()
 {
   const KLibrary *lib = static_cast<const KLibrary *>( sender() );
 
   QAsciiDictIterator<KLibWrapPrivate> it( m_libs );
   for (; it.current(); ++it )
     if ( it.current()->lib == lib )
     {
       KLibWrapPrivate *wrap = it.current();
       wrap->lib = 0;  /* the KLibrary object is already away */
       m_libs.remove( it.currentKey() );
       close_pending( wrap );
       return;
     }
 }
 
 void KLibLoader::close_pending(KLibWrapPrivate *wrap)
 {
   if (wrap && !d->pending_close.containsRef( wrap ))
     d->pending_close.append( wrap );
 
   /* First delete all KLibrary objects in pending_close, but _don't_ unload
      the DSO behind it.  */
   QPtrListIterator<KLibWrapPrivate> it(d->pending_close);
   for (; it.current(); ++it) {
     wrap = it.current();
     if (wrap->lib) {
       disconnect( wrap->lib, SIGNAL( destroyed() ),
                   this, SLOT( slotLibraryDestroyed() ) );
       delete wrap->lib;
       wrap->lib = 0;
     }
   }
 
   if (d->unload_mode == KLibLoaderPrivate::DONT_UNLOAD) return;
 
   bool deleted_one = false;
   while ((wrap = d->loaded_stack.first())) {
     /* Let's first see, if we want to try to unload this lib.
        If the env. var KDE_DOUNLOAD is set, we try to unload every lib.
        If not, we look at the lib itself, and unload it only, if it exports
        the symbol __kde_do_unload. */
     if (d->unload_mode != KLibLoaderPrivate::UNLOAD
         && wrap->unload_mode != KLibWrapPrivate::UNLOAD)
       break;
 
     /* Now ensure, that the libs are only unloaded in the reverse direction
        they were loaded.  */
     if (!d->pending_close.containsRef( wrap )) {
       if (!deleted_one)
         /* Only diagnose, if we really haven't deleted anything. */
 //        kdDebug(150) << "try to dlclose " << wrap->name << ": not yet" << endl;
       break;
     }
 
 //    kdDebug(150) << "try to dlclose " << wrap->name << ": yes, done." << endl;
 
 #if 0
 #ifndef Q_WS_QWS
     if ( !deleted_one ) {
       /* Only do the hack once in this loop.
          WABA: *HACK*
          We need to make sure to clear the clipboard before unloading a DSO
          because the DSO could have defined an object derived from QMimeSource
          and placed that on the clipboard. */
       /*kapp->clipboard()->clear();*/
 
       /* Well.. let's do something more subtle... convert the clipboard context
          to text. That should be safe as it only uses objects defined by Qt. */
 
       QWidgetList *widgetlist = QApplication::topLevelWidgets();
       QWidget *co = widgetlist->first();
       while (co) {
         if (qstrcmp(co->name(), "internal clipboard owner") == 0) {
           if (XGetSelectionOwner(co->x11Display(), XA_PRIMARY) == co->winId())
 	    kapp->clipboard()->setText(kapp->clipboard()->text());
 
           break;
         }
         co = widgetlist->next();
diff --git a/microkde/kdeui/ktoolbar.cpp b/microkde/kdeui/ktoolbar.cpp
index 1ad1728..09ad0c8 100644
--- a/microkde/kdeui/ktoolbar.cpp
+++ b/microkde/kdeui/ktoolbar.cpp
@@ -753,257 +753,257 @@ KToolBarButton * KToolBar::getButton (int id)
         return 0;
 //US    return dynamic_cast<KToolBarButton *>( *it );
     return (KToolBarButton *)( *it );
 }
 
 
 void KToolBar::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);
 }
 
 
 QWidget *KToolBar::getWidget (int id)
 {
     Id2WidgetMap::Iterator it = id2widget.find( id );
     return ( it == id2widget.end() ) ? 0 : (*it);
 }
 
 
 void KToolBar::setItemAutoSized (int id, bool yes )
 {
     QWidget *w = getWidget(id);
     if ( w && yes )
         setStretchableWidget( w );
 }
 
 
 void KToolBar::clear ()
 {
     QToolBar::clear();
     widget2id.clear();
     id2widget.clear();
 }
 
 
 void KToolBar::removeItem(int id)
 {
     Id2WidgetMap::Iterator it = id2widget.find( id );
     if ( it == id2widget.end() )
     {
         kdDebug(220) << "KToolBar::removeItem item " << id << " not found" << endl;
         return;
     }
     QWidget * w = (*it);
     id2widget.remove( id );
     widget2id.remove( w );
     widgets.removeRef( w );
     delete w;
 }
 
 
 void KToolBar::removeItemDelayed(int id)
 {
     Id2WidgetMap::Iterator it = id2widget.find( id );
     if ( it == id2widget.end() )
     {
         kdDebug(220) << "KToolBar::removeItem item " << id << " not found" << endl;
         return;
     }
     QWidget * w = (*it);
     id2widget.remove( id );
     widget2id.remove( w );
     widgets.removeRef( w );
 
     w->blockSignals(true);
     d->idleButtons.append(w);
     layoutTimer->start( 50, TRUE );
 }
 
 
 void KToolBar::hideItem (int id)
 {
     QWidget *w = getWidget(id);
     if ( w )
         w->hide();
 }
 
 
 void KToolBar::showItem (int id)
 {
     QWidget *w = getWidget(id);
     if ( w )
         w->show();
 }
 
 
 int KToolBar::itemIndex (int id)
 {
     QWidget *w = getWidget(id);
     return w ? widgets.findRef(w) : -1;
 }
 
 
 void KToolBar::setFullSize(bool flag )
 {
     setHorizontalStretchable( flag );
     setVerticalStretchable( flag );
 }
 
 
 bool KToolBar::fullSize() const
 {
     return isHorizontalStretchable() || isVerticalStretchable();
 }
 
 
 void KToolBar::enableMoving(bool flag )
 {
 //US    setMovingEnabled(flag);
   this->mainWindow()->setToolBarsMovable(flag);    
 }
 
 
 void KToolBar::setBarPos (BarPosition bpos)
 {
     if ( !mainWindow() )
         return;
 //US    mainWindow()->moveDockWindow( this, (Dock)bpos );
     mainWindow()->moveToolBar( this, (QMainWindow::ToolBarDock)bpos );
 }
 
 
-KToolBar::BarPosition KToolBar::barPos()
+KToolBar::BarPosition KToolBar::barPos() const
 {
     if ( !(QMainWindow*)mainWindow() )
         return KToolBar::Top;
 //US    Dock dock;
     QMainWindow::ToolBarDock dock;
     int dm1, dm2;
     bool dm3;
     ((QMainWindow*)mainWindow())->getLocation( (QToolBar*)this, dock, dm1, dm3, dm2 );
 //US    if ( dock == DockUnmanaged ) {
     if ( dock == QMainWindow::Unmanaged ) {
         return (KToolBar::BarPosition)Top;
     }
     return (BarPosition)dock;
 }
 
 
 bool KToolBar::enable(BarStatus stat)
 {
     bool mystat = isVisible();
 
     if ( (stat == Toggle && mystat) || stat == Hide )
         hide();
     else
         show();
 
     return isVisible() == mystat;
 }
 
 
 void KToolBar::setMaxHeight ( int h )
 {
     setMaximumHeight( h );
 }
 
 int KToolBar::maxHeight()
 {
     return maximumHeight();
 }
 
 
 void KToolBar::setMaxWidth (int dw)
 {
     setMaximumWidth( dw );
 }
 
 
 int KToolBar::maxWidth()
 {
     return maximumWidth();
 }
 
 
 void KToolBar::setTitle (const QString& _title)
 {
     setLabel( _title );
 }
 
 
 void KToolBar::enableFloating (bool )
 {
 }
 
 
 void KToolBar::setIconText(IconText it)
 {
     setIconText( it, true );
 }
 
 
 void KToolBar::setIconText(IconText icontext, bool update)
 {
     bool doUpdate=false;
 
     if (icontext != d->m_iconText) {
         d->m_iconText = icontext;
         doUpdate=true;
     }
 
     if (update == false)
         return;
 
     if (doUpdate)
         emit modechange(); // tell buttons what happened
 
     // ugly hack to force a QMainWindow::triggerLayout( TRUE )
     if ( mainWindow() ) {
         QMainWindow *mw = mainWindow();
         mw->setUpdatesEnabled( FALSE );
         mw->setToolBarsMovable( !mw->toolBarsMovable() );
         mw->setToolBarsMovable( !mw->toolBarsMovable() );
         mw->setUpdatesEnabled( TRUE );
     }
 }
 
 
 KToolBar::IconText KToolBar::iconText() const
 {
     return d->m_iconText;
 }
 
 
 void KToolBar::setIconSize(int size)
 {
     setIconSize( size, true );
 }
 
 void KToolBar::setIconSize(int size, bool update)
 {
     bool doUpdate=false;
 
     if ( size != d->m_iconSize ) {
             d->m_iconSize = size;
             doUpdate=true;
     }
 
     if (update == false)
         return;
 
     if (doUpdate)
         emit modechange(); // tell buttons what happened
 
     // ugly hack to force a QMainWindow::triggerLayout( TRUE )
     if ( mainWindow() ) {
         QMainWindow *mw = mainWindow();
         mw->setUpdatesEnabled( FALSE );
         mw->setToolBarsMovable( !mw->toolBarsMovable() );
         mw->setToolBarsMovable( !mw->toolBarsMovable() );
         mw->setUpdatesEnabled( TRUE );
diff --git a/microkde/kdeui/ktoolbar.h b/microkde/kdeui/ktoolbar.h
index 61b5ea3..49ff856 100644
--- a/microkde/kdeui/ktoolbar.h
+++ b/microkde/kdeui/ktoolbar.h
@@ -621,257 +621,257 @@ public:
    * as @ref QLineEdit plus completion signals.
    */
     KLineEdit * getLined (int id);
 
     /**
    * Returns a pointer to KToolBarButton.
    *
    * Example:
    * <pre>
    * KToolBarButton * button = toolbar->getButton(button_id);
    * </pre>
    * That way you can get access to other public methods
    * that @ref KToolBarButton provides.
    *
    *  Using this method is not recommended.
    */
     KToolBarButton * getButton (int id);
 
     /**
    * Align item to the right.
    *
    * This works only if toolbar is set to full width.
    * @see setFullWidth()
    */
     void alignItemRight (int id, bool right = true);
 
     /**
    * Returns a pointer to an inserted widget.
    *
    * Wrong ids are not tested.
    * You can do with this whatever you want,
    * except change its height (hardcoded). If you change its width
    * you will probably have to call QToolBar::updateRects(true)
    * @see QWidget
    * @see updateRects()
    * 
    * KDE4: make this const!
    */
     QWidget *getWidget (int id);
 
     /**
    * Set item autosized.
    *
    * This works only if the toolbar is set to full width.
    * Only @p one item can be autosized, and it has to be
    * the last left-aligned item. Items that come after this must be right
    * aligned. Items that can be right aligned are Lineds, Frames, Widgets and
    * Combos. An autosized item will resize itself whenever the toolbar geometry
    * changes to the last right-aligned item (or to end of toolbar if there
    * are no right-aligned items.)
    * @see setFullWidth()
    * @see alignItemRight()
    */
     void setItemAutoSized (int id, bool yes = true);
 
     /**
    * Remove all items.
    *
    * The toolbar is redrawn after it.
    */
     void clear ();
 
     /**
    * Remove item @p id.
    *
    * Item is deleted. Toolbar is redrawn after it.
    */
     void removeItem (int id);
 
     /**
    * Remove item @p id.
    *
    * Item is deleted when toolbar is redrawn.
    */
     void removeItemDelayed (int id);
 
     /**
    * Hide item.
    */
     void hideItem (int id);
 
     /**
    * Show item.
    */
     void showItem (int id);
 
     /**
    * Returns the index of the given item.
    *
    * KDE4: make this const!
    */
     int itemIndex (int id);
 
     /**
    * Set toolbar to full parent size (default).
    *
    *  In full size mode the bar
    * extends over the parent's full width or height. If the mode is disabled
    * the toolbar tries to take as much space as it needs without wrapping, but
    * it does not exceed the parent box. You can force a certain width or
    * height with @ref setMaxWidth() or @ref setMaxHeight().
    *
    * If you want to use right-aligned items or auto-sized items you must use
    * full size mode.
    */
     void setFullSize(bool flag = true);
 
     /**
    * @return @p true if the full-size mode is enabled. Otherwise
    * it returns @false.
    */
     bool fullSize() const;
 
     /**
    * @deprecated use setMovingEnabled(bool) instead.
    * Enable or disable moving of toolbar.
    */
     void enableMoving(bool flag = true);
 
     /**
    * Set position of toolbar.
    * @see BarPosition()
    */
     void setBarPos (BarPosition bpos);
 
     /**
    * Returns position of toolbar.
    */
-    BarPosition barPos();
+    BarPosition barPos() const;
 
   /**
    * @deprecated
    * Show, hide, or toggle toolbar.
    *
    * This method is provided for compatibility only,
    * please use show() and/or hide() instead.
    * @see BarStatus
    */
     bool enable(BarStatus stat);
 
   /**
    * @deprecated
    * Use setMaximumHeight() instead.
    */
     void setMaxHeight (int h);  // Set max height for vertical toolbars
 
   /**
    * @deprecated
    * Use maximumHeight() instead.
    * Returns the value that was set with @ref setMaxHeight().
    */
     int maxHeight();
 
   /**
    * @deprecated
    * Use setMaximumWidth() instead.
    * Set maximal width of horizontal (top or bottom) toolbar.
    */
     void setMaxWidth (int dw);
 
   /**
    * @deprecated
    * Use maximumWidth() instead.
    * Returns the value that was set with @ref setMaxWidth().
    */
     int maxWidth();
 
   /**
    * Set title for toolbar when it floats.
    *
    * Titles are however not (yet)
    * visible. You can't change toolbar's title while it's floating.
    */
     void setTitle (const QString& _title);
 
   /**
    * @deprecated
    * Use enableMoving() instead.
    */
     void enableFloating (bool arrrrrrgh);
 
   /**
    * Set the kind of painting for buttons.
    *
    * Choose from:
    * @li IconOnly (only icons),
    * @li IconTextRight (icon and text, text is left from icons),
    * @li TextOnly (only text),
    * @li IconTextBottom (icons and text, text is under icons).
    * @see IconText
    *
    */
     void setIconText(IconText it);
    // Note: don't merge with the next one, it breaks Qt properties
 
   /**
    * Similar to @ref setIconText(IconText it) but allows you to
    * disable or enable updating.  If @p update is false, then the
    * buttons will not be updated.  This is useful only if you know
    * that you will be forcing an update later.
    */
     void setIconText(IconText it, bool update);
 
   /**
    * @return The current text style for buttons.
    */
     IconText iconText() const;
 
   /**
    * Set the icon size to load. Usually you should not call
    * this, the icon size is taken care of by KIconLoader
    * and globally configured.
    * By default, the toolbar will load icons of size 32 for main
    * toolbars and 22 for other toolbars
    * @see KIconLoader.
    *
    * @param size The size to use
    */
     void setIconSize(int size);
     // Note: don't merge with the next one, it breaks Qt properties
 
   /**
    * Same as @ref setIconText(int size) but allows you
    * to disable the toolbar update.
    *
    * @param size   The size to use
    * @param update If true, then the toolbar will be updated after
    *               this
    */
     void setIconSize(int size, bool update);
 
   /**
    * @return The current icon size for buttons.
    */
     int iconSize() const;
 
   /**
    * This allows you to enable or disable the context menu.
    *
    * @param enable If false, then the context menu will be disabled
    */
     void setEnableContextMenu(bool enable = true);
 
   /**
    * Returns whether or not the context menu is disabled
    *
    * @return The context menu state
    */
     bool contextMenuEnabled() const;
 
   /**
    * This will inform a toolbar button to ignore certain style
    * changes.  Specifically, it will ignore IconText (always IconOnly)
    * and will not allow image effects to apply.
    *
    * @param id The button to exclude from styles
    * @param no_style If true, then it is excluded (default: true).