source: trunk/src/gui/kernel/qwidget_pm.cpp@ 603

/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** Copyright (C) 2009 netlabs.org. OS/2 parts.
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qt_os2.h"

#include "qdebug.h"

#include "qwidget.h"
#include "qwidget_p.h"

#include "qapplication.h"
#include "qdesktopwidget.h"
#include "qevent.h"

#include "private/qapplication_p.h"
#include "private/qbackingstore_p.h"
#include "private/qwindowsurface_raster_p.h"

//#define QT_DEBUGWINCREATEDESTROY
//#define QT_DEBUGWIDGETMASK

QT_BEGIN_NAMESPACE

static QWidget *mouseGrb    = 0;
static QCursor *mouseGrbCur = 0;
static QWidget *keyboardGrb = 0;

// defined in qapplication_pm.cpp
extern bool qt_nograb();
extern MRESULT EXPENTRY QtWndProc(HWND, ULONG, MPARAM, MPARAM);
extern PFNWP QtOldFrameProc;
extern MRESULT EXPENTRY QtFrameProc(HWND, ULONG, MPARAM, MPARAM);
extern PFNWP QtOldFrameCtlProcs[FID_HORZSCROLL - FID_SYSMENU + 1];
extern MRESULT EXPENTRY QtFrameCtlProc(HWND, ULONG, MPARAM, MPARAM);

#if !defined(QT_NO_SESSIONMANAGER)
bool qt_about_to_destroy_wnd = false;
#endif

typedef QSet<QString> WinClassNameHash;
Q_GLOBAL_STATIC(WinClassNameHash, winclassNames)

// register window class
static const QString qt_reg_winclass(QWidget *w)
{
    int flags = w->windowFlags();
    int type = flags & Qt::WindowType_Mask;

    QString cname;
    ULONG style = 0;

    if (type == Qt::Popup || type == Qt::ToolTip) {
        cname = QLatin1String("QPopup");
        style |= CS_SAVEBITS;
    } else if (w->isWindow()) {
        // this class is for top level widgets which are client HWNDs of a
        // WC_FRAME parent HWND internally maintaned for them
        cname = QLatin1String("QWindow");
    } else {
        cname = QLatin1String("QWidget");
    }

    if (winclassNames()->contains(cname)) // already registered in our list
        return cname;

    // QT_EXTRAWINDATASIZE is defined in qwindowdefs_pm.h
    WinRegisterClass(0, cname.toLatin1(), QtWndProc, style, QT_EXTRAWINDATASIZE);

    winclassNames()->insert(cname);
    return cname;

    // Note: there is no need to unregister private window classes registered by
    // this function -- it is done automatically upon process termination.
}

/*!
    \internal

    Extended version of WinQueryClipRegion(). If the given window has a clip
    region, the given region will receive a copy of the clip region clipped to
    the current window rectangle. If there is no clip region, the given region
    will contain only the window rectangle on return.
 */
void qt_WinQueryClipRegionOrRect(HWND hwnd, HRGN hrgn)
{
    RECTL rcl;
    WinQueryWindowRect(hwnd, &rcl);

    HPS hps = qt_display_ps();
    GpiSetRegion(hps, hrgn, 1, &rcl);
    if (WinQueryClipRegion(hwnd, 0) != QCRGN_NO_CLIP_REGION) {
        HRGN hrgnTemp = GpiCreateRegion(hps, 0, NULL);
        WinQueryClipRegion(hwnd, hrgnTemp);
        GpiCombineRegion(hps, hrgn, hrgnTemp, hrgn, CRGN_AND);
        GpiDestroyRegion(hps, hrgnTemp);
    }
}

/*!
    \internal

    Extended version of WinInvalidateRegion(): invalidates the specified region
    of the given window and regions of children from \a hwndFrom to \a hwndTo
    if they intersect with the invalid region. If either of child window
    handles is NULLHANDLE, children are not invalidated at all. Also, HWND_TOP
    can be used as \a hwndFrom, HWND_BOTTOM \a can be used as \a hwndTo.
 */
