Rename a number of libraries and executables to avoid conflicts with KDE4

1 files changed, 523 insertions, 0 deletions

diff --git a/lib/compatibility/tdemdi/qextmdi/ktabwidget.cpp b/lib/compatibility/tdemdi/qextmdi/ktabwidget.cpp
new file mode 100644
index 00000000..041143d9
--- /dev/null
+++ b/lib/compatibility/tdemdi/qextmdi/ktabwidget.cpp
@@ -0,0 +1,523 @@
+/* This file is part of the KDE libraries
+    Copyright (C) 2003 Stephan Binner <binner@kde.org>
+    Copyright (C) 2003 Zack Rusin <zack@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 as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    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 <tqapplication.h>
+#include <tqstyle.h>
+
+#include <kconfig.h>
+#include <kiconloader.h>
+#include <kstringhandler.h>
+
+#include "ktabwidget.h"
+#include "ktabbar.h"
+
+class KTabWidgetPrivate {
+public:
+    bool m_automaticResizeTabs;
+    int m_maxLength;
+    int m_minLength;
+    unsigned int m_CurrentMaxLength;
+
+    //holds the full names of the tab, otherwise all we
+    //know about is the shortened name
+    TQStringList m_tabNames;
+
+    KTabWidgetPrivate() {
+        m_automaticResizeTabs = false;
+        TDEConfigGroupSaver groupsaver(TDEGlobal::config(), "General");
+        m_maxLength = TDEGlobal::config()->readNumEntry("MaximumTabLength", 30);
+        m_minLength = TDEGlobal::config()->readNumEntry("MinimumTabLength", 3);
+        m_CurrentMaxLength = m_minLength;
+    }
+};
+
+KTabWidget::KTabWidget( TQWidget *parent, const char *name, WFlags f )
+    : TQTabWidget( parent, name, f )
+{
+    d = new KTabWidgetPrivate;
+    setTabBar( new KTabBar(this, "tabbar") );
+    setAcceptDrops( true );
+
+    connect(tabBar(), TQT_SIGNAL(contextMenu( int, const TQPoint & )), TQT_SLOT(contextMenu( int, const TQPoint & )));
+    connect(tabBar(), TQT_SIGNAL(mouseDoubleClick( int )), TQT_SLOT(mouseDoubleClick( int )));
+    connect(tabBar(), TQT_SIGNAL(mouseMiddleClick( int )), TQT_SLOT(mouseMiddleClick( int )));
+    connect(tabBar(), TQT_SIGNAL(initiateDrag( int )), TQT_SLOT(initiateDrag( int )));
+    connect(tabBar(), TQT_SIGNAL(testCanDecode(const TQDragMoveEvent *, bool & )), TQT_SIGNAL(testCanDecode(const TQDragMoveEvent *, bool & )));
+    connect(tabBar(), TQT_SIGNAL(receivedDropEvent( int, TQDropEvent * )), TQT_SLOT(receivedDropEvent( int, TQDropEvent * )));
+    connect(tabBar(), TQT_SIGNAL(moveTab( int, int )), TQT_SLOT(moveTab( int, int )));
+    connect(tabBar(), TQT_SIGNAL(closeRequest( int )), TQT_SLOT(closeRequest( int )));
+#ifndef TQT_NO_WHEELEVENT
+    connect(tabBar(), TQT_SIGNAL(wheelDelta( int )), TQT_SLOT(wheelDelta( int )));
+#endif
+}
+
+KTabWidget::~KTabWidget()
+{
+    delete d;
+}
+
+void KTabWidget::insertTab( TQWidget *child, const TQString &label, int index )
+{
+    TQTabWidget::insertTab( child, label, index );
+}
+
+void KTabWidget::insertTab( TQWidget *child, const TQIconSet& iconset, const TQString &label, int index )
+{
+    TQTabWidget::insertTab( child, iconset, label, index );
+}
+
+void KTabWidget::insertTab( TQWidget *child, TQTab *tab, int index )
+{
+    TQTabWidget::insertTab( child, tab, index);
+    if ( d->m_automaticResizeTabs ) {
+        if ( index < 0 || index >= count() ) {
+            d->m_tabNames.append( tab->text() );
+            resizeTabs( d->m_tabNames.count()-1 );
+        }
+        else {
+            d->m_tabNames.insert( d->m_tabNames.at( index ), tab->text() );
+            resizeTabs( index );
+        }
+    }
+}
+
+void KTabWidget::setTabBarHidden( bool hide )
+{
+    TQWidget *rightcorner = this->cornerWidget( TopRight );
+    TQWidget *leftcorner = this->cornerWidget( TopLeft );
+
+    if ( hide ) {
+        if ( leftcorner ) leftcorner->hide();
+        if ( rightcorner ) rightcorner->hide();
+        tabBar()->hide();
+    } else {
+        tabBar()->show();
+        if ( leftcorner ) leftcorner->show();
+        if ( rightcorner ) rightcorner->show();
+    }
+}
+
+bool KTabWidget::isTabBarHidden() const
+{
+    return !( tabBar()->isVisible() );
+}
+
+void KTabWidget::setTabColor( TQWidget *w, const TQColor& color )
+{
+    TQTab *t = tabBar()->tabAt( indexOf( w ) );
+    if (t) {
+        static_cast<KTabBar*>(tabBar())->setTabColor( t->identifier(), color );
+    }
+}
+
+TQColor KTabWidget::tabColor( TQWidget *w ) const
+{
+    TQTab *t = tabBar()->tabAt( indexOf( w ) );
+    if (t) {
+        return static_cast<KTabBar*>(tabBar())->tabColor( t->identifier() );
+    } else {
+        return TQColor();
+    }
+}
+
+void KTabWidget::setTabReorderingEnabled( bool on)
+{
+    static_cast<KTabBar*>(tabBar())->setTabReorderingEnabled( on );
+}
+
+bool KTabWidget::isTabReorderingEnabled() const
+{
+    return static_cast<KTabBar*>(tabBar())->isTabReorderingEnabled();
+}
+
+void KTabWidget::setTabCloseActivatePrevious( bool previous)
+{
+    static_cast<KTabBar*>(tabBar())->setTabCloseActivatePrevious( previous );
+}
+
+bool KTabWidget::tabCloseActivatePrevious() const
+{
+    return static_cast<KTabBar*>(tabBar())->tabCloseActivatePrevious();
+}
+
+unsigned int KTabWidget::tabBarWidthForMaxChars( uint maxLength )
+{
+    int hframe, overlap;
+    hframe  = tabBar()->style().pixelMetric( TQStyle::PM_TabBarTabHSpace, tabBar() );
+    overlap = tabBar()->style().pixelMetric( TQStyle::PM_TabBarTabOverlap, tabBar() );
+
+    TQFontMetrics fm = tabBar()->fontMetrics();
+    int x = 0;
+    for( int i=0; i < count(); ++i ) {
+        TQString newTitle = d->m_tabNames[ i ];
+        newTitle = KStringHandler::rsqueeze( newTitle, maxLength ).leftJustify( d->m_minLength, ' ' );
+
+        TQTab* tab = tabBar()->tabAt( i );
+        int lw = fm.width( newTitle );
+        int iw = 0;
+        if ( tab->iconSet() )
+          iw = tab->iconSet()->pixmap( TQIconSet::Small, TQIconSet::Normal ).width() + 4;
+        x += ( tabBar()->style().tqsizeFromContents( TQStyle::CT_TabBarTab, this,
+                   TQSize( TQMAX( lw + hframe + iw, TQApplication::globalStrut().width() ), 0 ),
+                   TQStyleOption( tab ) ) ).width();
+    }
+    return x;
+}
+
+void KTabWidget::changeTab( TQWidget *w, const TQString &label )
+{
+    TQTabWidget::changeTab( w, label );
+    if ( d->m_automaticResizeTabs ) {
+        int index = indexOf( w );
+        if ( index != -1 ) {
+            d->m_tabNames[ index ] = label;
+            resizeTabs( index );
+        }
+    }
+}
+
+void KTabWidget::changeTab( TQWidget *w, const TQIconSet &iconset, const TQString &label )
+{
+    TQTabWidget::changeTab( w, iconset, label );
+    if ( d->m_automaticResizeTabs ) {
+        int index = indexOf( w );
+        if ( index != -1 ) {
+            d->m_tabNames[ index ] = label;
+            resizeTabs( index );
+        }
+    }
+}
+
+TQString KTabWidget::label( int index ) const
+{
+    if ( d->m_automaticResizeTabs ) {
+        if ( index >= 0 && index < count() )
+            return d->m_tabNames[ index ];
+        else
+            return TQString();
+    }
+    else
+        return TQTabWidget::label( index );
+}
+
+TQString KTabWidget::tabLabel( TQWidget * w ) const
+{
+    if ( d->m_automaticResizeTabs ) {
+        int index = indexOf( w );
+        if ( index == -1 )
+            return TQString();
+        else
+            return d->m_tabNames[ index ];
+    }
+    else
+        return TQTabWidget::tabLabel( w );
+}
+
+void KTabWidget::setTabLabel( TQWidget *w, const TQString &l )
+{
+    TQTabWidget::setTabLabel( w, l );
+    if ( d->m_automaticResizeTabs ) {
+        int index = indexOf( w );
+        if ( index != -1 ) {
+            d->m_tabNames[ index ] = l;
+            resizeTabs( index );
+        }
+  }
+}
+
+void KTabWidget::resizeTabs( int changeTabIndex )
+{
+    uint newMaxLength;
+    if ( d->m_automaticResizeTabs ) {
+        // Calculate new max length
+        newMaxLength=d->m_maxLength;
+        uint lcw=0, rcw=0;
+
+        int tabBarHeight = tabBar()->sizeHint().height();
+        if ( cornerWidget( TopLeft ) && cornerWidget( TopLeft )->isVisible() )
+            lcw = TQMAX( cornerWidget( TopLeft )->width(), tabBarHeight );
+        if ( cornerWidget( TopRight ) && cornerWidget( TopRight )->isVisible() )
+            rcw = TQMAX( cornerWidget( TopRight )->width(), tabBarHeight );
+
+        uint maxTabBarWidth = width() - lcw - rcw;
+
+        for ( ; newMaxLength > (uint)d->m_minLength; newMaxLength-- ) {
+            if ( tabBarWidthForMaxChars( newMaxLength ) < maxTabBarWidth )
+                break;
+        }
+    }
+    else
+        newMaxLength = 4711;
+
+    // Update hinted or all tabs
+    if ( d->m_CurrentMaxLength != newMaxLength ) {
+        d->m_CurrentMaxLength = newMaxLength;
+        for( int i = 0; i < count(); ++i )
+            updateTab( i );
+    }
+    else if ( changeTabIndex != -1 )
+        updateTab( changeTabIndex );
+}
+
+void KTabWidget::updateTab( int index )
+{
+    TQString title = d->m_automaticResizeTabs ? d->m_tabNames[ index ] : TQTabWidget::label( index );
+    removeTabToolTip( page( index ) );
+    if ( title.length() > d->m_CurrentMaxLength )
+        setTabToolTip( page( index ), title );
+
+    title = KStringHandler::rsqueeze( title, d->m_CurrentMaxLength ).leftJustify( d->m_minLength, ' ' );
+    title.replace( '&', "&&" );
+
+    if ( TQTabWidget::label( index ) != title )
+        TQTabWidget::setTabLabel( page( index ), title );
+}
+
+void KTabWidget::dragMoveEvent( TQDragMoveEvent *e )
+{
+    if ( isEmptyTabbarSpace( e->pos() ) ) {
+        bool accept = false;
+        // The receivers of the testCanDecode() signal has to adjust
+        // 'accept' accordingly.
+        emit testCanDecode( e, accept);
+        e->accept( accept );
+        return;
+    }
+    e->accept( false );
+    TQTabWidget::dragMoveEvent( e );
+}
+
+void KTabWidget::dropEvent( TQDropEvent *e )
+{
+    if ( isEmptyTabbarSpace( e->pos() ) ) {
+        emit ( receivedDropEvent( e ) );
+        return;
+    }
+    TQTabWidget::dropEvent( e );
+}
+
+#ifndef TQT_NO_WHEELEVENT
+void KTabWidget::wheelEvent( TQWheelEvent *e )
+{
+    if ( e->orientation() ==Qt::Horizontal )
+        return;
+
+    if ( isEmptyTabbarSpace( e->pos() ) )
+        wheelDelta( e->delta() );
+    else
+        e->ignore();
+}
+
+void KTabWidget::wheelDelta( int delta )
+{
+    if ( count() < 2 )
+        return;
+
+    int page = currentPageIndex();
+    if ( delta < 0 )
+         page = (page + 1) % count();
+    else {
+        page--;
+        if ( page < 0 )
+            page = count() - 1;
+    }
+    setCurrentPage( page );
+}
+#endif
+
+void KTabWidget::mouseDoubleClickEvent( TQMouseEvent *e )
+{
+    if( e->button() != Qt::LeftButton )
+        return;
+
+    if ( isEmptyTabbarSpace( e->pos() ) ) {
+        emit( mouseDoubleClick() );
+        return;
+    }
+    TQTabWidget::mouseDoubleClickEvent( e );
+}
+
+void KTabWidget::mousePressEvent( TQMouseEvent *e )
+{
+    if ( e->button() == Qt::RightButton ) {
+        if ( isEmptyTabbarSpace( e->pos() ) ) {
+            emit( contextMenu( mapToGlobal( e->pos() ) ) );
+            return;
+        }
+    } else if ( e->button() == Qt::MidButton ) {
+        if ( isEmptyTabbarSpace( e->pos() ) ) {
+            emit( mouseMiddleClick() );
+            return;
+        }
+    }
+    TQTabWidget::mousePressEvent( e );
+}
+
+void KTabWidget::receivedDropEvent( int index, TQDropEvent *e )
+{
+    emit( receivedDropEvent( page( index ), e ) );
+}
+
+void KTabWidget::initiateDrag( int index )
+{
+    emit( initiateDrag( page( index ) ) );
+}
+
+void KTabWidget::contextMenu( int index, const TQPoint &p )
+{
+    emit( contextMenu( page( index ), p ) );
+}
+
+void KTabWidget::mouseDoubleClick( int index )
+{
+    emit( mouseDoubleClick( page( index ) ) );
+}
+
+void KTabWidget::mouseMiddleClick( int index )
+{
+    emit( mouseMiddleClick( page( index ) ) );
+}
+
+void KTabWidget::moveTab( int from, int to )
+{
+    TQString tablabel = label( from );
+    TQWidget *w = page( from );
+    TQColor color = tabColor( w );
+    TQIconSet tabiconset = tabIconSet( w );
+    TQString tabtooltip = tabToolTip( w );
+    bool current = ( w == currentPage() );
+    bool enabled = isTabEnabled( w );
+    blockSignals(true);
+    removePage( w );
+
+    // Work-around tdemdi brain damage which calls showPage() in insertTab()
+    TQTab * t = new TQTab();
+    t->setText(tablabel);
+    TQTabWidget::insertTab( w, t, to );
+    if ( d->m_automaticResizeTabs ) {
+        if ( to < 0 || to >= count() )
+            d->m_tabNames.append( TQString() );
+        else
+            d->m_tabNames.insert( d->m_tabNames.at( to ), TQString() );
+    }
+
+    w = page( to );
+    changeTab( w, tabiconset, tablabel );
+    setTabToolTip( w, tabtooltip );
+    setTabColor( w, color );
+    if ( current )
+        showPage( w );
+    setTabEnabled( w, enabled );
+    blockSignals(false);
+
+    emit ( movedTab( from, to ) );
+}
+
+void KTabWidget::removePage( TQWidget * w ) {
+    if ( d->m_automaticResizeTabs ) {
+        int index = indexOf( w );
+        if ( index != -1 )
+            d->m_tabNames.remove( d->m_tabNames.at( index ) );
+    }
+    TQTabWidget::removePage( w );
+    if ( d->m_automaticResizeTabs )
+        resizeTabs();
+}
+
+
+bool KTabWidget::isEmptyTabbarSpace( const TQPoint &p ) const
+{
+    TQPoint point( p );
+    TQSize size( tabBar()->sizeHint() );
+    if ( ( tabPosition()==Top && point.y()< size.height() ) || ( tabPosition()==Bottom && point.y()>(height()-size.height() ) ) ) {
+        TQWidget *rightcorner = cornerWidget( TopRight );
+        if ( rightcorner ) {
+            if ( point.x()>=width()-rightcorner->width() )
+                return false;
+        }
+        TQWidget *leftcorner = cornerWidget( TopLeft );
+        if ( leftcorner ) {
+            if ( point.x()<=leftcorner->width() )
+                return false;
+            point.setX( point.x()-size.height() );
+        }
+        if ( tabPosition()==Bottom )
+            point.setY( point.y()-( height()-size.height() ) );
+        TQTab *tab = tabBar()->selectTab( point);
+        if( !tab )
+            return true;
+    }
+    return false;
+}
+
+void KTabWidget::setHoverCloseButton( bool button )
+{
+    static_cast<KTabBar*>(tabBar())->setHoverCloseButton( button );
+}
+
+bool KTabWidget::hoverCloseButton() const
+{
+    return static_cast<KTabBar*>(tabBar())->hoverCloseButton();
+}
+
+void KTabWidget::setHoverCloseButtonDelayed( bool delayed )
+{
+    static_cast<KTabBar*>(tabBar())->setHoverCloseButtonDelayed( delayed );
+}
+
+bool KTabWidget::hoverCloseButtonDelayed() const
+{
+    return static_cast<KTabBar*>(tabBar())->hoverCloseButtonDelayed();
+}
+
+void KTabWidget::setAutomaticResizeTabs( bool enabled )
+{
+    if ( d->m_automaticResizeTabs==enabled )
+        return;
+
+    d->m_automaticResizeTabs = enabled;
+    if ( enabled ) {
+        d->m_tabNames.clear();
+        for( int i = 0; i < count(); ++i )
+            d->m_tabNames.append( tabBar()->tabAt( i )->text() );
+    }
+    else
+        for( int i = 0; i < count(); ++i )
+            tabBar()->tabAt( i )->setText( d->m_tabNames[ i ] );
+    resizeTabs();
+}
+
+bool KTabWidget::automaticResizeTabs() const
+{
+    return d->m_automaticResizeTabs;
+}
+
+void KTabWidget::closeRequest( int index )
+{
+    emit( closeRequest( page( index ) ) );
+}
+
+void KTabWidget::resizeEvent( TQResizeEvent *e )
+{
+    TQTabWidget::resizeEvent( e );
+    resizeTabs();
+}
+
+#include "ktabwidget.moc"