| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| #if defined(_MSC_VER) && (_MSC_VER > 1310) |
| #pragma warning(disable : 4917 4555) |
| #endif |
| |
| #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; |
| } |
| |
| // Fix strange warnings about some |
| // ATL::CAxHostWindow::QueryInterface|AddRef|Releae functions. |
| // warning C4505: 'xxx' : unreferenced local function has been removed |
| #if defined(_MSC_VER) |
| #pragma warning(disable: 4505) |
| #endif |