static BOOL qt_WinInvalidateRegionEx(HWND hwnd, HRGN hrgn,
                                     HWND hwndFrom, HWND hwndTo)
{
#if defined(QT_DEBUGWIDGETMASK)
    qDebug("qt_WinInvalidateRegionEx: hwnd=%s hwndFrom=%08lX hwndTo=%08lX",
           qStrHWND(hwnd).toUtf8().constData(), hwndFrom, hwndTo);
#endif

    if (hwndFrom == HWND_TOP)
        hwndFrom = WinQueryWindow(hwnd, QW_TOP);
    if (hwndTo == HWND_BOTTOM)
        hwndTo = WinQueryWindow(hwnd, QW_BOTTOM);

    if (hwndFrom == 0 || hwndTo == 0)
        return WinInvalidateRegion(hwnd, hrgn, FALSE);

    if (WinQueryWindow(hwndFrom, QW_PARENT) != hwnd ||
        WinQueryWindow(hwndTo, QW_PARENT) != hwnd)
        return FALSE;

    HPS hps = qt_display_ps();

    SWP swp;
    HWND child = hwndFrom;
    HRGN hrgnChild = GpiCreateRegion(hps, 0, NULL);
    HRGN hrgnInv = GpiCreateRegion(hps, 0, NULL);
    GpiCombineRegion(hps, hrgnInv, hrgn, 0, CRGN_COPY);

    LONG cmplx = RGN_RECT;

    while (child) {
        WinQueryWindowPos(child, &swp);
#if defined(QT_DEBUGWIDGETMASK)
        qDebug(" child=%s [fl=%08lX]", qStrHWND(child).toUtf8().constData(),
               swp.fl);
#endif
        // proceed only if not hidden
        if (swp.fl & SWP_SHOW) {
            // get sibling's bounds (clip region or rect)
            qt_WinQueryClipRegionOrRect(child, hrgnChild);
            // translate the region to the parent's coordinate system
            POINTL ptl = { swp.x, swp.y };
            GpiOffsetRegion(hps, hrgnChild, &ptl);
            // intersect the child's region with the invalid one
            // and invalidate if not NULL
            cmplx = GpiCombineRegion(hps, hrgnChild, hrgnChild, hrgnInv,
                                      CRGN_AND);
            if (cmplx != RGN_NULL) {
                POINTL ptl2 = { -swp.x, -swp.y };
                GpiOffsetRegion(hps, hrgnChild, &ptl2);
                WinInvalidateRegion(child, hrgnChild, TRUE);
                GpiOffsetRegion(hps, hrgnChild, &ptl);
                // substract the invalidated area from the widget's region
                // (no need to invalidate it any more)
                cmplx = GpiCombineRegion(hps, hrgnInv, hrgnInv, hrgnChild,
                                          CRGN_DIFF);
#if defined(QT_DEBUGWIDGETMASK)
                qDebug("  processed");
#endif
                // finish if nothing left
                if (cmplx == RGN_NULL)
                    break;
            }
        }
        // iterate to the next window (below)
        if (child == hwndTo)
            break;
        child = WinQueryWindow(child, QW_NEXT);
    }

    BOOL ok = (cmplx == RGN_NULL) || (child == hwndTo);

    if (ok) {
        // invalidate what's left invalid after substracting children
        WinInvalidateRegion(hwnd, hrgnInv, FALSE);
    }

    GpiDestroyRegion(hps, hrgnInv);
    GpiDestroyRegion(hps, hrgnChild);

    return ok;
}

/** \internal flags for qt_WinProcessWindowObstacles() */
enum {
    PWO_Children = 0x01,
    PWO_Sibings = 0x02,
    PWO_Ancestors = 0x04,
    PWO_Screen = 0x08,
    PWO_TopLevel = 0x80000000,
    // PWO_Default is suitable in most cases (for simple paint operations)