diff options
Diffstat (limited to 'tqtinterface/qt4/src/widgets/tqwidgetresizehandler.cpp')
| -rw-r--r-- | tqtinterface/qt4/src/widgets/tqwidgetresizehandler.cpp | 516 |
1 files changed, 516 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/widgets/tqwidgetresizehandler.cpp b/tqtinterface/qt4/src/widgets/tqwidgetresizehandler.cpp new file mode 100644 index 0000000..b9b576a --- /dev/null +++ b/tqtinterface/qt4/src/widgets/tqwidgetresizehandler.cpp @@ -0,0 +1,516 @@ +/**************************************************************************** +** +** Implementation of the TQWidgetResizeHandler class +** +** Created : 001010 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of the workspace module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include "tqwidgetresizehandler_p.h" + +#ifndef TQT_NO_RESIZEHANDLER +#include "tqframe.h" +#include "tqapplication.h" +#include "tqcursor.h" +#include "tqsizegrip.h" +#if defined(TQ_WS_WIN) +#include "tqt_windows.h" +#endif + +#define RANGE 4 + +static bool resizeHorizontalDirectionFixed = FALSE; +static bool resizeVerticalDirectionFixed = FALSE; + +TQWidgetResizeHandler::TQWidgetResizeHandler( TQWidget *tqparent, TQWidget *cw, const char *name ) + : TQObject( tqparent, name ), widget( tqparent ), childWidget( cw ? cw : tqparent ), + extrahei( 0 ), buttonDown( FALSE ), moveResizeMode( FALSE ), sizeprotect( TRUE ), moving( TRUE ) +{ + mode = Nowhere; + widget->setMouseTracking( TRUE ); + TQFrame *frame = ::tqqt_cast<TQFrame*>(widget); + range = frame ? frame->frameWidth() : RANGE; + range = TQMAX( RANGE, range ); + activeForMove = activeForResize = TRUE; + tqApp->installEventFilter( this ); +} + +void TQWidgetResizeHandler::setActive( Action ac, bool b ) +{ + if ( ac & Move ) + activeForMove = b; + if ( ac & Resize ) + activeForResize = b; + + if ( !isActive() ) + setMouseCursor( Nowhere ); +} + +bool TQWidgetResizeHandler::isActive( Action ac ) const +{ + bool b = FALSE; + if ( ac & Move ) b = activeForMove; + if ( ac & Resize ) b |= activeForResize; + + return b; +} + +static TQWidget *childOf( TQWidget *w, TQWidget *child ) +{ + while ( child ) { + if ( child == w ) + return child; + if ( child->isTopLevel() ) + break; + child = child->parentWidget(); + } + return 0; +} + +bool TQWidgetResizeHandler::eventFilter( TQObject *o, TQEvent *ee ) +{ + if ( !isActive() || !o->isWidgetType() || !ee->spontaneous()) + return FALSE; + + if ( ee->type() != TQEvent::MouseButtonPress && + ee->type() != TQEvent::MouseButtonRelease && + ee->type() != TQEvent::MouseMove && + ee->type() != TQEvent::KeyPress && + ee->type() != (QEvent::Type)TQEvent::AccelOverride ) + return FALSE; + + TQWidget *w = childOf( widget, (TQWidget*)o ); + if ( !w +#ifndef TQT_NO_SIZEGRIP + || ::tqqt_cast<TQSizeGrip*>(o) +#endif + || tqApp->activePopupWidget() ) { + if ( buttonDown && ee->type() == TQEvent::MouseButtonRelease ) + buttonDown = FALSE; + return FALSE; + } + + TQMouseEvent *e = (TQMouseEvent*)ee; + switch ( e->type() ) { + case TQEvent::MouseButtonPress: { + if ( w->isMaximized() ) + break; + if ( !TQT_TQRECT_OBJECT(widget->rect()).tqcontains( widget->mapFromGlobal( e->globalPos() ) ) ) + return FALSE; + if ( e->button() == Qt::LeftButton ) { + emit activate(); + bool me = isMovingEnabled(); + setMovingEnabled( me && TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(widget) ); + mouseMoveEvent( e ); + setMovingEnabled( me ); + buttonDown = TRUE; + moveOffset = widget->mapFromGlobal( e->globalPos() ); + invertedMoveOffset = widget->rect().bottomRight() - moveOffset; + } + } break; + case TQEvent::MouseButtonRelease: + if ( w->isMaximized() ) + break; + if ( e->button() == Qt::LeftButton ) { + moveResizeMode = FALSE; + buttonDown = FALSE; + widget->releaseMouse(); + widget->releaseKeyboard(); + } + break; + case TQEvent::MouseMove: { + if ( w->isMaximized() ) + break; + bool me = isMovingEnabled(); + setMovingEnabled( me && TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(widget) ); + mouseMoveEvent( e ); + setMovingEnabled( me ); + if ( buttonDown && mode != Center ) + return TRUE; + } break; + case TQEvent::KeyPress: + keyPressEvent( (TQKeyEvent*)e ); + break; + case TQEvent::AccelOverride: + if ( buttonDown ) { + ((TQKeyEvent*)ee)->accept(); + return TRUE; + } + break; + default: + break; + } + return FALSE; +} + +void TQWidgetResizeHandler::mouseMoveEvent( TQMouseEvent *e ) +{ + TQPoint pos = widget->mapFromGlobal( e->globalPos() ); + if ( !moveResizeMode && ( !buttonDown || ( e->state() & Qt::LeftButton ) == 0 ) ) { + if ( pos.y() <= range && pos.x() <= range) + mode = TopLeft; + else if ( pos.y() >= widget->height()-range && pos.x() >= widget->width()-range) + mode = BottomRight; + else if ( pos.y() >= widget->height()-range && pos.x() <= range) + mode = BottomLeft; + else if ( pos.y() <= range && pos.x() >= widget->width()-range) + mode = TopRight; + else if ( pos.y() <= range ) + mode = Top; + else if ( pos.y() >= widget->height()-range ) + mode = Bottom; + else if ( pos.x() <= range ) + mode = Left; + else if ( pos.x() >= widget->width()-range ) + mode = Right; + else + mode = Center; + + if ( widget->isMinimized() || !isActive(Resize) ) + mode = Center; +#ifndef TQT_NO_CURSOR + setMouseCursor( mode ); +#endif + return; + } + + if ( buttonDown && !isMovingEnabled() && mode == Center && !moveResizeMode ) + return; + + if ( widget->testWState( TQt::WState_ConfigPending ) ) + return; + + TQPoint globalPos = widget->parentWidget( TRUE ) ? + widget->parentWidget( TRUE )->mapFromGlobal( e->globalPos() ) : e->globalPos(); + if ( widget->parentWidget( TRUE ) && !TQT_TQRECT_OBJECT(widget->parentWidget( TRUE )->rect()).tqcontains( globalPos ) ) { + if ( globalPos.x() < 0 ) + globalPos.rx() = 0; + if ( globalPos.y() < 0 ) + globalPos.ry() = 0; + if ( sizeprotect && globalPos.x() > widget->parentWidget()->width() ) + globalPos.rx() = widget->parentWidget()->width(); + if ( sizeprotect && globalPos.y() > widget->parentWidget()->height() ) + globalPos.ry() = widget->parentWidget()->height(); + } + + TQPoint p = globalPos + invertedMoveOffset; + TQPoint pp = globalPos - moveOffset; + + int fw = 0; + int mw = TQMAX( childWidget->tqminimumSizeHint().width(), + childWidget->minimumWidth() ); + int mh = TQMAX( childWidget->tqminimumSizeHint().height(), + childWidget->minimumHeight() ); + if ( childWidget != widget ) { + TQFrame *frame = ::tqqt_cast<TQFrame*>(widget); + if ( frame ) + fw = frame->frameWidth(); + mw += 2 * fw; + mh += 2 * fw + extrahei; + } + + TQSize mpsize( widget->tqgeometry().right() - pp.x() + 1, + widget->tqgeometry().bottom() - pp.y() + 1 ); + mpsize = mpsize.expandedTo( widget->tqminimumSize() ).expandedTo( TQSize(mw, mh) ); + TQPoint mp( widget->tqgeometry().right() - mpsize.width() + 1, + widget->tqgeometry().bottom() - mpsize.height() + 1 ); + + TQRect geom = widget->tqgeometry(); + + switch ( mode ) { + case TopLeft: + geom = TQRect( mp, widget->tqgeometry().bottomRight() ) ; + break; + case BottomRight: + geom = TQRect( widget->tqgeometry().topLeft(), p ) ; + break; + case BottomLeft: + geom = TQRect( TQPoint(mp.x(), widget->tqgeometry().y() ), TQPoint( widget->tqgeometry().right(), p.y()) ) ; + break; + case TopRight: + geom = TQRect( TQPoint( widget->tqgeometry().x(), mp.y() ), TQPoint( p.x(), widget->tqgeometry().bottom()) ) ; + break; + case Top: + geom = TQRect( TQPoint( widget->tqgeometry().left(), mp.y() ), widget->tqgeometry().bottomRight() ) ; + break; + case Bottom: + geom = TQRect( widget->tqgeometry().topLeft(), TQPoint( widget->tqgeometry().right(), p.y() ) ) ; + break; + case Left: + geom = TQRect( TQPoint( mp.x(), widget->tqgeometry().top() ), widget->tqgeometry().bottomRight() ) ; + break; + case Right: + geom = TQRect( widget->tqgeometry().topLeft(), TQPoint( p.x(), widget->tqgeometry().bottom() ) ) ; + break; + case Center: + if ( isMovingEnabled() || moveResizeMode ) + geom.moveTopLeft( pp ); + break; + default: + break; + } + + TQSize maxsize( childWidget->tqmaximumSize() ); + if ( childWidget != widget ) + maxsize += TQSize( 2 * fw, 2 * fw + extrahei ); + + geom = TQRect( geom.topLeft(), + geom.size().expandedTo( widget->tqminimumSize() ) + .expandedTo( TQSize(mw, mh) ) + .boundedTo( maxsize ) ); + + if ( geom != widget->tqgeometry() && + ( widget->isTopLevel() || widget->parentWidget()->rect().intersects( geom ) ) ) { + if ( widget->isMinimized() ) + widget->move( geom.topLeft() ); + else + widget->setGeometry( geom ); + } + +#if defined(TQ_WS_WIN) + MSG msg; + TQT_WA( { + while(PeekMessageW( &msg, widget->winId(), WM_MOUSEMOVE, WM_MOUSEMOVE, PM_REMOVE )) + ; + } , { + while(PeekMessageA( &msg, widget->winId(), WM_MOUSEMOVE, WM_MOUSEMOVE, PM_REMOVE )) + ; + } ); +#endif + + TQApplication::syncX(); +} + +void TQWidgetResizeHandler::setMouseCursor( MousePosition m ) +{ +#ifndef TQT_NO_CURSOR + switch ( m ) { + case TopLeft: + case BottomRight: + widget->setCursor( Qt::SizeFDiagCursor ); + break; + case BottomLeft: + case TopRight: + widget->setCursor( Qt::SizeBDiagCursor ); + break; + case Top: + case Bottom: + widget->setCursor( Qt::SizeVerCursor ); + break; + case Left: + case Right: + widget->setCursor( Qt::SizeHorCursor ); + break; + default: + widget->setCursor( Qt::ArrowCursor ); + break; + } +#endif +} + +void TQWidgetResizeHandler::keyPressEvent( TQKeyEvent * e ) +{ + if ( !isMove() && !isResize() ) + return; + bool is_control = e->state() & ControlButton; + int delta = is_control?1:8; + TQPoint pos = TQCursor::pos(); + switch ( e->key() ) { + case Qt::Key_Left: + pos.rx() -= delta; + if ( pos.x() <= TQT_TQWIDGET(TQApplication::desktop())->tqgeometry().left() ) { + if ( mode == TopLeft || mode == BottomLeft ) { + moveOffset.rx() += delta; + invertedMoveOffset.rx() += delta; + } else { + moveOffset.rx() -= delta; + invertedMoveOffset.rx() -= delta; + } + } + if ( isResize() && !resizeHorizontalDirectionFixed ) { + resizeHorizontalDirectionFixed = TRUE; + if ( mode == BottomRight ) + mode = BottomLeft; + else if ( mode == TopRight ) + mode = TopLeft; +#ifndef TQT_NO_CURSOR + setMouseCursor( mode ); + widget->grabMouse( widget->cursor() ); +#else + widget->grabMouse(); +#endif + } + break; + case Qt::Key_Right: + pos.rx() += delta; + if ( pos.x() >= TQT_TQWIDGET(TQApplication::desktop())->tqgeometry().right() ) { + if ( mode == TopRight || mode == BottomRight ) { + moveOffset.rx() += delta; + invertedMoveOffset.rx() += delta; + } else { + moveOffset.rx() -= delta; + invertedMoveOffset.rx() -= delta; + } + } + if ( isResize() && !resizeHorizontalDirectionFixed ) { + resizeHorizontalDirectionFixed = TRUE; + if ( mode == BottomLeft ) + mode = BottomRight; + else if ( mode == TopLeft ) + mode = TopRight; +#ifndef TQT_NO_CURSOR + setMouseCursor( mode ); + widget->grabMouse( widget->cursor() ); +#else + widget->grabMouse(); +#endif + } + break; + case Qt::Key_Up: + pos.ry() -= delta; + if ( pos.y() <= TQT_TQWIDGET(TQApplication::desktop())->tqgeometry().top() ) { + if ( mode == TopLeft || mode == TopRight ) { + moveOffset.ry() += delta; + invertedMoveOffset.ry() += delta; + } else { + moveOffset.ry() -= delta; + invertedMoveOffset.ry() -= delta; + } + } + if ( isResize() && !resizeVerticalDirectionFixed ) { + resizeVerticalDirectionFixed = TRUE; + if ( mode == BottomLeft ) + mode = TopLeft; + else if ( mode == BottomRight ) + mode = TopRight; +#ifndef TQT_NO_CURSOR + setMouseCursor( mode ); + widget->grabMouse( widget->cursor() ); +#else + widget->grabMouse(); +#endif + } + break; + case Qt::Key_Down: + pos.ry() += delta; + if ( pos.y() >= TQT_TQWIDGET(TQApplication::desktop())->tqgeometry().bottom() ) { + if ( mode == BottomLeft || mode == BottomRight ) { + moveOffset.ry() += delta; + invertedMoveOffset.ry() += delta; + } else { + moveOffset.ry() -= delta; + invertedMoveOffset.ry() -= delta; + } + } + if ( isResize() && !resizeVerticalDirectionFixed ) { + resizeVerticalDirectionFixed = TRUE; + if ( mode == TopLeft ) + mode = BottomLeft; + else if ( mode == TopRight ) + mode = BottomRight; +#ifndef TQT_NO_CURSOR + setMouseCursor( mode ); + widget->grabMouse( widget->cursor() ); +#else + widget->grabMouse(); +#endif + } + break; + case Qt::Key_Space: + case Qt::Key_Return: + case Qt::Key_Enter: + case Key_Escape: + moveResizeMode = FALSE; + widget->releaseMouse(); + widget->releaseKeyboard(); + buttonDown = FALSE; + break; + default: + return; + } + TQCursor::setPos( pos ); +} + + +void TQWidgetResizeHandler::doResize() +{ + if ( !activeForResize ) + return; + + moveResizeMode = TRUE; + buttonDown = TRUE; + moveOffset = widget->mapFromGlobal( TQCursor::pos() ); + if ( moveOffset.x() < widget->width()/2) { + if ( moveOffset.y() < widget->height()/2) + mode = TopLeft; + else + mode = BottomLeft; + } else { + if ( moveOffset.y() < widget->height()/2) + mode = TopRight; + else + mode = BottomRight; + } + invertedMoveOffset = widget->rect().bottomRight() - moveOffset; +#ifndef TQT_NO_CURSOR + setMouseCursor( mode ); + widget->grabMouse( widget->cursor() ); +#else + widget->grabMouse(); +#endif + widget->grabKeyboard(); + resizeHorizontalDirectionFixed = FALSE; + resizeVerticalDirectionFixed = FALSE; +} + +void TQWidgetResizeHandler::doMove() +{ + if ( !activeForMove ) + return; + + mode = Center; + moveResizeMode = TRUE; + buttonDown = TRUE; + moveOffset = widget->mapFromGlobal( TQCursor::pos() ); + invertedMoveOffset = widget->rect().bottomRight() - moveOffset; +#ifndef TQT_NO_CURSOR + widget->grabMouse( SizeAllCursor ); +#else + widget->grabMouse(); +#endif + widget->grabKeyboard(); +} + +#endif //TQT_NO_RESIZEHANDLER |