| /************************************************************** | |
| * | |
| * 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_PTR)) | |
| #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)GetWindowLongPtr(hWnd, HWWL_STRUCTURE); | |
| POINT ptMouse; | |
| switch (iMsg) | |
| { | |
| case WM_CREATE: | |
| phw=(PCHatchWin)((LPCREATESTRUCT)lParam)->lpCreateParams; | |
| SetWindowLongPtr(hWnd, HWWL_STRUCTURE, (LONG_PTR)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 |