INTEGRATION: CWS layoutmanager (1.1.2); FILE ADDED

2004/02/02 09:15:39 abi 1.1.2.3: with tracker
2003/11/20 12:54:52 abi 1.1.2.2: resizing of frame
2003/10/29 13:40:54 abi 1.1.2.1: new files for inplace activation

1 files changed, 501 insertions, 0 deletions

diff --git a/embedserv/source/embed/syswinwrapper.cxx b/embedserv/source/embed/syswinwrapper.cxx
new file mode 100644
index 000000000000..aeda3686e284
--- /dev/null
+++ b/embedserv/source/embed/syswinwrapper.cxx
@@ -0,0 +1,501 @@
+/*************************************************************************
+ *
+ *  $RCSfile: syswinwrapper.cxx,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: kz $ $Date: 2004-02-25 17:09:58 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include "docholder.hxx"
+#include "syswinwrapper.hxx"
+
+/*
+ * CWindow::CWindow
+ * CWindow::~CWindow
+ *
+ * Constructor Parameters:
+ *  hInst           HINSTANCE of the task owning us.
+ */
+
+
+using namespace winwrap;
+
+
+#define HWWL_STRUCTURE                  0
+
+//Notification codes for WM_COMMAND messages
+#define HWN_BORDERDOUBLECLICKED         1
+#define CBHATCHWNDEXTRA                 (sizeof(LONG))
+#define SZCLASSHATCHWIN                 TEXT("hatchwin")
+#define SendCommand(hWnd, wID, wCode, hControl)                     \
+            SendMessage(hWnd, WM_COMMAND, MAKEWPARAM(wID, wCode)    \
+                        , (LPARAM)hControl)
+
+
+typedef CHatchWin *PCHatchWin;
+
+
+void DrawShading(LPRECT prc, HDC hDC, UINT cWidth);
+
+
+
+winwrap::CWindow::CWindow(HINSTANCE hInst)
+{
+    m_hInst=hInst;
+    m_hWnd=NULL;
+    return;
+}
+
+winwrap::CWindow::~CWindow(void)
+{
+    if (IsWindow(m_hWnd))
+        DestroyWindow(m_hWnd);
+
+    return;
+}
+
+
+
+/*
+ * CWindow::Window
+ *
+ * Purpose:
+ *  Returns the window handle associated with this object.
+ *
+ * Return Value:
+ *  HWND            Window handle for this object
+ */
+
+HWND winwrap::CWindow::Window(void)
+{
+    return m_hWnd;
+}
+
+
+
+/*
+ * CWindow::Instance
+ *
+ * Purpose:
+ *  Returns the instance handle associated with this object.
+ *
+ * Return Value:
+ *  HINSTANCE       Instance handle of the module stored here.
+ */
+
+HINSTANCE winwrap::CWindow::Instance(void)
+{
+    return m_hInst;
+}
+
+
+
+
+
+//Hatch pattern brush bits
+static WORD g_wHatchBmp[]={0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88};
+
+// void DrawShading(LPRECT, HDC, UINT);
+
+
+/*
+ * HatchWindowRegister
+ *
+ * Purpose:
+ *  Registers the hatch window class for use with CHatchWin.
+ *
+ * Parameters:
+ *  hInst           HINSTANCE under which to register.
+ *
+ * Return Value:
+ *  BOOL            TRUE if successful, FALSE otherwise.
+ */
+
+BOOL winwrap::HatchWindowRegister(HINSTANCE hInst)
+{
+    WNDCLASS    wc;
+
+    //Must have CS_DBLCLKS for border!
+    wc.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
+    wc.hInstance     = hInst;
+    wc.cbClsExtra    = 0;
+    wc.lpfnWndProc   = HatchWndProc;
+    wc.cbWndExtra    = CBHATCHWNDEXTRA;
+    wc.hIcon         = NULL;
+    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
+    wc.lpszMenuName  = NULL;
+    wc.lpszClassName = SZCLASSHATCHWIN;
+
+    return RegisterClass(&wc);
+    return FALSE;
+}
+
+
+
+
+/*
+ * CHatchWin:CHatchWin
+ * CHatchWin::~CHatchWin
+ *
+ * Constructor Parameters:
+ *  hInst           HINSTANCE of the application we're in.
+ */
+
+CHatchWin::CHatchWin(HINSTANCE hInst,const DocumentHolder* pDocHolder)
+    : CWindow(hInst),
+      m_aTracker()
+{
+    m_hWnd=NULL;
+    m_hWndKid=NULL;
+    m_hWndAssociate=NULL;
+    m_uID=0;
+
+    m_dBorderOrg=GetProfileInt(TEXT("windows")
+                               , TEXT("OleInPlaceBorderWidth")
+                               , HATCHWIN_BORDERWIDTHDEFAULT);
+
+    m_dBorder=m_dBorderOrg;
+    SetRect(&m_rcPos, 0, 0, 0, 0);
+    SetRect(&m_rcClip, 0, 0, 0, 0);
+
+    m_pDocHolder = pDocHolder;
+    return;
+}
+
+
+CHatchWin::~CHatchWin(void)
+{
+    /*
+     * Chances are this was already destroyed when a document
+     * was destroyed.
+     */
+    if (NULL!=m_hWnd && IsWindow(m_hWnd))
+        DestroyWindow(m_hWnd);
+
+    return;
+}
+
+
+
+/*
+ * CHatchWin::Init
+ *
+ * Purpose:
+ *  Instantiates a hatch window within a given parent with a
+ *  default rectangle.  This is not initially visible.
+ *
+ * Parameters:
+ *  hWndParent      HWND of the parent of this window
+ *  uID             UINT identifier for this window (send in
+ *                  notifications to associate window).
+ *  hWndAssoc       HWND of the initial associate.
+ *
+ * Return Value:
+ *  BOOL            TRUE if the function succeeded, FALSE otherwise.
+ */
+
+BOOL CHatchWin::Init(HWND hWndParent, UINT uID, HWND hWndAssoc)
+{
+    m_hWndParent = hWndParent;
+    m_hWnd=CreateWindowEx(
+        WS_EX_NOPARENTNOTIFY, SZCLASSHATCHWIN
+        , SZCLASSHATCHWIN, WS_CHILD | WS_CLIPSIBLINGS
+        | WS_CLIPCHILDREN, 0, 0, 100, 100, hWndParent, (HMENU)uID
+        , m_hInst, this);
+
+    m_uID=uID;
+    m_hWndAssociate=hWndAssoc;
+
+    return (NULL!=m_hWnd);
+}
+
+
+void CHatchWin::SetTrans()
+{
+    HRGN hrgn = CreateRectRgn(0,0,0,0);
+    SetWindowRgn(m_hWnd,hrgn,true);
+}
+
+/*
+ * CHatchWin::HwndAssociateSet
+ * CHatchWin::HwndAssociateGet
+ *
+ * Purpose:
+ *  Sets (Set) or retrieves (Get) the associate window of the
+ *  hatch window.
+ *
+ * Parameters: (Set only)
+ *  hWndAssoc       HWND to set as the associate.
+ *
+ * Return Value:
+ *  HWND            Previous (Set) or current (Get) associate
+ *                  window.
+ */
+
+HWND CHatchWin::HwndAssociateSet(HWND hWndAssoc)
+{
+    HWND    hWndT=m_hWndAssociate;
+
+    m_hWndAssociate=hWndAssoc;
+    return hWndT;
+}
+
+
+HWND CHatchWin::HwndAssociateGet(void)
+{
+    return m_hWndAssociate;
+}
+
+
+/*
+ * CHatchWin::RectsSet
+ *
+ * Purpose:
+ *  Changes the size and position of the hatch window and the child
+ *  window within it using a position rectangle for the child and
+ *  a clipping rectangle for the hatch window and child.  The hatch
+ *  window occupies prcPos expanded by the hatch border and clipped
+ *  by prcClip.  The child window is fit to prcPos to give the
+ *  proper scaling, but it clipped to the hatch window which
+ *  therefore clips it to prcClip without affecting the scaling.
+ *
+ * Parameters:
+ *  prcPos          LPRECT providing the position rectangle.
+ *  prcClip         LPRECT providing the clipping rectangle.
+ *
+ * Return Value:
+ *  None
+ */
+
+void CHatchWin::RectsSet(LPRECT prcPos, LPRECT prcClip)
+{
+    RECT    rc;
+    RECT    rcPos;
+
+    m_rcPos=*prcPos;
+    m_rcClip=*prcClip;
+
+    //Calculate the rectangle for the hatch window, then clip it.
+    rcPos=*prcPos;
+    InflateRect(&rcPos, m_dBorder, m_dBorder);
+    IntersectRect(&rc, &rcPos, prcClip);
+
+    SetWindowPos(m_hWnd, NULL, rc.left, rc.top, rc.right-rc.left
+                 , rc.bottom-rc.top, SWP_NOZORDER | SWP_NOACTIVATE);
+
+    /*
+     * Set the rectangle of the child window to be at m_dBorder
+     * from the top and left but with the same size as prcPos
+     * contains.  The hatch window will clip it.
+     */
+//     SetWindowPos(m_hWndKid, NULL, rcPos.left-rc.left+m_dBorder
+//                  , rcPos.top-rc.top+m_dBorder, prcPos->right-prcPos->left
+//                  , prcPos->bottom-prcPos->top, SWP_NOZORDER | SWP_NOACTIVATE);
+
+    RECT newRC;
+    GetClientRect(m_hWnd,&newRC);
+    m_aTracker = Tracker(
+        &newRC,
+        Tracker::hatchInside |
+        Tracker::hatchedBorder |
+        Tracker::resizeInside
+    );
+
+    return;
+}
+
+
+
+/*
+ * CHatchWin::ChildSet
+ *
+ * Purpose:
+ *  Assigns a child window to this hatch window.
+ *
+ * Parameters:
+ *  hWndKid         HWND of the child window.
+ *
+ * Return Value:
+ *  None
+ */
+
+void CHatchWin::ChildSet(HWND hWndKid)
+{
+    m_hWndKid=hWndKid;
+
+    if (NULL!=hWndKid)
+    {
+        SetParent(hWndKid, m_hWnd);
+
+        //Insure this is visible when the hatch window becomes visible.
+        ShowWindow(hWndKid, SW_SHOW);
+    }
+
+    return;
+}
+
+
+
+/*
+ * CHatchWin::ShowHatch
+ *
+ * Purpose:
+ *  Turns hatching on and off; turning the hatching off changes
+ *  the size of the window to be exactly that of the child, leaving
+ *  everything else the same.  The result is that we don't have
+ *  to turn off drawing because our own WM_PAINT will never be
+ *  called.
+ *
+ * Parameters:
+ *  fHatch          BOOL indicating to show (TRUE) or hide (FALSE)
+                    the hatching.
+ *
+ * Return Value:
+ *  None
+ */
+
+void CHatchWin::ShowHatch(BOOL fHatch)
+{
+    /*
+     * All we have to do is set the border to zero and
+     * call SetRects again with the last rectangles the
+     * child sent to us.
+     */
+    m_dBorder=fHatch ? m_dBorderOrg : 0;
+    RectsSet(&m_rcPos, &m_rcClip);
+    return;
+}
+
+
+
+/*
+ * HatchWndProc
+ *
+ * Purpose:
+ *  Standard window procedure for the Hatch Window
+ */
+
+LRESULT APIENTRY winwrap::HatchWndProc(
+    HWND hWnd, UINT iMsg
+    , WPARAM wParam, LPARAM lParam)
+{
+    PCHatchWin  phw;
+    HDC         hDC;
+    PAINTSTRUCT ps;
+
+    phw=(PCHatchWin)GetWindowLong(hWnd, HWWL_STRUCTURE);
+    POINT ptMouse;
+
+    switch (iMsg)
+    {
+        case WM_CREATE:
+            phw=(PCHatchWin)((LPCREATESTRUCT)lParam)->lpCreateParams;
+            SetWindowLong(hWnd, HWWL_STRUCTURE, (LONG)phw);
+            break;
+        case WM_PAINT:
+            hDC=BeginPaint(hWnd,&ps);
+            //Always draw the hatching.
+            phw->m_aTracker.Draw(hDC);
+            EndPaint(hWnd,&ps);
+            break;
+        case WM_LBUTTONDOWN:
+            GetCursorPos(&ptMouse);
+            ScreenToClient(hWnd,&ptMouse);
+
+            // track in case we have to
+            if(phw->m_aTracker.Track(hWnd,ptMouse,FALSE,GetParent(hWnd)))
+            {
+                RECT aRect = phw->m_aTracker.m_rect;
+                TransformRect(&aRect,hWnd,GetParent(hWnd));
+                phw->m_pDocHolder->OnPosRectChanged(&aRect);
+            }
+            break;
+        case WM_LBUTTONUP:
+        case WM_MOUSEMOVE:
+            GetCursorPos(&ptMouse);
+            ScreenToClient(hWnd,&ptMouse);
+            phw->m_aTracker.SetCursor(hWnd,HTCLIENT);
+            break;
+        case WM_SETFOCUS:
+            //We need this since the container will SetFocus to us.
+            if (NULL!=phw->m_hWndKid)
+                SetFocus(phw->m_hWndKid);
+
+            break;
+        case WM_LBUTTONDBLCLK:
+            /*
+             * If the double click was within m_dBorder of an
+             * edge, send the HWN_BORDERDOUBLECLICKED notification.
+             *
+             * Because we're always sized just larger than our child
+             * window by the border width, we can only *get* this
+             * message when the mouse is on the border.  So we can
+             * just send the notification.
+             */
+            if (NULL!=phw->m_hWndAssociate)
+            {
+                SendCommand(phw->m_hWndAssociate, phw->m_uID
+                            , HWN_BORDERDOUBLECLICKED, hWnd);
+            }
+
+            break;
+        default:
+            return DefWindowProc(hWnd, iMsg, wParam, lParam);
+    }
+
+    return 0L;
+}