mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

INTEGRATION: CWS layoutmanager (1.1.2); FILE ADDED

Browse Source 
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
This commit is contained in:
Kurt Zenker
2004-02-25 16:09:58 +00:00
parent b517516353
commit 3e8e69e54e
1 changed files with 501 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

501
embedserv/source/embed/syswinwrapper.cxx Normal file
View File

@@ -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;
}