You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdegraphics/kpovmodeler/pmdockwidget.cpp

2552 lines
76 KiB

/* This file is part of the KDE libraries
Copyright (C) 2000 Max Judin <novaprint@mtu-net.ru>
Modified 2002 Andreas Zehender <zehender@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 "pmdockwidget.h"
#include "pmdockwidget_private.h"
#include <tqapplication.h>
#include <tqlayout.h>
#include <tqpainter.h>
#include <tqobjectlist.h>
#include <tqstrlist.h>
#include <tqcursor.h>
#include <tqwidgetlist.h>
#include <tqtabwidget.h>
#include <tqstyle.h>
#ifndef NO_KDE2
#include <kconfig.h>
#include <kglobal.h>
#include <ktoolbar.h>
#include <kpopupmenu.h>
#include <twin.h>
#include <kdebug.h>
#ifdef TQ_WS_X11
#include <X11/X.h>
#include <X11/Xlib.h>
#endif
#else
#include <tqapplication.h>
#include <tqtoolbar.h>
#include <tqpopupmenu.h>
#endif
#include "pmdebug.h"
#include <kparts/event.h>
#include <kparts/part.h>
#include <kaccel.h>
#include <kparts/plugin.h>
#include <kstatusbar.h>
#include <kinstance.h>
#include <khelpmenu.h>
#include <kstandarddirs.h>
#include <tqapplication.h>
#include <kdebug.h>
#include <kxmlguifactory.h>
#include <assert.h>
#define DOCK_CONFIG_VERSION "0.0.5"
static const char* const close_xpm[]={
"7 7 2 1",
"# c black",
". c None",
".......",
"##..##.",
".####..",
"..##...",
".####..",
"##..##.",
"......."};
static const char* const todesktop_xpm[]={
"5 5 2 1",
"# c black",
". c None",
"####.",
"##...",
"#.#..",
"#..#.",
"....#"};
static const char* const dockback_xpm[]={
"5 5 2 1",
"# c black",
". c None",
"#....",
".#..#",
"..#.#",
"...##",
".####"};
static const char* const not_close_xpm[]={
"5 5 2 1",
"# c black",
". c None",
"#####",
"#...#",
"#...#",
"#...#",
"#####"};
class PMDockMainWindowPrivate
{
public:
PMDockMainWindowPrivate()
{
m_activePart = 0;
m_bShellGUIActivated = false;
m_helpMenu = 0;
}
~PMDockMainWindowPrivate()
{
}
TQGuardedPtr<Part> m_activePart;
bool m_bShellGUIActivated;
KHelpMenu *m_helpMenu;
};
/**
* A special kind of KMainWindow that is able to have dockwidget child widgets.
*
* The main widget should be a dockwidget where other dockwidgets can be docked to
* the left, right, top, bottom or to the middle.
* Furthermore, the PMDockMainWindow has got the KDocManager and some data about the dock states.
*
* @author Max Judin.
*/
PMDockMainWindow::PMDockMainWindow( TQWidget* parent, const char *name, WFlags f)
:KMainWindow( parent, name, f )
{
TQString new_name = TQString(name) + TQString("_DockManager");
dockManager = new PMDockManager( this, new_name.latin1() );
mainDockWidget = 0L;
d = new PMDockMainWindowPrivate( );
PartBase::setPartObject( TQT_TQOBJECT(this) );
}
PMDockMainWindow::~PMDockMainWindow()
{
delete dockManager;
delete d;
}
// kparts/dockmainwindow stuff
void PMDockMainWindow::createGUI( Part * part )
{
kdDebug(1000) << TQString("DockMainWindow::createGUI for %1").arg(part?part->name():"0L") << endl;
KXMLGUIFactory *factory = guiFactory();
setUpdatesEnabled( false );
TQPtrList<Plugin> plugins;
if ( d->m_activePart )
{
kdDebug(1000) << TQString("deactivating GUI for %1").arg(d->m_activePart->name()) << endl;
GUIActivateEvent ev( false );
TQApplication::sendEvent( d->m_activePart, &ev );
factory->removeClient( d->m_activePart );
disconnect( d->m_activePart, TQT_SIGNAL( setWindowCaption( const TQString & ) ),
this, TQT_SLOT( setCaption( const TQString & ) ) );
disconnect( d->m_activePart, TQT_SIGNAL( setStatusBarText( const TQString & ) ),
this, TQT_SLOT( slotSetStatusBarText( const TQString & ) ) );
}
if( !d->m_bShellGUIActivated )
{
loadPlugins( TQT_TQOBJECT(this), this, KGlobal::instance() );
createShellGUI();
d->m_bShellGUIActivated = true;
}
if ( part )
{
// do this before sending the activate event
connect( part, TQT_SIGNAL( setWindowCaption( const TQString & ) ),
this, TQT_SLOT( setCaption( const TQString & ) ) );
connect( part, TQT_SIGNAL( setStatusBarText( const TQString & ) ),
this, TQT_SLOT( slotSetStatusBarText( const TQString & ) ) );
factory->addClient( part );
GUIActivateEvent ev( true );
TQApplication::sendEvent( part, &ev );
}
setUpdatesEnabled( true );
d->m_activePart = part;
}
void PMDockMainWindow::slotSetStatusBarText( const TQString & text )
{
statusBar()->message( text );
}
void PMDockMainWindow::createShellGUI( bool create )
{
bool bAccelAutoUpdate = accel()->setAutoUpdate( false );
assert( d->m_bShellGUIActivated != create );
d->m_bShellGUIActivated = create;
if ( create )
{
if ( isHelpMenuEnabled() && !d->m_helpMenu )
d->m_helpMenu = new KHelpMenu( this, instance()->aboutData(), true, actionCollection() );
TQString f = xmlFile();
setXMLFile( locate( "config", "ui/ui_standards.rc", instance() ) );
if ( !f.isEmpty() )
setXMLFile( f, true );
else
{
TQString auto_file( instance()->instanceName() + "ui.rc" );
setXMLFile( auto_file, true );
}
GUIActivateEvent ev( true );
TQApplication::sendEvent( this, &ev );
guiFactory()->addClient( this );
}
else
{
GUIActivateEvent ev( false );
TQApplication::sendEvent( this, &ev );
guiFactory()->removeClient( this );
}
accel()->setAutoUpdate( bAccelAutoUpdate );
}
// end kparts/dockmainwindow
void PMDockMainWindow::setMainDockWidget( PMDockWidget* mdw )
{
if ( mainDockWidget == mdw ) return;
mainDockWidget = mdw;
}
void PMDockMainWindow::setView( TQWidget *view )
{
if ( view->isA("PMDockWidget") ){
if ( TQT_BASE_OBJECT(view->parent()) != TQT_BASE_OBJECT(this) ) ((PMDockWidget*)view)->applyToWidget( this );
}
#ifndef NO_KDE2
KMainWindow::setCentralWidget(view);
#else
TQMainWindow::setCentralWidget(view);
#endif
}
PMDockWidget* PMDockMainWindow::createDockWidget( const TQString& name, const TQPixmap &pixmap, TQWidget* parent, const TQString& strCaption, const TQString& strTabPageLabel)
{
return new PMDockWidget( dockManager, name.latin1(), pixmap, parent, strCaption, strTabPageLabel );
}
void PMDockMainWindow::makeDockVisible( PMDockWidget* dock )
{
if ( dock != 0L)
dock->makeDockVisible();
}
void PMDockMainWindow::makeDockInvisible( PMDockWidget* dock )
{
if ( dock != 0L)
dock->undock();
}
void PMDockMainWindow::makeWidgetDockVisible( TQWidget* widget )
{
makeDockVisible( dockManager->findWidgetParentDock(widget) );
}
void PMDockMainWindow::writeDockConfig(TQDomElement &base)
{
dockManager->writeConfig(base);
}
void PMDockMainWindow::readDockConfig(TQDomElement &base)
{
dockManager->readConfig(base);
}
#ifndef NO_KDE2
void PMDockMainWindow::writeDockConfig( KConfig* c, TQString group )
{
dockManager->writeConfig( c, group );
}
void PMDockMainWindow::readDockConfig( KConfig* c, TQString group )
{
dockManager->readConfig( c, group );
}
#endif
void PMDockMainWindow::slotDockWidgetUndocked()
{
TQObject* pSender = (TQObject*) sender();
if (!pSender->inherits("PMDockWidget")) return;
PMDockWidget* pDW = (PMDockWidget*) pSender;
emit dockWidgetHasUndocked( pDW);
}
/*************************************************************************/
PMDockWidgetAbstractHeaderDrag::PMDockWidgetAbstractHeaderDrag( PMDockWidgetAbstractHeader* parent, PMDockWidget* dock, const char* name )
:TQFrame( parent, name )
{
dw = dock;
installEventFilter( dock->dockManager() );
}
/*************************************************************************/
PMDockWidgetHeaderDrag::PMDockWidgetHeaderDrag( PMDockWidgetAbstractHeader* parent, PMDockWidget* dock, const char* name )
:PMDockWidgetAbstractHeaderDrag( parent, dock, name )
{
}
void PMDockWidgetHeaderDrag::paintEvent( TQPaintEvent* )
{
TQPainter paint;
paint.begin( this );
style().tqdrawPrimitive (TQStyle::PE_DockWindowHandle, &paint, TQRect(0,0,width(), height()), colorGroup());
paint.end();
}
/*************************************************************************/
PMDockWidgetAbstractHeader::PMDockWidgetAbstractHeader( PMDockWidget* parent, const char* name )
:TQFrame( parent, name )
{
}
/*************************************************************************/
PMDockWidgetHeader::PMDockWidgetHeader( PMDockWidget* parent, const char* name )
:PMDockWidgetAbstractHeader( parent, name )
{
layout = new TQHBoxLayout( this );
layout->setResizeMode( TQLayout::Minimum );
drag = new PMDockWidgetHeaderDrag( this, parent );
closeButton = new PMDockButton_Private( this, "DockCloseButton" );
closeButton->setPixmap( const_cast< const char** >(close_xpm) );
int buttonWidth = 9, buttonHeight = 9;
closeButton->setFixedSize(buttonWidth,buttonHeight);
connect( closeButton, TQT_SIGNAL(clicked()), parent, TQT_SIGNAL(headerCloseButtonClicked()));
// MODIFICATION (zehender)
// The shell will delete the widget
// undock is unnecessary
// connect( closeButton, TQT_SIGNAL(clicked()), parent, TQT_SLOT(undock()));
stayButton = new PMDockButton_Private( this, "DockStayButton" );
stayButton->setToggleButton( true );
stayButton->setPixmap( const_cast< const char** >(not_close_xpm) );
stayButton->setFixedSize(buttonWidth,buttonHeight);
connect( stayButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotStayClicked()));
stayButton->hide( );
dockbackButton = new PMDockButton_Private( this, "DockbackButton" );
dockbackButton->setPixmap( const_cast< const char** >(dockback_xpm));
dockbackButton->setFixedSize(buttonWidth,buttonHeight);
connect( dockbackButton, TQT_SIGNAL(clicked()), parent, TQT_SIGNAL(headerDockbackButtonClicked()));
connect( dockbackButton, TQT_SIGNAL(clicked()), parent, TQT_SLOT(dockBack()));
// MODIFICATION (zehender)
// Add a button to undock the widget and dock it as top level
// widget to the desktop
toDesktopButton = new PMDockButton_Private( this, "ToDesktopButton" );
toDesktopButton->setPixmap( const_cast< const char** >(todesktop_xpm));
toDesktopButton->setFixedSize(buttonWidth,buttonHeight);
connect( toDesktopButton, TQT_SIGNAL(clicked()), parent, TQT_SLOT(toDesktop()));
layout->addWidget( drag );
layout->addWidget( dockbackButton );
layout->addWidget( toDesktopButton );
layout->addWidget( stayButton );
layout->addWidget( closeButton );
layout->activate();
drag->setFixedHeight( layout->minimumSize().height() );
}
void PMDockWidgetHeader::setTopLevel( bool isTopLevel )
{
if ( isTopLevel ){
PMDockWidget* par = (PMDockWidget*)parent();
if( par) {
if( par->isDockBackPossible())
dockbackButton->show();
else
dockbackButton->hide();
}
stayButton->hide();
closeButton->hide();
toDesktopButton->hide();
drag->setEnabled( true );
} else {
dockbackButton->hide();
stayButton->hide();
closeButton->show();
toDesktopButton->show();
}
layout->activate();
updateGeometry();
}
void PMDockWidgetHeader::setDragPanel( PMDockWidgetHeaderDrag* nd )
{
if ( !nd ) return;
delete layout;
layout = new TQHBoxLayout( this );
layout->setResizeMode( TQLayout::Minimum );
delete drag;
drag = nd;
layout->addWidget( drag );
layout->addWidget( dockbackButton );
layout->addWidget( toDesktopButton );
layout->addWidget( stayButton );
layout->addWidget( closeButton );
layout->activate();
drag->setFixedHeight( layout->minimumSize().height() );
}
void PMDockWidgetHeader::slotStayClicked()
{
setDragEnabled(!stayButton->isOn());
}
bool PMDockWidgetHeader::dragEnabled() const
{
return drag->isEnabled();
}
void PMDockWidgetHeader::setDragEnabled(bool b)
{
stayButton->setOn(!b);
closeButton->setEnabled(b);
drag->setEnabled(b);
}
#ifndef NO_KDE2
void PMDockWidgetHeader::saveConfig( KConfig* c )
{
c->writeEntry( TQString("%1%2").arg(parent()->name()).arg(":stayButton"), stayButton->isOn() );
}
void PMDockWidgetHeader::loadConfig( KConfig* c )
{
setDragEnabled( !c->readBoolEntry( TQString("%1%2").arg(parent()->name()).arg(":stayButton"), false ) );
}
#endif
/*************************************************************************/
PMDockWidget::PMDockWidget( PMDockManager* dockManager, const char* name, const TQPixmap &pixmap, TQWidget* parent, const TQString& strCaption, const TQString& strTabPageLabel, WFlags f)
: TQWidget( parent, name, f )
,formerBrotherDockWidget(0L)
,currentDockPos(DockNone)
,formerDockPos(DockNone)
,pix(new TQPixmap(pixmap))
,prevSideDockPosBeforeDrag(DockNone)
{
d = new PMDockWidgetPrivate(); // create private data
d->_parent = parent;
layout = new TQVBoxLayout( this );
layout->setResizeMode( TQLayout::Minimum );
manager = dockManager;
manager->childDock->append( TQT_TQOBJECT(this) );
installEventFilter( manager );
header = 0L;
setHeader( new PMDockWidgetHeader( this, "AutoCreatedDockHeader" ) );
if( strCaption == 0L)
setCaption( name );
else
setCaption( strCaption);
if( strTabPageLabel == " ")
setTabPageLabel( caption());
else
setTabPageLabel( strTabPageLabel);
eDocking = DockFullDocking;
sDocking = DockFullSite;
isGroup = false;
isTabGroup = false;
setIcon( pixmap);
widget = 0L;
TQObject::connect(this, TQT_SIGNAL(hasUndocked()), manager->main, TQT_SLOT(slotDockWidgetUndocked()) );
applyToWidget( parent, TQPoint(0,0) );
}
void PMDockWidget::slotSetCaption( const TQString& str )
{
setTabPageLabel( str );
setCaption( str );
}
PMDockWidget::~PMDockWidget()
{
if ( !manager->undockProcess ){
d->blockHasUndockedSignal = true;
undock();
d->blockHasUndockedSignal = false;
}
emit iMBeingClosed();
manager->childDock->remove( TQT_TQOBJECT(this) );
delete pix;
delete d; // destroy private data
}
void PMDockWidget::setHeader( PMDockWidgetAbstractHeader* h )
{
if ( !h ) return;
if ( header ){
delete header;
delete layout;
header = h;
layout = new TQVBoxLayout( this );
layout->setResizeMode( TQLayout::Minimum );
layout->addWidget( header );
setWidget( widget );
} else {
header = h;
layout->addWidget( header );
}
}
void PMDockWidget::setEnableDocking( int pos )
{
eDocking = pos;
updateHeader();
}
void PMDockWidget::updateHeader()
{
if ( parent() ){
if ( (TQT_BASE_OBJECT(parent()) == TQT_BASE_OBJECT(manager->main)) || isGroup || (eDocking == PMDockWidget::DockNone) ){
header->hide();
} else {
header->setTopLevel( false );
header->show();
}
} else {
header->setTopLevel( true );
header->show();
}
}
void PMDockWidget::applyToWidget( TQWidget* s, const TQPoint& p )
{
if ( TQT_BASE_OBJECT(parent()) != TQT_BASE_OBJECT(s) )
{
hide();
reparent(s, 0, TQPoint(0,0), false);
}
if ( s && s->inherits("PMDockMainWindow") ){
((PMDockMainWindow*)s)->setView( this );
}
if ( s == manager->main ){
setGeometry( TQRect(TQPoint(0,0), manager->main->geometry().size()) );
}
if ( !s )
{
move(p);
#ifndef NO_KDE2
#ifdef TQ_WS_X11
if (d->transient && d->_parent)
XSetTransientForHint( qt_xdisplay(), winId(), d->_parent->winId() );
KWin::setType( winId(), d->windowType );
#endif
#endif
}
updateHeader();
setIcon(*pix);
}
void PMDockWidget::show()
{
if ( parent() || manager->main->isVisible() )
if ( !parent() ){
emit manager->setDockDefaultPos( this );
emit setDockDefaultPos();
if ( parent() ){
makeDockVisible();
} else {
TQWidget::show();
}
} else {
TQWidget::show();
}
}
#ifndef NO_KDE2
void PMDockWidget::setDockWindowType (NET::WindowType windowType)
{
d->windowType = windowType;
applyToWidget( parentWidget(), TQPoint(0,0) );
}
#endif
void PMDockWidget::setDockWindowTransient (TQWidget *parent, bool transientEnabled)
{
d->_parent = parent;
d->transient = transientEnabled;
applyToWidget( parentWidget(), TQPoint(0,0) );
}
bool PMDockWidget::event( TQEvent* pevent )
{
switch ( pevent->type() )
{
#undef FocusIn
case TQEvent::FocusIn:
if (widget && !d->pendingFocusInEvent) {
d->pendingFocusInEvent = true;
widget->setFocus();
}
d->pendingFocusInEvent = false;
break;
case TQEvent::ChildRemoved:
if ( widget == ((TQChildEvent*)pevent)->child() ) widget = 0L;
break;
case TQEvent::Show:
if ( widget ) widget->show();
emit manager->change();
break;
case TQEvent::Hide:
if ( widget ) widget->hide();
emit manager->change();
break;
case TQEvent::CaptionChange:
if ( parentWidget() ){
if ( parent()->inherits("PMDockSplitter") ){
((PMDockSplitter*)(parent()))->updateName();
}
if ( parentDockTabGroup() ){
setDockTabName( parentDockTabGroup() );
parentDockTabGroup()->setTabLabel( this, tabPageLabel() );
}
}
break;
case TQEvent::Close:
// MODIFICATION (zehender)
// Top level widget is closed
// emit same signal as if the widget is docked and closed with
// the header button
emit headerCloseButtonClicked( );
// emit iMBeingClosed();
break;
default:
break;
}
#undef KeyPress
bool processed = TQWidget::event( pevent );
if( pevent->type( ) == TQEvent::AccelOverride && !processed && !parent( ) ){
// MODIFICATION (zehender)
// floating widget, post event to main window
processed = tqApp->sendEvent( manager->dockMainWidget( ), pevent );
}
return processed;
}
PMDockWidget* PMDockWidget::manualDock( PMDockWidget* target, DockPosition dockPos, int spliPos, TQPoint pos, bool check, int tabIndex )
{
if (this == target)
return 0L; // docking to itself not possible
bool succes = true; // tested flag
// do not dock into a floating widget
if( target && !target->parent( ) )
target = 0;
// check allowed this dock submit this operations
if ( !(eDocking & (int)dockPos) ){
succes = false;
}
// check allowed target submit this operations
if ( target && !(target->dockSite( ) & (int)dockPos) ){
succes = false;
}
if ( parent() && !parent()->inherits("PMDockSplitter") && !parentDockTabGroup() ){
succes = false;
}
// if docking to a tab group, and position is not center
// dock to the parent of the tab group
if( target && ( dockPos != PMDockWidget::DockCenter )
&& ( dockPos != PMDockWidget::DockNone ) )
{
TQWidget* pdt = target->parentDockTabGroup( );
if( pdt )
return manualDock( ( PMDockWidget* ) ( pdt->parent( ) ),
dockPos, spliPos, pos, check, tabIndex );
}
if ( !succes ){
// try to make another manualDock
PMDockWidget* dock_result = 0L;
if ( target && !check ){
PMDockWidget::DockPosition another__dockPos = PMDockWidget::DockNone;
switch ( dockPos ){
case PMDockWidget::DockLeft : another__dockPos = PMDockWidget::DockRight ; break;
case PMDockWidget::DockRight : another__dockPos = PMDockWidget::DockLeft ; break;
case PMDockWidget::DockTop : another__dockPos = PMDockWidget::DockBottom; break;
case PMDockWidget::DockBottom: another__dockPos = PMDockWidget::DockTop ; break;
default: break;
}
dock_result = target->manualDock( this, another__dockPos, spliPos, pos, true, tabIndex );
}
return dock_result;
}
// end check block
d->blockHasUndockedSignal = true;
undock();
d->blockHasUndockedSignal = false;
if ( !target ){
move( pos );
show();
emit manager->change();
return this;
}
PMDockTabGroup* parentTab = target->parentDockTabGroup();
if ( parentTab ){
// add to existing TabGroup
applyToWidget( parentTab );
parentTab->insertTab( this, icon() ? *icon() : TQPixmap(),
tabPageLabel(), tabIndex );
setDockTabName( parentTab );
if( !toolTipStr.isEmpty())
parentTab->setTabToolTip( this, toolTipStr);
currentDockPos = PMDockWidget::DockCenter;
emit manager->change();
return (PMDockWidget*)parentTab->parent();
}
// MODIFICATION (Zehender):
// If DockPosition is DockLeft or DockRight, add the widget
// left or right of the target, so that a new vertical splitter
// (a splitter with horizontal widget layout :-) is created
// that spawns the full height of the main view
if( ( dockPos == PMDockWidget::DockLeft ) ||
( dockPos == PMDockWidget::DockRight ) )
{
PMDockWidget* newTarget = target;
bool found = false;
TQWidget* wtarget = target;
while( wtarget && !found )
{
if( wtarget->inherits( "PMDockWidget" ) )
{
PMDockWidget* dw = ( PMDockWidget* ) wtarget;
newTarget = dw;
TQWidget* pw = wtarget->parentWidget( );
if( pw )
{
if( pw->inherits( "PMDockSplitter" ) )
{
PMDockSplitter* ds = ( PMDockSplitter* ) pw;
if( ds->splitterOrientation( ) ==Qt::Vertical )
found = true;
}
}
}
wtarget = wtarget->parentWidget( );
}
if( newTarget != target )
return manualDock( newTarget, dockPos, spliPos, pos, check, tabIndex );
}
// END MODIFICATION
// create a new dockwidget that will contain the target and this
TQWidget* parentDock = target->parentWidget();
PMDockWidget* newDock = new PMDockWidget( manager, "tempName", TQPixmap(TQString("")), parentDock );
newDock->currentDockPos = target->currentDockPos;
if ( dockPos == PMDockWidget::DockCenter ){
newDock->isTabGroup = true;
} else {
newDock->isGroup = true;
}
newDock->eDocking = (target->eDocking & eDocking) & (~(int)PMDockWidget::DockCenter);
newDock->applyToWidget( parentDock );
if ( !parentDock ){
// dock to a toplevel dockwidget means newDock is toplevel now
newDock->move( target->frameGeometry().topLeft() );
newDock->resize( target->geometry().size() );
if ( target->isVisibleToTLW() ) newDock->show();
}
// redirect the dockback button to the new dockwidget
if( target->formerBrotherDockWidget != 0L) {
newDock->formerBrotherDockWidget = target->formerBrotherDockWidget;
if( formerBrotherDockWidget != 0L)
TQObject::connect( newDock->formerBrotherDockWidget, TQT_SIGNAL(iMBeingClosed()),
newDock, TQT_SLOT(loseFormerBrotherDockWidget()) );
target->loseFormerBrotherDockWidget();
}
newDock->formerDockPos = target->formerDockPos;
if ( dockPos == PMDockWidget::DockCenter )
{
PMDockTabGroup* tab = new PMDockTabGroup( newDock, "_dock_tab");
TQObject::connect(tab, TQT_SIGNAL(currentChanged(TQWidget*)), d, TQT_SLOT(slotFocusEmbeddedWidget(TQWidget*)));
newDock->setWidget( tab );
target->applyToWidget( tab );
applyToWidget( tab );
tab->insertTab( target, target->icon() ? *(target->icon()) : TQPixmap(),
target->tabPageLabel() );
if( !target->toolTipString().isEmpty())
tab->setTabToolTip( target, target->toolTipString());
tab->insertTab( this, icon() ? *icon() : TQPixmap(),
tabPageLabel(), tabIndex );
if( !toolTipString().isEmpty())
tab->setTabToolTip( this, toolTipString());
setDockTabName( tab );
tab->show();
currentDockPos = DockCenter;
target->formerDockPos = target->currentDockPos;
target->currentDockPos = DockCenter;
}
else {
// if to dock not to the center of the target dockwidget,
// dock to newDock
PMDockSplitter* panner = 0L;
if ( dockPos == PMDockWidget::DockTop || dockPos == PMDockWidget::DockBottom ) panner = new PMDockSplitter( newDock, "_dock_split_",Qt::Horizontal, spliPos, manager->splitterHighResolution() );
if ( dockPos == PMDockWidget::DockLeft || dockPos == PMDockWidget::DockRight ) panner = new PMDockSplitter( newDock, "_dock_split_",Qt::Vertical , spliPos, manager->splitterHighResolution() );
newDock->setWidget( panner );
panner->setOpaqueResize(manager->splitterOpaqueResize());
panner->setKeepSize(manager->splitterKeepSize());
panner->setFocusPolicy( TQ_NoFocus );
target->applyToWidget( panner );
applyToWidget( panner );
target->formerDockPos = target->currentDockPos;
if ( dockPos == PMDockWidget::DockRight) {
panner->activate( target, this );
currentDockPos = PMDockWidget::DockRight;
target->currentDockPos = PMDockWidget::DockLeft;
}
else if( dockPos == PMDockWidget::DockBottom) {
panner->activate( target, this );
currentDockPos = PMDockWidget::DockBottom;
target->currentDockPos = PMDockWidget::DockTop;
}
else if( dockPos == PMDockWidget::DockTop) {
panner->activate( this, target );
currentDockPos = PMDockWidget::DockTop;
target->currentDockPos = PMDockWidget::DockBottom;
}
else if( dockPos == PMDockWidget::DockLeft) {
panner->activate( this, target );
currentDockPos = PMDockWidget::DockLeft;
target->currentDockPos = PMDockWidget::DockRight;
}
target->show();
show();
panner->show();
}
if ( parentDock ){
if ( parentDock->inherits("PMDockSplitter") ){
PMDockSplitter* sp = (PMDockSplitter*)parentDock;
sp->deactivate();
if ( sp->getFirst() == target )
sp->activate( newDock, 0L );
else
sp->activate( 0L, newDock );
}
}
newDock->show();
emit target->docking( this, dockPos );
emit manager->replaceDock( target, newDock );
emit manager->change();
return newDock;
}
PMDockTabGroup* PMDockWidget::parentDockTabGroup() const
{
if ( !parent() ) return 0L;
TQWidget* candidate = parentWidget()->parentWidget();
if ( candidate && candidate->inherits("PMDockTabGroup") ) return (PMDockTabGroup*)candidate;
return 0L;
}
void PMDockWidget::toDesktop()
{
TQPoint p = mapToGlobal( TQPoint( -30, -30 ) );
if( p.x( ) < 0 )
p.setX( 0 );
if( p.y( ) < 0 )
p.setY( 0 );
manualDock( 0, DockDesktop, 50, p );
}
void PMDockWidget::undock()
{
TQWidget* parentW = parentWidget();
if ( !parentW ){
hide();
if (!d->blockHasUndockedSignal)
emit hasUndocked();
return;
}
formerDockPos = currentDockPos;
currentDockPos = PMDockWidget::DockDesktop;
manager->blockSignals(true);
manager->undockProcess = true;
bool isV = parentW->isVisibleToTLW();
PMDockTabGroup* parentTab = parentDockTabGroup();
if ( parentTab ){
d->index = parentTab->indexOf( this); // memorize the page position in the tab widget
parentTab->removePage( this );
formerBrotherDockWidget = (PMDockWidget*)parentTab->page(0);
TQObject::connect( formerBrotherDockWidget, TQT_SIGNAL(iMBeingClosed()),
this, TQT_SLOT(loseFormerBrotherDockWidget()) );
applyToWidget( 0L );
if ( parentTab->count() == 1 ){
// last subdock widget in the tab control
PMDockWidget* lastTab = (PMDockWidget*)parentTab->page(0);
parentTab->removePage( lastTab );
lastTab->applyToWidget( 0L );
lastTab->move( parentTab->mapToGlobal(parentTab->frameGeometry().topLeft()) );
// PMDockTabGroup always have a parent that is a PMDockWidget
PMDockWidget* parentOfTab = (PMDockWidget*)parentTab->parent();
delete parentTab; // PMDockTabGroup
TQWidget* parentOfDockWidget = parentOfTab->parentWidget();
if ( parentOfDockWidget == 0L ){
if ( isV ) lastTab->show();
} else {
if ( parentOfDockWidget->inherits("PMDockSplitter") ){
PMDockSplitter* split = (PMDockSplitter*)parentOfDockWidget;
lastTab->applyToWidget( split );
split->deactivate();
if ( split->getFirst() == parentOfTab ){
split->activate( lastTab );
if ( ((PMDockWidget*)split->parent())->splitterOrientation ==Qt::Vertical )
emit ((PMDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, PMDockWidget::DockLeft );
else
emit ((PMDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, PMDockWidget::DockTop );
} else {
split->activate( 0L, lastTab );
if ( ((PMDockWidget*)split->parent())->splitterOrientation ==Qt::Vertical )
emit ((PMDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, PMDockWidget::DockRight );
else
emit ((PMDockWidget*)split->getAnother(parentOfTab))->docking( parentOfTab, PMDockWidget::DockBottom );
}
split->show();
} else {
lastTab->applyToWidget( parentOfDockWidget );
}
lastTab->show();
}
manager->blockSignals(false);
emit manager->replaceDock( parentOfTab, lastTab );
lastTab->currentDockPos = parentOfTab->currentDockPos;
emit parentOfTab->iMBeingClosed();
manager->blockSignals(true);
delete parentOfTab;
} else {
setDockTabName( parentTab );
}
} else {
/*********************************************************************************************/
if ( parentW->inherits("PMDockSplitter") ){
PMDockSplitter* parentSplitterOfDockWidget = (PMDockSplitter*)parentW;
d->splitPosInPercent = parentSplitterOfDockWidget->separatorPos();
PMDockWidget* secondWidget = (PMDockWidget*)parentSplitterOfDockWidget->getAnother( this );
PMDockWidget* group = (PMDockWidget*)parentSplitterOfDockWidget->parentWidget();
formerBrotherDockWidget = secondWidget;
applyToWidget( 0L );
group->hide();
if( formerBrotherDockWidget != 0L)
TQObject::connect( formerBrotherDockWidget, TQT_SIGNAL(iMBeingClosed()),
this, TQT_SLOT(loseFormerBrotherDockWidget()) );
if ( !group->parentWidget() ){
secondWidget->applyToWidget( 0L, group->frameGeometry().topLeft() );
secondWidget->resize( group->width(), group->height() );
} else {
TQWidget* obj = group->parentWidget();
secondWidget->applyToWidget( obj );
if ( obj->inherits("PMDockSplitter") ){
PMDockSplitter* parentOfGroup = (PMDockSplitter*)obj;
parentOfGroup->deactivate();
if ( parentOfGroup->getFirst() == group )
parentOfGroup->activate( secondWidget );
else
parentOfGroup->activate( 0L, secondWidget );
}
}
secondWidget->currentDockPos = group->currentDockPos;
secondWidget->formerDockPos = group->formerDockPos;
delete parentSplitterOfDockWidget;
manager->blockSignals(false);
emit manager->replaceDock( group, secondWidget );
emit group->iMBeingClosed();
manager->blockSignals(true);
delete group;
if ( isV ) secondWidget->show();
} else {
applyToWidget( 0L );
}
/*********************************************************************************************/
}
manager->blockSignals(false);
if (!d->blockHasUndockedSignal)
emit manager->change();
manager->undockProcess = false;
if (!d->blockHasUndockedSignal)
emit hasUndocked();
}
void PMDockWidget::setWidget( TQWidget* mw )
{
if ( !mw ) return;
if ( TQT_BASE_OBJECT(mw->parent()) != TQT_BASE_OBJECT(this) ){
mw->reparent(this, 0, TQPoint(0,0), false);
}
widget = mw;
delete layout;
layout = new TQVBoxLayout( this );
layout->setResizeMode( TQLayout::Minimum );
layout->addWidget( header );
layout->addWidget( widget,1 );
}
void PMDockWidget::setDockTabName( PMDockTabGroup* tab )
{
TQString listOfName;
TQString listOfCaption;
for ( int i = 0; i < tab->count(); ++i ) {
TQWidget *w = tab->page( i );
listOfCaption.append( w->caption() ).append(",");
listOfName.append( w->name() ).append(",");
}
listOfCaption.remove( listOfCaption.length()-1, 1 );
listOfName.remove( listOfName.length()-1, 1 );
tab->parentWidget()->setName( listOfName.utf8() );
tab->parentWidget()->setCaption( listOfCaption );
tab->parentWidget()->repaint( false ); // PMDockWidget->repaint
if ( tab->parentWidget()->parent() )
if ( tab->parentWidget()->parent()->inherits("PMDockSplitter") )
((PMDockSplitter*)(tab->parentWidget()->parent()))->updateName();
}
bool PMDockWidget::mayBeHide() const
{
bool f = (TQT_BASE_OBJECT(parent()) != TQT_BASE_OBJECT(manager->main));
return ( !isGroup && !isTabGroup && f && isVisible() && ( eDocking != (int)PMDockWidget::DockNone ) );
}
bool PMDockWidget::mayBeShow() const
{
bool f = (TQT_BASE_OBJECT(parent()) != TQT_BASE_OBJECT(manager->main));
return ( !isGroup && !isTabGroup && f && !isVisible() );
}
void PMDockWidget::changeHideShowState()
{
if ( mayBeHide() ){
undock();
return;
}
if ( mayBeShow() ){
if ( manager->main->inherits("PMDockMainWindow") ){
((PMDockMainWindow*)manager->main)->makeDockVisible(this);
} else {
makeDockVisible();
}
}
}
void PMDockWidget::makeDockVisible()
{
if ( parentDockTabGroup() ){
parentDockTabGroup()->showPage( this );
}
if ( isVisible() ) return;
TQWidget* p = parentWidget();
while ( p ){
if ( !p->isVisible() )
p->show();
p = p->parentWidget();
}
if( parent() == 0L) // is undocked
dockBack();
show();
}
void PMDockWidget::loseFormerBrotherDockWidget()
{
if( formerBrotherDockWidget != 0L)
TQObject::disconnect( formerBrotherDockWidget, TQT_SIGNAL(iMBeingClosed()),
this, TQT_SLOT(loseFormerBrotherDockWidget()) );
formerBrotherDockWidget = 0L;
repaint();
}
void PMDockWidget::dockBack()
{
if( formerBrotherDockWidget) {
// search all children if it tries to dock back to a child
bool found = false;
TQObjectList* cl = queryList("PMDockWidget");
TQObjectListIt it( *cl );
TQObject * obj;
while ( !found && (obj=it.current()) != 0 ) {
++it;
TQWidget* widg = (TQWidget*)obj;
if( widg == formerBrotherDockWidget)
found = true;
}
delete cl;
if( !found) {
// can dock back to the former brother dockwidget
manualDock( formerBrotherDockWidget, formerDockPos, d->splitPosInPercent, TQPoint(0,0), false, d->index);
formerBrotherDockWidget = 0L;
makeDockVisible();
return;
}
}
// else dockback to the dockmainwindow (default behaviour)
manualDock( ((PMDockMainWindow*)manager->main)->getMainDockWidget(), formerDockPos, d->splitPosInPercent, TQPoint(0,0), false, d->index);
formerBrotherDockWidget = 0L;
if (parent())
makeDockVisible();
}
bool PMDockWidget::isDockBackPossible() const
{
if( (formerBrotherDockWidget == 0L) || !(formerBrotherDockWidget->dockSite() & formerDockPos))
return false;
else
return true;
}
/**************************************************************************************/
class PMDockManager::PMDockManagerPrivate
{
public:
/**
* This rectangle is used to highlight the current dockposition. It stores global screen coordinates.
*/
TQRect dragRect;
/**
* This rectangle is used to erase the previously highlighted dockposition. It stores global screen coordinates.
*/
TQRect oldDragRect;
/**
* This flag stores the information if dragging is ready to start. Used between mousePress and mouseMove event.
*/
bool readyToDrag;
/**
* This variable stores the offset of the mouse cursor to the upper left edge of the current drag widget.
*/
TQPoint dragOffset;
/**
* These flags store information about the splitter behaviour
*/
bool splitterOpaqueResize;
bool splitterKeepSize;
bool splitterHighResolution;
};
PMDockManager::PMDockManager( TQWidget* mainWindow , const char* name )
:TQObject( mainWindow, name )
,main(mainWindow)
,currentDragWidget(0L)
,currentMoveWidget(0L)
,childDockWidgetList(0L)
,autoCreateDock(0L)
,storeW(0)
,storeH(0)
,draging(false)
,undockProcess(false)
,dropCancel(true)
{
d = new PMDockManagerPrivate;
d->splitterOpaqueResize = false;
d->splitterKeepSize = false;
d->splitterHighResolution = false;
main->installEventFilter( this );
undockProcess = false;
menuData = new TQPtrList<MenuDockData>;
menuData->setAutoDelete( true );
menuData->setAutoDelete( true );
#ifndef NO_KDE2
menu = new KPopupMenu();
#else
menu = new TQPopupMenu();
#endif
connect( menu, TQT_SIGNAL(aboutToShow()), TQT_SLOT(slotMenuPopup()) );
connect( menu, TQT_SIGNAL(activated(int)), TQT_SLOT(slotMenuActivated(int)) );
childDock = new TQObjectList();
childDock->setAutoDelete( false );
}
PMDockManager::~PMDockManager()
{
delete menuData;
delete menu;
TQObjectListIt it( *childDock );
PMDockWidget * obj;
while ( (obj=(PMDockWidget*)it.current()) ) {
delete obj;
}
delete childDock;
delete d;
}
void PMDockManager::activate()
{
TQObjectListIt it( *childDock );
PMDockWidget * obj;
while ( (obj=(PMDockWidget*)it.current()) ) {
++it;
if ( obj->widget ) obj->widget->show();
if ( !obj->parentDockTabGroup() ){
obj->show();
}
}
if ( !main->inherits(TQDIALOG_OBJECT_NAME_STRING) ) main->show();
}
bool PMDockManager::eventFilter( TQObject *obj, TQEvent *event )
{
/* This doesn't seem to fullfill any sense, other than breaking
TQMainWindow's layout all over the place
The first child of the mainwindow is not necessarily a meaningful
content widget but in TQt3's TQMainWindow it can easily be a TQToolBar.
In short: TQMainWindow knows how to layout its children, no need to
mess that up.
>>>>>I need this in the PMDockArea at the moment (JoWenn)
if ( obj == main && event->type() == TQEvent::Resize && dynamic_cast<PMDockArea*>(main) && main->children() ){
#ifndef NO_KDE2
kdDebug()<<"PMDockManager::eventFilter(): main is a PMDockArea and there are children"<<endl;
#endif
TQWidget* fc = (TQWidget*)main->children()->getFirst();
if ( fc )
fc->setGeometry( TQRect(TQPoint(0,0), main->geometry().size()) );
}
*/
if ( obj->inherits("PMDockWidgetAbstractHeaderDrag") ){
PMDockWidget* pDockWdgAtCursor = 0L;
PMDockWidget* curdw = ((PMDockWidgetAbstractHeaderDrag*)obj)->dockWidget();
switch ( event->type() ){
case TQEvent::MouseButtonDblClick:
if (curdw->currentDockPos == PMDockWidget::DockDesktop) curdw->dockBack();
else curdw->toDesktop( );
break;
case TQEvent::MouseButtonPress:
if ( ((TQMouseEvent*)event)->button() == Qt::LeftButton ){
if ( curdw->eDocking != (int)PMDockWidget::DockNone ){
dropCancel = true;
curdw->setFocus();
tqApp->processOneEvent();
currentDragWidget = curdw;
currentMoveWidget = 0L;
childDockWidgetList = new TQWidgetList();
childDockWidgetList->append( curdw );
findChildDockWidget( curdw, *childDockWidgetList );
d->oldDragRect = TQRect();
d->dragRect = TQRect(curdw->geometry());
TQPoint p = curdw->mapToGlobal(TQPoint(0,0));
d->dragRect.moveTopLeft(p);
drawDragRectangle();
d->readyToDrag = true;
d->dragOffset = TQCursor::pos()-currentDragWidget->mapToGlobal(TQPoint(0,0));
}
}
break;
case TQEvent::MouseButtonRelease:
if ( ((TQMouseEvent*)event)->button() == Qt::LeftButton ){
if ( draging ){
if ( !dropCancel )
drop();
else
cancelDrop();
}
if (d->readyToDrag) {
d->readyToDrag = false;
d->oldDragRect = TQRect();
d->dragRect = TQRect(curdw->geometry());
TQPoint p = curdw->mapToGlobal(TQPoint(0,0));
d->dragRect.moveTopLeft(p);
drawDragRectangle();
currentDragWidget = 0L;
delete childDockWidgetList;
childDockWidgetList = 0L;
}
draging = false;
dropCancel = true;
}
break;
case TQEvent::MouseMove:
if ( draging ) {
pDockWdgAtCursor = findDockWidgetAt( TQCursor::pos() );
PMDockWidget* oldMoveWidget = currentMoveWidget;
if ( currentMoveWidget && pDockWdgAtCursor == currentMoveWidget ) { //move
dragMove( currentMoveWidget, currentMoveWidget->mapFromGlobal( TQCursor::pos() ) );
break;
} else {
if (dropCancel && curdw) {
d->dragRect = TQRect(curdw->geometry());
TQPoint p = curdw->mapToGlobal(TQPoint(0,0));
d->dragRect.moveTopLeft(p);
}else
d->dragRect = TQRect();
drawDragRectangle();
}
if ( !pDockWdgAtCursor && (curdw->eDocking & (int)PMDockWidget::DockDesktop) == 0 ){
// just moving at the desktop
currentMoveWidget = pDockWdgAtCursor;
curPos = PMDockWidget::DockDesktop;
} else {
if ( oldMoveWidget && pDockWdgAtCursor != currentMoveWidget ) { //leave
currentMoveWidget = pDockWdgAtCursor;
curPos = PMDockWidget::DockDesktop;
}
}
if ( oldMoveWidget != pDockWdgAtCursor && pDockWdgAtCursor ) { //enter pDockWdgAtCursor
currentMoveWidget = pDockWdgAtCursor;
curPos = PMDockWidget::DockDesktop;
}
} else {
if (d->readyToDrag) {
d->readyToDrag = false;
}
if ( (((TQMouseEvent*)event)->state() == Qt::LeftButton) &&
(curdw->eDocking != (int)PMDockWidget::DockNone) ) {
startDrag( curdw);
}
}
break;
default:
break;
}
}
return TQObject::eventFilter( obj, event );
}
PMDockWidget* PMDockManager::findDockWidgetAt( const TQPoint& pos )
{
dropCancel = true;
if (!currentDragWidget)
return 0L; // pointer access safety
if (currentDragWidget->eDocking == (int)PMDockWidget::DockNone ) return 0L;
TQWidget* p = TQApplication::widgetAt( pos );
if ( !p ) {
dropCancel = false;
return 0L;
}
#if defined(_OS_WIN32_) || defined(Q_OS_WIN32)
p = p->topLevelWidget();
#endif
TQWidget* w = 0L;
findChildDockWidget( w, p, p->mapFromGlobal(pos) );
if ( !w ){
if ( !p->inherits("PMDockWidget") ) {
return 0L;
}
w = p;
}
if ( qt_find_obj_child( TQT_TQOBJECT(w), "PMDockSplitter", "_dock_split_" ) ) return 0L;
if ( qt_find_obj_child( TQT_TQOBJECT(w), "PMDockTabGroup", "_dock_tab" ) ) return 0L;
if (!childDockWidgetList) return 0L;
if ( childDockWidgetList->find(w) != -1 ) return 0L;
if ( currentDragWidget->isGroup && ((PMDockWidget*)w)->parentDockTabGroup() ) return 0L;
PMDockWidget* www = (PMDockWidget*)w;
if ( www->dockSite( ) == (int)PMDockWidget::DockNone ) return 0L;
PMDockWidget::DockPosition curPos = PMDockWidget::DockDesktop;
TQPoint cpos = www->mapFromGlobal( pos );
int ww = www->widget->width() / 3;
int hh = www->widget->height() / 3;
if ( cpos.y() <= hh ){
curPos = PMDockWidget::DockTop;
} else
if ( cpos.y() >= 2*hh ){
curPos = PMDockWidget::DockBottom;
} else
if ( cpos.x() <= ww ){
curPos = PMDockWidget::DockLeft;
} else
if ( cpos.x() >= 2*ww ){
curPos = PMDockWidget::DockRight;
} else
curPos = PMDockWidget::DockCenter;
if ( !(www->dockSite( ) & (int)curPos) ) return 0L;
if ( !(currentDragWidget->eDocking & (int)curPos) ) return 0L;
if ( www->manager != this ) return 0L;
dropCancel = false;
return www;
}
void PMDockManager::findChildDockWidget( TQWidget*& ww, const TQWidget* p, const TQPoint& pos )
{
TQObjectList clo = p->childrenListObject();
if ( !clo.isEmpty() ) {
TQWidget *w;
TQObjectListIt it( clo );
it.toLast();
while ( it.current() ) {
if ( it.current()->isWidgetType() ) {
w = (TQWidget*)it.current();
if ( w->isVisible() && w->geometry().contains(pos) ) {
if ( w->inherits("PMDockWidget") ) ww = w;
findChildDockWidget( ww, w, w->mapFromParent(pos) );
return;
}
}
--it;
}
}
return;
}
void PMDockManager::findChildDockWidget( const TQWidget* p, TQWidgetList& list )
{
TQObjectList clo = p->childrenListObject();
if ( !clo.isEmpty() ) {
TQWidget *w;
TQObjectListIt it( clo );
it.toLast();
while ( it.current() ) {
if ( it.current()->isWidgetType() ) {
w = (TQWidget*)it.current();
if ( w->isVisible() ) {
if ( w->inherits("PMDockWidget") ) list.append( w );
findChildDockWidget( w, list );
}
}
--it;
}
}
return;
}
void PMDockManager::findFloatingWidgets( TQPtrList<PMDockWidget>& l )
{
TQObjectListIt it( *childDock );
for( ; it.current( ); ++it )
if( it.current( )->inherits( "PMDockWidget" ) &&
!it.current( )->parent( ) )
l.append( ( PMDockWidget* ) it.current( ) );
}
void PMDockManager::startDrag( PMDockWidget* w )
{
if(( w->currentDockPos == PMDockWidget::DockLeft) || ( w->currentDockPos == PMDockWidget::DockRight)
|| ( w->currentDockPos == PMDockWidget::DockTop) || ( w->currentDockPos == PMDockWidget::DockBottom)) {
w->prevSideDockPosBeforeDrag = w->currentDockPos;
if ( w->parentWidget()->inherits("PMDockSplitter") ){
PMDockSplitter* parentSplitterOfDockWidget = (PMDockSplitter*)(w->parentWidget());
w->d->splitPosInPercent = parentSplitterOfDockWidget->separatorPos();
}
}
curPos = PMDockWidget::DockDesktop;
draging = true;
TQApplication::setOverrideCursor(TQCursor(sizeAllCursor));
}
void PMDockManager::dragMove( PMDockWidget* dw, TQPoint pos )
{
TQPoint p = dw->mapToGlobal( dw->widget->pos() );
PMDockWidget::DockPosition oldPos = curPos;
TQSize r = dw->widget->size();
if ( dw->parentDockTabGroup() ){
curPos = PMDockWidget::DockCenter;
if ( oldPos != curPos ) {
d->dragRect.setRect( p.x()+2, p.y()+2, r.width()-4, r.height()-4 );
}
return;
}
int w = r.width() / 3;
int h = r.height() / 3;
PMDockMainWindow* mw = ( PMDockMainWindow* ) parent( );
TQWidget* cw = mw->centralWidget( );
TQPoint cwp = cw->mapToGlobal( TQPoint( 0, 0 ) );
int cwh = cw->height( );
if ( pos.y() <= h )
{
curPos = PMDockWidget::DockTop;
w = r.width();
}
else if ( pos.y() >= 2*h )
{
curPos = PMDockWidget::DockBottom;
p.setY( p.y() + 2*h );
w = r.width();
}
else if ( pos.x() <= w )
{
curPos = PMDockWidget::DockLeft;
h = r.height();
p.setY( cwp.y( ) );
h = cwh;
}
else if ( pos.x() >= 2*w )
{
curPos = PMDockWidget::DockRight;
p.setX( p.x() + 2*w );
p.setY( cwp.y( ) );
h = cwh;
}
else
{
curPos = PMDockWidget::DockCenter;
p.setX( p.x() + w );
p.setY( p.y() + h );
}
if ( oldPos != curPos ) {
d->dragRect.setRect( p.x(), p.y(), w, h );
drawDragRectangle();
}
}
void PMDockManager::cancelDrop()
{
TQApplication::restoreOverrideCursor();
delete childDockWidgetList;
childDockWidgetList = 0L;
d->dragRect = TQRect(); // cancel drawing
drawDragRectangle(); // only the old rect will be deleted
}
void PMDockManager::drop()
{
d->dragRect = TQRect(); // cancel drawing
drawDragRectangle(); // only the old rect will be deleted
TQApplication::restoreOverrideCursor();
delete childDockWidgetList;
childDockWidgetList = 0L;
if ( dropCancel ) return;
if ( !currentMoveWidget && ((currentDragWidget->eDocking & (int)PMDockWidget::DockDesktop) == 0) ) {
d->dragRect = TQRect(); // cancel drawing
drawDragRectangle(); // only the old rect will be deleted
return;
}
if ( !currentMoveWidget && !currentDragWidget->parent() ) {
currentDragWidget->move( TQCursor::pos() - d->dragOffset );
}
else {
int splitPos = currentDragWidget->d->splitPosInPercent;
// do we have to calculate 100%-splitPosInPercent?
if( (curPos != currentDragWidget->prevSideDockPosBeforeDrag) && (curPos != PMDockWidget::DockCenter) && (curPos != PMDockWidget::DockDesktop)) {
switch( currentDragWidget->prevSideDockPosBeforeDrag) {
case PMDockWidget::DockLeft: if(curPos != PMDockWidget::DockTop) splitPos = 100-splitPos; break;
case PMDockWidget::DockRight: if(curPos != PMDockWidget::DockBottom) splitPos = 100-splitPos; break;
case PMDockWidget::DockTop: if(curPos != PMDockWidget::DockLeft) splitPos = 100-splitPos; break;
case PMDockWidget::DockBottom: if(curPos != PMDockWidget::DockRight) splitPos = 100-splitPos; break;
default: break;
}
}
currentDragWidget->manualDock( currentMoveWidget, curPos , splitPos, TQCursor::pos() - d->dragOffset );
currentDragWidget->makeDockVisible();
}
}
static TQDomElement createStringEntry(TQDomDocument &doc, const TQString &tagName, const TQString &str)
{
TQDomElement el = doc.createElement(tagName);
el.appendChild(doc.createTextNode(str));
return el;
}
static TQDomElement createBoolEntry(TQDomDocument &doc, const TQString &tagName, bool b)
{
return createStringEntry(doc, tagName, TQString::fromLatin1(b? "true" : "false"));
}
static TQDomElement createNumberEntry(TQDomDocument &doc, const TQString &tagName, int n)
{
return createStringEntry(doc, tagName, TQString::number(n));
}
static TQDomElement createRectEntry(TQDomDocument &doc, const TQString &tagName, const TQRect &rect)
{
TQDomElement el = doc.createElement(tagName);
TQDomElement xel = doc.createElement("x");
xel.appendChild(doc.createTextNode(TQString::number(rect.x())));
el.appendChild(xel);
TQDomElement yel = doc.createElement("y");
yel.appendChild(doc.createTextNode(TQString::number(rect.y())));
el.appendChild(yel);
TQDomElement wel = doc.createElement("width");
wel.appendChild(doc.createTextNode(TQString::number(rect.width())));
el.appendChild(wel);
TQDomElement hel = doc.createElement("height");
hel.appendChild(doc.createTextNode(TQString::number(rect.height())));
el.appendChild(hel);
return el;
}
static TQDomElement createListEntry(TQDomDocument &doc, const TQString &tagName,
const TQString &subTagName, const TQStrList &list)
{
TQDomElement el = doc.createElement(tagName);
TQStrListIterator it(list);
for (; it.current(); ++it) {
TQDomElement subel = doc.createElement(subTagName);
subel.appendChild(doc.createTextNode(TQString::fromLatin1(it.current())));
el.appendChild(subel);
}
return el;
}
static TQString stringEntry(TQDomElement &base, const TQString &tagName)
{
return base.namedItem(tagName).firstChild().toText().data();
}
static bool boolEntry(TQDomElement &base, const TQString &tagName)
{
return base.namedItem(tagName).firstChild().toText().data() == "true";
}
static int numberEntry(TQDomElement &base, const TQString &tagName)
{
return stringEntry(base, tagName).toInt();
}
static TQRect rectEntry(TQDomElement &base, const TQString &tagName)
{
TQDomElement el = base.namedItem(tagName).toElement();
int x = numberEntry(el, "x");
int y = numberEntry(el, "y");
int width = numberEntry(el, "width");
int height = numberEntry(el, "height");
return TQRect(x, y, width, height);
}
static TQStrList listEntry(TQDomElement &base, const TQString &tagName, const TQString &subTagName)
{
TQStrList list;
TQDomElement subel = base.namedItem(tagName).firstChild().toElement();
while (!subel.isNull()) {
if (subel.tagName() == subTagName)
list.append(subel.firstChild().toText().data().latin1());
subel = subel.nextSibling().toElement();
}
return list;
}
void PMDockManager::writeConfig(TQDomElement &base)
{
// First of all, clear the tree under base
while (!base.firstChild().isNull())
base.removeChild(base.firstChild());
TQDomDocument doc = base.ownerDocument();
TQStrList nameList;
TQString mainWidgetStr;
// collect widget names
TQStrList nList;
TQObjectListIt it(*childDock);
PMDockWidget *obj1;
while ( (obj1=(PMDockWidget*)it.current()) ) {
if ( TQT_BASE_OBJECT(obj1->parent()) == TQT_BASE_OBJECT(main) )
mainWidgetStr = TQString::fromLatin1(obj1->name());
nList.append(obj1->name());
++it;
}
nList.first();
while ( nList.current() ) {
PMDockWidget *obj = getDockWidgetFromName( nList.current() );
if (obj->isGroup && (nameList.find( obj->firstName.latin1() ) == -1
|| nameList.find(obj->lastName.latin1()) == -1)) {
// Skip until children are saved (why?)
nList.next();
if ( !nList.current() ) nList.first();
continue;
}
TQDomElement groupEl;
if (obj->isGroup) {
//// Save a group
groupEl = doc.createElement("splitGroup");
groupEl.appendChild(createStringEntry(doc, "firstName", obj->firstName));
groupEl.appendChild(createStringEntry(doc, "secondName", obj->lastName));
groupEl.appendChild(createNumberEntry(doc, "orientation", (int)obj->splitterOrientation));
groupEl.appendChild(createNumberEntry(doc, "separatorPos", ((PMDockSplitter*)obj->widget)->separatorPos()));
} else if (obj->isTabGroup) {
//// Save a tab group
groupEl = doc.createElement("tabGroup");
TQStrList list;
for ( int i = 0; i < ((PMDockTabGroup*)obj->widget)->count(); ++i )
list.append( ((PMDockTabGroup*)obj->widget)->page( i )->name() );
groupEl.appendChild(createListEntry(doc, "tabs", "tab", list));
groupEl.appendChild(createNumberEntry(doc, "currentTab", ((PMDockTabGroup*)obj->widget)->currentPageIndex()));
} else {
//// Save an ordinary dock widget
groupEl = doc.createElement("dock");
}
groupEl.appendChild(createStringEntry(doc, "name", TQString::fromLatin1(obj->name())));
groupEl.appendChild(createBoolEntry(doc, "hasParent", obj->parent()));
if ( !obj->parent() ) {
groupEl.appendChild(createRectEntry(doc, "geometry", TQRect(main->frameGeometry().topLeft(), main->size())));
groupEl.appendChild(createBoolEntry(doc, "visible", obj->isVisible()));
}
if (obj->header && obj->header->inherits("PMDockWidgetHeader")) {
PMDockWidgetHeader *h = static_cast<PMDockWidgetHeader*>(obj->header);
groupEl.appendChild(createBoolEntry(doc, "dragEnabled", h->dragEnabled()));
}
base.appendChild(groupEl);
nameList.append(obj->name());
nList.remove();
nList.first();
}
if (main->inherits("PMDockMainWindow")) {
PMDockMainWindow *dmain = (PMDockMainWindow*)main;
TQString centralWidgetStr = TQString(dmain->centralWidget()? dmain->centralWidget()->name() : "");
base.appendChild(createStringEntry(doc, "centralWidget", centralWidgetStr));
TQString mainDockWidgetStr = TQString(dmain->getMainDockWidget()? dmain->getMainDockWidget()->name() : "");
base.appendChild(createStringEntry(doc, "mainDockWidget", mainDockWidgetStr));
} else {
base.appendChild(createStringEntry(doc, "mainWidget", mainWidgetStr));
}
base.appendChild(createRectEntry(doc, "geometry", TQRect(main->frameGeometry().topLeft(), main->size())));
}
void PMDockManager::readConfig(TQDomElement &base)
{
if (base.namedItem("group").isNull()
&& base.namedItem("tabgroup").isNull()
&& base.namedItem("dock").isNull()) {
activate();
return;
}
autoCreateDock = new TQObjectList();
autoCreateDock->setAutoDelete( true );
bool isMainVisible = main->isVisible();
main->hide();
TQObjectListIt it(*childDock);
PMDockWidget *obj1;
while ( (obj1=(PMDockWidget*)it.current()) ) {
if ( !obj1->isGroup && !obj1->isTabGroup ) {
if ( obj1->parent() )
obj1->undock();
else
obj1->hide();
}
++it;
}
TQDomElement childEl = base.firstChild().toElement();
while (!childEl.isNull() ) {
PMDockWidget *obj = 0;
if (childEl.tagName() == "splitGroup") {
// Read a group
TQString name = stringEntry(childEl, "name");
TQString firstName = stringEntry(childEl, "firstName");
TQString secondName = stringEntry(childEl, "secondName");
int orientation = numberEntry(childEl, "orientation");
int separatorPos = numberEntry(childEl, "separatorPos");
PMDockWidget *first = getDockWidgetFromName(firstName);
PMDockWidget *second = getDockWidgetFromName(secondName);
if (first && second) {
obj = first->manualDock(second,
(orientation == (int)Qt::Vertical)? PMDockWidget::DockLeft : PMDockWidget::DockTop,
separatorPos);
if (obj)
obj->setName(name.latin1());
}
} else if (childEl.tagName() == "tabGroup") {
// Read a tab group
TQString name = stringEntry(childEl, "name");
TQStrList list = listEntry(childEl, "tabs", "tab");
PMDockWidget *d1 = getDockWidgetFromName( list.first() );
list.next();
PMDockWidget *d2 = getDockWidgetFromName( list.current() );
PMDockWidget *obj = d2->manualDock( d1, PMDockWidget::DockCenter );
if (obj) {
PMDockTabGroup *tab = (PMDockTabGroup*)obj->widget;
list.next();
while (list.current() && obj) {
PMDockWidget *tabDock = getDockWidgetFromName(list.current());
obj = tabDock->manualDock(d1, PMDockWidget::DockCenter);
list.next();
}
if (obj) {
obj->setName(name.latin1());
tab->showPage(tab->page(numberEntry(childEl, "currentTab")));
}
}
} else if (childEl.tagName() == "dock") {
// Read an ordinary dock widget
obj = getDockWidgetFromName(stringEntry(childEl, "name"));
}
if (!boolEntry(childEl, "hasParent")) {
TQRect r = rectEntry(childEl, "geometry");
obj = getDockWidgetFromName(stringEntry(childEl, "name"));
obj->applyToWidget(0);
obj->setGeometry(r);
if (boolEntry(childEl, "visible"))
obj->TQWidget::show();
}
if (obj && obj->header && obj->header->inherits("PMDockWidgetHeader")) {
PMDockWidgetHeader *h = static_cast<PMDockWidgetHeader*>(obj->header);
h->setDragEnabled(boolEntry(childEl, "dragEnabled"));
}
childEl = childEl.nextSibling().toElement();
}
if (main->inherits("PMDockMainWindow")) {
PMDockMainWindow *dmain = (PMDockMainWindow*)main;
TQString mv = stringEntry(base, "centralWidget");
if (!mv.isEmpty() && getDockWidgetFromName(mv) ) {
PMDockWidget *mvd = getDockWidgetFromName(mv);
mvd->applyToWidget(dmain);
mvd->show();
dmain->setCentralWidget(mvd);
}
TQString md = stringEntry(base, "mainDockWidget");
if (!md.isEmpty() && getDockWidgetFromName(md)) {
PMDockWidget *mvd = getDockWidgetFromName(md);
dmain->setMainDockWidget(mvd);
}
} else {
TQString mv = stringEntry(base, "mainWidget");
if (!mv.isEmpty() && getDockWidgetFromName(mv)) {
PMDockWidget *mvd = getDockWidgetFromName(mv);
mvd->applyToWidget(main);
mvd->show();
}
}
TQRect mr = rectEntry(base, "geometry");
main->setGeometry(mr);
if (isMainVisible)
main->show();
delete autoCreateDock;
autoCreateDock = 0;
}
#ifndef NO_KDE2
void PMDockManager::writeConfig( KConfig* c, TQString group )
{
//debug("BEGIN Write Config");
if ( !c ) c = KGlobal::config();
if ( group.isEmpty() ) group = "dock_setting_default";
c->setGroup( group );
c->writeEntry( "Version", DOCK_CONFIG_VERSION );
TQStrList nameList;
TQStrList findList;
TQObjectListIt it( *childDock );
PMDockWidget * obj;
// collect PMDockWidget's name
TQStrList nList;
while ( (obj=(PMDockWidget*)it.current()) ) {
++it;
//debug(" +Add subdock %s", obj->name());
nList.append( obj->name() );
if ( TQT_BASE_OBJECT(obj->parent()) == TQT_BASE_OBJECT(main) )
c->writeEntry( "Main:view", obj->name() );
}
nList.first();
while ( nList.current() ){
//debug(" -Try to save %s", nList.current());
obj = getDockWidgetFromName( nList.current() );
TQString cname = obj->name();
if ( obj->header ){
obj->header->saveConfig( c );
}
/*************************************************************************************************/
if ( obj->isGroup ){
if ( findList.find( obj->firstName.latin1() ) != -1 && findList.find( obj->lastName.latin1() ) != -1 ){
c->writeEntry( cname+":type", "GROUP");
if ( !obj->parent() ){
c->writeEntry( cname+":parent", "___null___");
c->writeEntry( cname+":geometry", TQRect(obj->frameGeometry().topLeft(), obj->size()) );
c->writeEntry( cname+":visible", obj->isVisible());
} else {
c->writeEntry( cname+":parent", "yes");
}
c->writeEntry( cname+":first_name", obj->firstName );
c->writeEntry( cname+":last_name", obj->lastName );
c->writeEntry( cname+":orientation", (int)obj->splitterOrientation );
c->writeEntry( cname+":sepPos", ((PMDockSplitter*)obj->widget)->separatorPos() );
nameList.append( obj->name() );
findList.append( obj->name() );
//debug(" Save %s", nList.current());
nList.remove();
nList.first();
} else {
/*************************************************************************************************/
//debug(" Skip %s", nList.current());
//if ( findList.find( obj->firstName ) == -1 )
// debug(" ? Not found %s", obj->firstName);
//if ( findList.find( obj->lastName ) == -1 )
// debug(" ? Not found %s", obj->lastName);
nList.next();
if ( !nList.current() ) nList.first();
}
} else {
/*************************************************************************************************/
if ( obj->isTabGroup){
c->writeEntry( cname+":type", "TAB_GROUP");
if ( !obj->parent() ){
c->writeEntry( cname+":parent", "___null___");
c->writeEntry( cname+":geometry", TQRect(obj->frameGeometry().topLeft(), obj->size()) );
c->writeEntry( cname+":visible", obj->isVisible());
} else {
c->writeEntry( cname+":parent", "yes");
}
TQStrList list;
for ( int i = 0; i < ((PMDockTabGroup*)obj->widget)->count(); ++i )
list.append( ((PMDockTabGroup*)obj->widget)->page( i )->name() );
c->writeEntry( cname+":tabNames", list );
c->writeEntry( cname+":curTab", ((PMDockTabGroup*)obj->widget)->currentPageIndex() );
nameList.append( obj->name() );
findList.append( obj->name() ); // not really need !!!
//debug(" Save %s", nList.current());
nList.remove();
nList.first();
} else {
/*************************************************************************************************/
if ( !obj->parent() ){
c->writeEntry( cname+":type", "NULL_DOCK");
c->writeEntry( cname+":geometry", TQRect(obj->frameGeometry().topLeft(), obj->size()) );
c->writeEntry( cname+":visible", obj->isVisible());
} else {
c->writeEntry( cname+":type", "DOCK");
}
nameList.append( cname.latin1() );
//debug(" Save %s", nList.current());
findList.append( obj->name() );
nList.remove();
nList.first();
}
}
}
c->writeEntry( "NameList", nameList );
c->writeEntry( "Main:Geometry", TQRect(main->frameGeometry().topLeft(), main->size()) );
c->writeEntry( "Main:visible", main->isVisible()); // curently nou use
if ( main->inherits("PMDockMainWindow") ){
PMDockMainWindow* dmain = (PMDockMainWindow*)main;
// for PMDockMainWindow->setView() in readConfig()
c->writeEntry( "Main:view", dmain->centralWidget() ? dmain->centralWidget()->name():"" );
c->writeEntry( "Main:dock", dmain->getMainDockWidget() ? dmain->getMainDockWidget()->name() :"" );
}
c->sync();
//debug("END Write Config");
}
#include <tqmessagebox.h>
void PMDockManager::readConfig( KConfig* c, TQString group )
{
if ( !c ) c = KGlobal::config();
if ( group.isEmpty() ) group = "dock_setting_default";
c->setGroup( group );
TQStrList nameList;
c->readListEntry( "NameList", nameList );
TQString ver = c->readEntry( "Version", "0.0.1" );
nameList.first();
if ( !nameList.current() || ver != DOCK_CONFIG_VERSION ){
activate();
return;
}
autoCreateDock = new TQObjectList();
autoCreateDock->setAutoDelete( true );
bool isMainVisible = main->isVisible();
// if (isMainVisible) // CCC
//TQMessageBox::information(0,"","hallo");
//COMMENTED4TESTING main->hide();
TQObjectListIt it( *childDock );
PMDockWidget * obj;
while ( (obj=(PMDockWidget*)it.current()) ){
++it;
if ( !obj->isGroup && !obj->isTabGroup )
{
if ( obj->parent() ) obj->undock(); else obj->hide();
}
}
nameList.first();
while ( nameList.current() ){
TQString oname = nameList.current();
c->setGroup( group );
TQString type = c->readEntry( oname + ":type" );
obj = 0L;
if ( type == "GROUP" ){
PMDockWidget* first = getDockWidgetFromName( c->readEntry( oname + ":first_name" ) );
PMDockWidget* last = getDockWidgetFromName( c->readEntry( oname + ":last_name" ) );
int sepPos = c->readNumEntry( oname + ":sepPos" );
Qt::Orientation p = (Qt::Orientation)c->readNumEntry( oname + ":orientation" );
if ( first && last ){
obj = first->manualDock( last, ( p ==Qt::Vertical ) ? PMDockWidget::DockLeft : PMDockWidget::DockTop, sepPos );
if (obj){
obj->setName( oname.latin1() );
}
}
}
if ( type == "TAB_GROUP" ){
TQStrList list;
PMDockWidget* tabDockGroup = 0L;
c->readListEntry( oname+":tabNames", list );
PMDockWidget* d1 = getDockWidgetFromName( list.first() );
list.next();
PMDockWidget* d2 = getDockWidgetFromName( list.current() );
tabDockGroup = d2->manualDock( d1, PMDockWidget::DockCenter );
if ( tabDockGroup ){
PMDockTabGroup* tab = (PMDockTabGroup*)tabDockGroup->widget;
list.next();
while ( list.current() && tabDockGroup ){
PMDockWidget* tabDock = getDockWidgetFromName( list.current() );
tabDockGroup = tabDock->manualDock( d1, PMDockWidget::DockCenter );
list.next();
}
if ( tabDockGroup ){
tabDockGroup->setName( oname.latin1() );
c->setGroup( group );
tab->showPage( tab->page( c->readNumEntry( oname+":curTab" ) ) );
}
}
obj = tabDockGroup;
}
if ( type == "NULL_DOCK" || c->readEntry( oname + ":parent") == "___null___" ){
TQRect r = c->readRectEntry( oname + ":geometry" );
obj = getDockWidgetFromName( oname );
obj->applyToWidget( 0L );
obj->setGeometry(r);
c->setGroup( group );
if ( c->readBoolEntry( oname + ":visible" ) ){
obj->TQWidget::show();
}
}
if ( type == "DOCK" ){
obj = getDockWidgetFromName( oname );
}
if ( obj && obj->header){
obj->header->loadConfig( c );
}
nameList.next();
}
if ( main->inherits("PMDockMainWindow") ){
PMDockMainWindow* dmain = (PMDockMainWindow*)main;
c->setGroup( group );
TQString mv = c->readEntry( "Main:view" );
if ( !mv.isEmpty() && getDockWidgetFromName( mv ) ){
PMDockWidget* mvd = getDockWidgetFromName( mv );
mvd->applyToWidget( dmain );
mvd->show();
dmain->setView( mvd );
}
c->setGroup( group );
TQString md = c->readEntry( "Main:dock" );
if ( !md.isEmpty() && getDockWidgetFromName( md ) ){
PMDockWidget* mvd = getDockWidgetFromName( md );
dmain->setMainDockWidget( mvd );
}
} else {
c->setGroup( group );
TQString mv = c->readEntry( "Main:view" );
if ( !mv.isEmpty() && getDockWidgetFromName( mv ) ){
PMDockWidget* mvd = getDockWidgetFromName( mv );
mvd->applyToWidget( main );
mvd->show();
}
}
// delete all autocreate dock
delete autoCreateDock;
autoCreateDock = 0L;
c->setGroup( group );
TQRect mr = c->readRectEntry("Main:Geometry");
main->setGeometry(mr);
if ( isMainVisible ) main->show();
}
#endif
PMDockWidget* PMDockManager::getDockWidgetFromName( const TQString& dockName )
{
TQObjectListIt it( *childDock );
PMDockWidget * obj;
while ( (obj=(PMDockWidget*)it.current()) ) {
++it;
if ( TQString(obj->name()) == dockName ) return obj;
}
PMDockWidget* autoCreate = 0L;
if ( autoCreateDock ){
autoCreate = new PMDockWidget( this, dockName.latin1(), TQPixmap(TQString("")) );
autoCreateDock->append( TQT_TQOBJECT(autoCreate) );
}
return autoCreate;
}
void PMDockManager::setSplitterOpaqueResize(bool b)
{
d->splitterOpaqueResize = b;
}
bool PMDockManager::splitterOpaqueResize() const
{
return d->splitterOpaqueResize;
}
void PMDockManager::setSplitterKeepSize(bool b)
{
d->splitterKeepSize = b;
}
bool PMDockManager::splitterKeepSize() const
{
return d->splitterKeepSize;
}
void PMDockManager::setSplitterHighResolution(bool b)
{
d->splitterHighResolution = b;
}
bool PMDockManager::splitterHighResolution() const
{
return d->splitterHighResolution;
}
void PMDockManager::slotMenuPopup()
{
menu->clear();
menuData->clear();
TQObjectListIt it( *childDock );
PMDockWidget * obj;
int numerator = 0;
while ( (obj=(PMDockWidget*)it.current()) ) {
++it;
if ( obj->mayBeHide() )
{
menu->insertItem( obj->icon() ? *(obj->icon()) : TQPixmap(), TQString("Hide ") + obj->caption(), numerator++ );
menuData->append( new MenuDockData( obj, true ) );
}
if ( obj->mayBeShow() )
{
menu->insertItem( obj->icon() ? *(obj->icon()) : TQPixmap(), TQString("Show ") + obj->caption(), numerator++ );
menuData->append( new MenuDockData( obj, false ) );
}
}
}
void PMDockManager::slotMenuActivated( int id )
{
MenuDockData* data = menuData->at( id );
data->dock->changeHideShowState();
}
PMDockWidget* PMDockManager::findWidgetParentDock( TQWidget* w ) const
{
TQObjectListIt it( *childDock );
PMDockWidget * dock;
PMDockWidget * found = 0L;
while ( (dock=(PMDockWidget*)it.current()) ) {
++it;
if ( dock->widget == w ){ found = dock; break; }
}
return found;
}
void PMDockManager::drawDragRectangle()
{
if (d->oldDragRect == d->dragRect)
return;
int i;
TQRect oldAndNewDragRect[2];
oldAndNewDragRect[0] = d->oldDragRect;
oldAndNewDragRect[1] = d->dragRect;
// 2 calls, one for the old and one for the new drag rectangle
for (i = 0; i <= 1; i++) {
if (oldAndNewDragRect[i].isEmpty())
continue;
PMDockWidget* pDockWdgAtRect = (PMDockWidget*) TQApplication::widgetAt( oldAndNewDragRect[i].topLeft(), true );
if (!pDockWdgAtRect)
continue;
bool isOverMainWdg = false;
bool unclipped;
PMDockMainWindow* pMain = 0L;
PMDockWidget* pTLDockWdg = 0L;
TQWidget* topWdg;
if (pDockWdgAtRect->topLevelWidget() == main) {
isOverMainWdg = true;
topWdg = pMain = (PMDockMainWindow*) main;
unclipped = pMain->testWFlags( WPaintUnclipped );
pMain->setWFlags( WPaintUnclipped );
}
else {
topWdg = pTLDockWdg = (PMDockWidget*) pDockWdgAtRect->topLevelWidget();
unclipped = pTLDockWdg->testWFlags( WPaintUnclipped );
pTLDockWdg->setWFlags( WPaintUnclipped );
}
// draw the rectangle unclipped over the main dock window
TQPainter p;
p.begin( topWdg );
if ( !unclipped ) {
if (isOverMainWdg)
pMain->clearWFlags(WPaintUnclipped);
else
pTLDockWdg->clearWFlags(WPaintUnclipped);
}
// draw the rectangle
p.setRasterOp(TQt::NotXorROP);
TQRect r = oldAndNewDragRect[i];
r.moveTopLeft( r.topLeft() - topWdg->mapToGlobal(TQPoint(0,0)) );
p.drawRect(r.x(), r.y(), r.width(), r.height());
p.end();
}
// memorize the current rectangle for later removing
d->oldDragRect = d->dragRect;
}
#ifdef _JOWENN_EXPERIMENTAL_
PMDockArea::PMDockArea( TQWidget* parent, const char *name)
:TQWidget( parent, name)
{
TQString new_name = TQString(name) + TQString("_DockManager");
dockManager = new PMDockManager( this, new_name.latin1() );
mainDockWidget = 0L;
}
PMDockArea::~PMDockArea()
{
delete dockManager;
}
PMDockWidget* PMDockArea::createDockWidget( const TQString& name, const TQPixmap &pixmap, TQWidget* parent, const TQString& strCaption, const TQString& strTabPageLabel)
{
return new PMDockWidget( dockManager, name.latin1(), pixmap, parent, strCaption, strTabPageLabel );
}
void PMDockArea::makeDockVisible( PMDockWidget* dock )
{
if ( dock != 0L)
dock->makeDockVisible();
}
void PMDockArea::makeDockInvisible( PMDockWidget* dock )
{
if ( dock != 0L)
dock->undock();
}
void PMDockArea::makeWidgetDockVisible( TQWidget* widget )
{
makeDockVisible( dockManager->findWidgetParentDock(widget) );
}
void PMDockArea::writeDockConfig(TQDomElement &base)
{
dockManager->writeConfig(base);
}
void PMDockArea::readDockConfig(TQDomElement &base)
{
dockManager->readConfig(base);
}
void PMDockArea::slotDockWidgetUndocked()
{
TQObject* pSender = (TQObject*) sender();
if (!pSender->inherits("PMDockWidget")) return;
PMDockWidget* pDW = (PMDockWidget*) pSender;
emit dockWidgetHasUndocked( pDW);
}
void PMDockArea::resizeEvent(TQResizeEvent *rsize)
{
TQWidget::resizeEvent(rsize);
if (!childrenListObject().isEmpty()){
#ifndef NO_KDE2
kdDebug()<<"PMDockArea::resize"<<endl;
#endif
TQObjectList *list=queryList(TQWIDGET_OBJECT_NAME_STRING,0,false);
TQObjectListIt it( *list ); // iterate over the buttons
TQObject *obj;
while ( (obj = it.current()) != 0 ) {
// for each found object...
((TQWidget*)obj)->setGeometry(TQRect(TQPoint(0,0),size()));
break;
}
delete list;
#if 0
PMDockSplitter *split;
// for (unsigned int i=0;i<children()->count();i++)
{
// TQPtrList<TQObject> list(children());
// TQObject *obj=((TQPtrList<TQObject*>)children())->at(i);
TQObject *obj=children()->getFirst();
if (split=dynamic_cast<PMDockSplitter*>(obj))
{
split->setGeometry( TQRect(TQPoint(0,0), size() ));
// break;
}
}
#endif
}
}
#ifndef NO_KDE2
void PMDockArea::writeDockConfig( KConfig* c, TQString group )
{
dockManager->writeConfig( c, group );
}
void PMDockArea::readDockConfig( KConfig* c, TQString group )
{
dockManager->readConfig( c, group );
}
void PMDockArea::setMainDockWidget( PMDockWidget* mdw )
{
if ( mainDockWidget == mdw ) return;
mainDockWidget = mdw;
mdw->applyToWidget(this);
}
#endif
#endif
void PMDockWidgetAbstractHeader::virtual_hook( int, void* )
{ /*BASE::virtual_hook( id, data );*/ }
void PMDockWidgetAbstractHeaderDrag::virtual_hook( int, void* )
{ /*BASE::virtual_hook( id, data );*/ }
void PMDockWidgetHeaderDrag::virtual_hook( int id, void* data )
{ PMDockWidgetAbstractHeaderDrag::virtual_hook( id, data ); }
void PMDockWidgetHeader::virtual_hook( int id, void* data )
{ PMDockWidgetAbstractHeader::virtual_hook( id, data ); }
void PMDockTabGroup::virtual_hook( int, void* )
{ /*BASE::virtual_hook( id, data );*/ }
void PMDockWidget::virtual_hook( int, void* )
{ /*BASE::virtual_hook( id, data );*/ }
void PMDockManager::virtual_hook( int, void* )
{ /*BASE::virtual_hook( id, data );*/ }
void PMDockMainWindow::virtual_hook( int id, void* data )
{ KMainWindow::virtual_hook( id, data ); }
void PMDockArea::virtual_hook( int, void* )
{ /*KMainWindow::virtual_hook( id, data );*/ }
#ifndef NO_INCLUDE_TQMOCFILES // for TQt-only projects, because tmake doesn't take this name
#include "pmdockwidget.moc"
#endif