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

1 files changed, 616 insertions, 0 deletions

diff --git a/lib/compatibility/tdemdi/qextmdi/tdemdichildview.h b/lib/compatibility/tdemdi/qextmdi/tdemdichildview.h
new file mode 100644
index 00000000..d459f663
--- /dev/null
+++ b/lib/compatibility/tdemdi/qextmdi/tdemdichildview.h
@@ -0,0 +1,616 @@
+//----------------------------------------------------------------------------
+//    filename             : tdemdichildview.h
+//----------------------------------------------------------------------------
+//    Project              : KDE MDI extension
+//
+//    begin                : 07/1999       by Szymon Stefanek as part of kvirc
+//                                         (an IRC application)
+//    changes              : 09/1999       by Falk Brettschneider to create an
+//                           - 06/2000     stand-alone TQt extension set of
+//                                         classes and a TQt-based library
+//                           2000-2003     maintained by the KDevelop project
+//    patches              : 02/2000       by Massimo Morin (mmorin@schedsys.com)
+//                           */2000        by Lars Beikirch (Lars.Beikirch@gmx.net)
+//                           02/2001       by Eva Brucherseifer (eva@rt.e-technik.tu-darmstadt.de)
+//                           01/2003       by Jens Zurheide (jens.zurheide@gmx.de)
+//
+//    copyright            : (C) 1999-2003 by Falk Brettschneider
+//                                         and
+//                                         Szymon Stefanek (stefanek@tin.it)
+//    email                :  falkbr@tdevelop.org (Falk Brettschneider)
+//----------------------------------------------------------------------------
+//
+//----------------------------------------------------------------------------
+//
+//    This program 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.
+//
+//----------------------------------------------------------------------------
+#ifndef _KMDI_CHILD_VIEW_H_
+#define _KMDI_CHILD_VIEW_H_
+
+#include <tqwidget.h>
+#include <tqpixmap.h>
+#include <tqrect.h>
+#include <tqapplication.h>
+#include <tqdatetime.h>
+
+#include "tdemdichildfrm.h"
+
+class KMdiChildViewPrivate;
+
+/**
+  * @short Base class for all your special view windows.
+  *
+  * Base class for all MDI view widgets. KMdi stores additional information in this class
+  * to handle the attach/detach mechanism and such things.
+  *
+  * All such windows 'lives' attached to a KMdiChildFrm widget
+  * managed by KMdiChildArea, or detached (managed by the window manager.)
+  * So remember that the KMdiChildView::parent pointer may change, and may be 0L, too.
+  *
+  * There are 2 possibilities for you to put your widgets under MDI control:
+  *
+  * Either you inherit all the views from KMdiChildView:
+  *   \code
+  *   class MyMdiWidget : public KMdiChildView
+  *   { .... };
+  *   ...
+  *   MyMdiWidget w;
+  *   mainframe->addWindow(w, flags);
+  *   \endcode
+  *
+  * or you wrap them by a KMdiChildView somehow like this:
+  *
+  * \code
+  * void DocViewMan::addKMdiFrame(TQWidget* pNewView, bool bShow, const TQPixmap& icon)
+  * {
+  *   // cover it by a KMdi childview and add that MDI system
+  *   KMdiChildView* pMDICover = new KMdiChildView( pNewView->caption());
+  *   pMDICover->setIcon(icon);
+  *   m_MDICoverList.append( pMDICover);
+  *   TQBoxLayout* pLayout = new TQHBoxLayout( pMDICover, 0, -1, "layout");
+  *   pNewView->reparent( pMDICover, TQPoint(0,0));
+  *   pLayout->addWidget( pNewView);
+  *   pMDICover->setName( pNewView->name());
+  *   // captions
+  *   TQString shortName = pNewView->caption();
+  *   int length = shortName.length();
+  *   shortName = shortName.right(length - (shortName.findRev('/') +1));
+  *   pMDICover->setTabCaption( shortName);
+  *   pMDICover->setCaption(pNewView->caption());
+  *
+  *   // fake a viewActivated to update the currentEditView/currentBrowserView pointers _before_ adding to MDI control
+  *   slot_viewActivated( pMDICover);
+  *
+  *   // take it under MDI mainframe control (note: this triggers also a setFocus())
+  *   int flags;
+  *   if (bShow) {
+  *     flags = KMdi::StandardAdd;
+  *   }
+  *   else {
+  *     flags = KMdi::Hide;
+  *   }
+  *   // set the accelerators for Toplevel MDI mode (each toplevel window needs its own accels
+  *   connect( m_pParent, TQT_SIGNAL(childViewIsDetachedNow(TQWidget*)), this, TQT_SLOT(initKeyAccel(TQWidget*)) );
+  *
+  *   m_pParent->addWindow( pMDICover, flags);
+  *   // correct the default settings of KMdi ('cause we haven't a tab order for subwidget focuses)
+  *   pMDICover->setFirstFocusableChildWidget(0L);
+  *   pMDICover->setLastFocusableChildWidget(0L);
+  * }
+  * \endcode
+  *
+  */
+
+class KMDI_EXPORT KMdiChildView : public TQWidget
+{
+	friend class KMdiMainFrm;
+	friend class KMdiChildFrm;
+	Q_OBJECT
+  
+
+	// attributes
+protected:
+	/**
+	 * See KMdiChildView::caption
+	 */
+	TQString m_szCaption;
+	
+	/**
+	 * See KMdiChildView::tabCaption
+	 */
+	TQString m_sTabCaption;
+	
+	/**
+	 * See KMdiChildView::focusedChildWidget
+	 */
+	TQWidget* m_focusedChildWidget;
+	
+	/**
+	 * See KMdiChildView::setFirstFocusableChildWidget
+	 */
+	TQWidget* m_firstFocusableChildWidget;
+	
+	/**
+	 * See KMdiChildView::setLastFocusableChildWidget
+	 */
+	TQWidget* m_lastFocusableChildWidget;
+	
+	/**
+	 * Every child view window has an temporary ID in the Window menu of the main frame.
+	 */
+	int m_windowMenuID;
+	
+	/**
+	 * Holds a temporary information about if the MDI view state has changed but is not processed yet (pending state).
+	 * For example it could be that a 'maximize' is pending, if this variable is true.
+	 */
+	bool m_stateChanged;
+
+	/**
+	 * Holds the time when this view was activated (not only displayed) for the last time.
+	 */
+	TQDateTime m_time;
+
+private:
+	/**
+	 * Internally used as indicator whether this KMdiChildView is treated as document view or as tool view.
+	 */
+	bool m_bToolView;
+	
+	/**
+	 * Internally used by KMdiMainFrm to store a temporary information that the method
+	 * activate() is unnecessary and that it can by escaped.
+	 * This saves from unnecessary calls when activate is called directly.
+	 */
+	bool m_bInterruptActivation;
+	
+	/**
+	 * Internally used to prevent cycles between KMdiMainFrm::activateView() and KMdiChildView::activate().
+	 */
+	bool m_bMainframesActivateViewIsPending;
+	
+	/**
+	 * Internally used to check if there is a focus in event pending
+	 */
+	bool m_bFocusInEventIsPending;
+
+	// methods
+public:
+	/**
+	 * Constructor
+	 */
+	KMdiChildView( const TQString& caption, TQWidget* parentWidget = 0L, const char* name = 0L, WFlags f = 0 );
+	
+	/**
+	 * Constructor 
+	 * sets "Unnamed" as default caption
+	 */
+	KMdiChildView( TQWidget* parentWidget = 0L, const char* name = 0L, WFlags f = 0 );
+	
+	/**
+	 * Destructor
+	 */
+	~KMdiChildView();
+	
+	/**
+	 * This method does the same as focusInEvent(). That's why it is a replacement for the setFocus() call. It makes
+	 * sense if you for instance want to focus (I mean raise and activate) this view although the real focus is
+	 * in another toplevel widget. focusInEvent() will never get called in that case and your setFocus() call for this
+	 * widget would fail without any effect.
+	 * Use this method with caution, it always raises the view and pushes the taskbar button. Also when the focus is
+	 * still on another MDI view in the same toplevel window where this is located!
+	 */
+	void activate();
+	
+	/**
+	 * Memorizes the first focusable child widget of this widget
+	 */
+	void setFirstFocusableChildWidget( TQWidget* );
+	
+	/**
+	 * Memorizes the last focusable child widget of this widget
+	 */
+	void setLastFocusableChildWidget( TQWidget* );
+	
+	/**
+	 * Returns the current focused child widget of this widget
+	 */
+	TQWidget* focusedChildWidget();
+	
+	/**
+	 * Returns true if the MDI view is a child window within the MDI mainframe widget
+	 * or false if the MDI view is in toplevel mode
+	 */
+	bool isAttached() const { return ( mdiParent() != 0L ); }
+	
+	/**
+	 * Returns the caption of the child window (different from the caption on the button in the taskbar)
+	 */
+	const TQString& caption() const { return m_szCaption; }
+	
+	/**
+	 * Returns the caption of the button on the taskbar
+	 */
+	const TQString& tabCaption() const { return m_sTabCaption; }
+	
+	/**
+	 * Sets the window caption string...
+	 * Calls updateButton on the taskbar button if it has been set.
+	 */
+	virtual void setCaption( const TQString& szCaption );
+	
+	/**
+	 * Sets the caption of the button referring to this window
+	 */
+	virtual void setTabCaption( const TQString& caption );
+	
+	/**
+	 * Sets the caption of both the window and the button on the taskbar
+	 */
+	virtual void setMDICaption( const TQString &caption );
+	
+	/**
+	 * Returns the KMdiChildFrm parent widget (or 0 if the window is not attached)
+	 */
+	KMdiChildFrm *mdiParent() const;
+	
+	/**
+	 * Tells if the window is minimized when attached to the Mdi manager,
+	 * or if it is VISIBLE when 'floating'.
+	 */
+	bool isMinimized() const;
+	
+	/**
+	 * Tells if the window is minimized when attached to the Mdi manager,
+	 * otherwise returns false.
+	 */
+	bool isMaximized() const;
+	
+	/**
+	 * Returns the geometry of this MDI child window as TQWidget::geometry() does.
+	 */
+	TQRect internalGeometry() const;
+	
+	/**
+	 * Sets the geometry of the client area of this MDI child window. The
+	 * top left position of the argument is the position of the top left point
+	 * of the client area in its parent coordinates and the arguments width
+	 * and height is the width and height of the client area. Please note: This
+	 * differs from the behavior of TQWidget::setGeometry()!
+	 */
+	void setInternalGeometry( const TQRect& newGeomety );
+	
+	/**
+	 * Returns the frame geometry of this window or of the parent if there is any...
+	 */
+	TQRect externalGeometry() const;
+	
+	/**
+	 * Sets the geometry of the frame of this MDI child window. The top left
+	 * position of the argument is the position of the top left point of the
+	 * frame in its parent coordinates and the arguments width and height is
+	 * the width and height of the widget frame. Please note: This differs
+	 * from the behavior of TQWidget::setGeometry()!
+	 */
+	void setExternalGeometry( const TQRect& newGeomety );
+	
+	/**
+	 * You should override this function in the derived class.
+	 */
+	virtual TQPixmap* myIconPtr();
+	
+	/**
+	 * Minimizes this window when it is attached to the Mdi manager.
+	 * Otherwise has no effect
+	 */
+	virtual void minimize( bool bAnimate );
+	
+	/**
+	 * Maximizes this window when it is attached to the Mdi manager.
+	 * Otherwise has no effect
+	 */
+	virtual void maximize( bool bAnimate );
+	
+	/**
+	 * Returns the geometry that will be restored by calling restore().
+	 */
+	TQRect restoreGeometry();
+	
+	/**
+	 * Sets the geometry that will be restored by calling restore().
+	 */
+	void setRestoreGeometry( const TQRect& newRestGeo );
+	
+	/**
+	 * Switches interposing in event loop of all current child widgets off.
+	 */
+	void removeEventFilterForAllChildren();
+	
+	/**
+	 * Internally used for setting an ID for the 'Window' menu entry
+	 */
+	void setWindowMenuID( int id );
+	
+	/**
+	 * Sets the minimum size of the widget to w by h pixels.
+	 * It extends it base clase method in a way that the minimum size of
+	 * its childframe (if there is one) will be set, additionally.
+	 */
+	virtual void setMinimumSize ( int minw, int minh );
+	
+	/**
+	 * Sets the maximum size of the widget to w by h pixels.
+	 * It extends it base clase method in a way that the maximum size of
+	 * its childframe (if there is one) will be set, additionally.
+	 */
+	virtual void setMaximumSize ( int maxw, int maxh );
+	
+	/**
+	 * Returns if this is added as MDI tool-view
+	 */
+	inline bool isToolView() const { return m_bToolView; }
+	
+	/**
+	 * Remember the current time
+	 */
+	inline void updateTimeStamp()
+	{
+		m_time.setDate( TQDate::currentDate() );
+		m_time.setTime( TQTime::currentTime() );
+	}
+	
+	/**
+	 * Recall a previously remembered time, i.e. the value of m_time
+	 */
+	inline const TQDateTime& getTimeStamp() const { return m_time; }
+
+public slots:
+	/**
+	* Attaches this window to the Mdi manager.
+	* It calls the KMdiMainFrm attachWindow function , so if you have a pointer
+	* to this KMdiMainFrm you'll be faster calling that function.
+	*/
+	virtual void attach();
+	
+	/**
+	 * Detaches this window from the Mdi manager.
+	 * It calls the KMdiMainFrm detachWindow function , so if you have a pointer
+	 * to this KMdiMainFrm you'll be faster calling that function.
+	 */
+	virtual void detach();
+	
+	/**
+	 * Mimimizes the MDI view. If attached, the covering childframe widget is minimized (only a mini widget
+	 * showing the caption bar and the system buttons will remain visible). If detached, it will use the
+	 * minimize of the underlying system ( TQWidget::showMinimized ).
+	 */
+	virtual void minimize();
+	
+	/**
+	 * Maximizes the MDI view. If attached, this widget will fill the whole MDI view area widget. The system buttons
+	 * move to the main menubar (if set by KMdiMainFrm::setMenuForSDIModeSysButtons ).
+	 * If detached, it will use the minimize of the underlying system ( TQWidget::showMaximized ).
+	 */
+	virtual void maximize();
+	
+	/**
+	 * Restores this window to its normal size. Also known as 'normalize'.
+	 */
+	virtual void restore();
+	
+	/**
+	 * Internally called, if KMdiMainFrm::attach is called.
+	 * Actually, only the caption of the covering childframe is set.
+	 */
+	virtual void youAreAttached( KMdiChildFrm *lpC );
+	
+	/**
+	 * Internally called, if KMdiMainFrm::detach is called.
+	 * Some things for going toplevel will be done here.
+	 */
+	virtual void youAreDetached();
+	
+	/**
+	 * Called if someone click on the "Window" menu item for this child frame window
+	 */
+	virtual void slot_clickedInWindowMenu();
+	
+	/**
+	 * Called if someone click on the "Dock/Undock..." menu item for this child frame window
+	 */
+	virtual void slot_clickedInDockMenu();
+	
+	/**
+	 * Calls TQWidget::show but also for it's parent widget if attached
+	 */
+	virtual void show();
+	
+	/**
+	 * Calls TQWidget::hide() or it's parent widget hide() if attached
+	 */
+	virtual void hide();
+	
+	/**
+	 * Calls TQWidget::raise() or it's parent widget raise() if attached
+	 */
+	virtual void raise();
+	
+	/**
+	 * Overridden from its base class method. Emits a signal KMdiChildView::isMinimizedNow , additionally.
+	 * Note that this method is not used by an external windows manager call on system minimizing.
+	 */
+	virtual void showMinimized();
+	
+	/**
+	 * Overridden from its base class method. Emits a signal KMdiChildView::isMaximizedNow , additionally.
+	 * Note that this method is not used by an external windows manager call on system maximizing.
+	 */
+	virtual void showMaximized();
+	
+	/**
+	 * Overridden from its base class method. Emits a signal KMdiChildView::isRestoredNow , additionally.
+	 * Note that this method is not used by an external windows manager call on system normalizing.
+	 */
+	virtual void showNormal();
+	
+
+protected:
+	/**
+	 * Ignores the event and calls KMdiMainFrm::childWindowCloseRequest instead. This is because the
+	 * mainframe has control over the views. Therefore the MDI view has to request the mainframe for a close.
+	 */
+	virtual void closeEvent( TQCloseEvent *e );
+	
+	/**
+	 * It only catches TQEvent::KeyPress events there. If a TQt::Key_Tab is pressed, the internal MDI focus
+	 * handling is called. That means if the last focusable child widget of this is called, it will jump to the
+	 * first focusable child widget of this.
+	 * See KMdiChildView::setFirstFocusableChildWidget and KMdiChildView::lastFirstFocusableChildWidget
+	 */
+	virtual bool eventFilter( TQObject *obj, TQEvent *e );
+	
+	/**
+	 * If attached, the childframe will be activated and the MDI taskbar button will be pressed. Additionally, the
+	 * memorized old focused child widget of this is focused again.
+	 * Sends the focusInEventOccurs signal before changing the focus and the
+	 * gotFocus signal after changing the focus.
+	 */
+	virtual void focusInEvent( TQFocusEvent *e );
+	
+	/**
+	 * Send the lostFocus signal
+	 */
+	virtual void focusOutEvent( TQFocusEvent *e );
+	
+	/**
+	 * Internally used for the minimize/maximize/restore mechanism when in attach mode.
+	 */
+	virtual void resizeEvent( TQResizeEvent *e );
+
+	void trackIconAndCaptionChanges( TQWidget *view );
+
+protected slots:
+	void slot_childDestroyed();
+
+signals:
+	/**
+	 * Internally used by KMdiChildView::attach to send it as command to the mainframe.
+	 */
+	void attachWindow( KMdiChildView*, bool );
+	
+	/**
+	 * Internally used by KMdiChildView::detach to send it as command to the mainframe.
+	 */
+	void detachWindow( KMdiChildView*, bool );
+	
+	/**
+	 * Is sent when this MDI child view is going to receive focus (before actually changing the focus).
+	 * Internally used to send information to the mainframe that this MDI child view is focused.
+	 * See KMdiChildView::focusInEvent
+	 */
+	void focusInEventOccurs( KMdiChildView* );
+	
+	/**
+	 * Is sent when this MDI child has received the focus (after actually changing the focus).
+	 * See KMdiChildView::focusInEvent
+	 */
+	void gotFocus( KMdiChildView* );
+	
+	/**
+	 * Is sent when this MDI child was set to the activate view of all MDI views (after actually changing the focus).
+	 * See KMdiChildView::activate
+	 */
+	void activated( KMdiChildView* );
+	
+	/** Is sent when this MDI child view has lost the focus (after actually changing the focus).
+	 *  See KMdiChildView::focusOutEvent
+	 */
+	void lostFocus( KMdiChildView* );
+	
+	/** Is sent when this MDI child view was deactivated (after actually changing the focus).
+	 *  See KMdiChildView::focusOutEvent
+	 */
+	void deactivated( KMdiChildView* );
+	
+	/**
+	 * Internally used to send information to the mainframe that this MDI child view wants to be closed.
+	 * See KMdiChildView::closeEvent and KMdiMainFrm::closeWindow
+	 */
+	void childWindowCloseRequest( KMdiChildView* );
+	
+	/**
+	 * Emitted when the window caption is changed via KMdiChildView::setCaption or KMdiChildView::setMDICaption
+	 */
+	void windowCaptionChanged( const TQString& );
+	
+	/**
+	 * Emitted  when the window caption is changed via KMdiChildView::setTabCaption or KMdiChildView::setMDICaption
+	 */
+	void tabCaptionChanged( const TQString& );
+	
+	/**
+	 * Internally used to send information to the mainframe that this MDI view is maximized now.
+	 * Usually, the mainframe switches system buttons.
+	 */
+	void mdiParentNowMaximized( bool );
+	
+	/**
+	 * Is automatically emitted when slot_clickedInWindowMenu is called
+	 */
+	void clickedInWindowMenu( int );
+	
+	/**
+	 * Is automatically emitted when slot_clickedInDockMenu is called
+	 */
+	void clickedInDockMenu( int );
+	
+	/**
+	 * Signals this has been maximized
+	 */
+	void isMaximizedNow();
+	
+	/**
+	 * Signals this has been minimized
+	 */
+	void isMinimizedNow();
+	
+	/**
+	 * Signals this has been restored (normalized)
+	 */
+	void isRestoredNow();
+	
+	/**
+	 * Signals this has been attached
+	 */
+	void isAttachedNow();
+	
+	/**
+	 * Signals this has been detached
+	 */
+	void isDetachedNow();
+
+	void iconUpdated( TQWidget*, TQPixmap );
+	void captionUpdated( TQWidget*, const TQString& );
+
+
+private:
+	KMdiChildViewPrivate *d;
+	TQWidget *m_trackChanges;
+};
+
+inline KMdiChildFrm *KMdiChildView::mdiParent() const
+{
+	TQWidget * pw = parentWidget();
+	if ( pw != 0L )
+		if ( pw->inherits( "KMdiChildFrm" ) )
+			return ( KMdiChildFrm * ) pw;
+	return 0L;
+}
+
+#endif //_KMDICHILDVIEW_H_
+
+// kate: space-indent off; replace-tabs off; indent-mode csands; tab-width 4;