    /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    /*
     * This file is part of the LibreOffice project.
     *
     * This Source Code Form is subject to the terms of the Mozilla Public
     * License, v. 2.0. If a copy of the MPL was not distributed with this
     * file, You can obtain one at http://mozilla.org/MPL/2.0/.
     *
     * This file incorporates work covered by the following license notice:
     *
     *   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 .
     */

    #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                 L"hatchwin"

    typedef CHatchWin *PCHatchWin;

    winwrap::CWindow::CWindow(HINSTANCE hInst)
    {
        m_hInst=hInst;
        m_hWnd=nullptr;
        return;
    }

    winwrap::CWindow::~CWindow()
    {
        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()
    {
        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()
    {
        return m_hInst;
    }

    /*
     * 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)
    {
        WNDCLASSW    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         = nullptr;
        wc.hCursor       = LoadCursor(nullptr, IDC_ARROW);
        wc.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW+1);
        wc.lpszMenuName  = nullptr;
        wc.lpszClassName = SZCLASSHATCHWIN;

        return RegisterClassW(&wc);
    }

    /*
     * 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=nullptr;
        m_hWndKid=nullptr;
        m_hWndAssociate=nullptr;
        m_uID=0;

        m_dBorderOrg=GetProfileIntW(L"windows"
                                   , L"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()
    {
        /*
         * Chances are this was already destroyed when a document
         * was destroyed.
         */
        if (nullptr!=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             WORD 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, WORD uID, HWND hWndAssoc)
    {
        m_hWndParent = hWndParent;
        m_hWnd=CreateWindowExW(
            WS_EX_NOPARENTNOTIFY, SZCLASSHATCHWIN
            , SZCLASSHATCHWIN, WS_CHILD | WS_CLIPSIBLINGS
            | WS_CLIPCHILDREN, 0, 0, 100, 100, hWndParent
            , reinterpret_cast<HMENU>(UINT_PTR(uID)), m_hInst, this);

        m_uID=uID;
        m_hWndAssociate=hWndAssoc;

        return (nullptr!=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()
    {
        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, nullptr, 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 (nullptr!=hWndKid)
        {
            SetParent(hWndKid, m_hWnd);

            //Ensure 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=reinterpret_cast<PCHatchWin>(GetWindowLongPtrW(hWnd, HWWL_STRUCTURE));
        POINT ptMouse;

        switch (iMsg)
        {
            case WM_CREATE:
                phw=static_cast<PCHatchWin>(reinterpret_cast<LPCREATESTRUCT>(lParam)->lpCreateParams);
                SetWindowLongPtrW(hWnd, HWWL_STRUCTURE, reinterpret_cast<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 (nullptr!=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 (nullptr!=phw->m_hWndAssociate)
                {
                    SendMessageW(
                        phw->m_hWndAssociate, WM_COMMAND,
                        MAKEWPARAM(phw->m_uID, HWN_BORDERDOUBLECLICKED),
                        reinterpret_cast<LPARAM>(hWnd));
                }

                break;
            default:
                return DefWindowProcW(hWnd, iMsg, wParam, lParam);
        }

        return 0;
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V730 Not all members of a class are initialized inside the constructor. Consider inspecting: m_hWndParent.