C4GuiContainers.cpp

Go to the documentation of this file.

/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2009-2016, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
// generic user interface
// grouping elements and control base classes
 
#include "C4Include.h"
#include "gui/C4Gui.h"
 
#include "graphics/C4Draw.h"
#include "graphics/C4GraphicsResource.h"
#include "gui/C4MouseControl.h"
 
namespace C4GUI
{
 
// --------------------------------------------------
// Container
 
    void Container::Draw(C4TargetFacet &cgo)
    {
        // self visible?
        if (!IsVisible()) return;
        // then draw all visible child elements
        for (Element *pEl = pFirst; pEl; pEl = pEl->pNext)
            if (pEl->fVisible)
            {
                // skip viewport dialogs
                if (!pEl->IsExternalDrawDialog())
                {
                    if (pEl->GetDialogWindow())
                        pEl->GetDialogWindow()->RequestUpdate();
                    else
                        pEl->Draw(cgo);
                }
            }
    }
 
    Container::Container() : Element()
    {
        // zero fields
        pFirst = pLast = nullptr;
    }
 
    Container::~Container()
    {
        // empty
        Clear();
    }
 
    void Container::Clear()
    {
        ClearChildren();
    }
 
    void Container::ClearChildren()
    {
        // delete all items; dtor will update list
        while (pFirst)
        {
            if (pFirst->IsOwnPtrElement())
            {
                // unlink from list
                Element *pANext = pFirst->pNext;
                pFirst->pPrev = pFirst->pNext = nullptr;
                pFirst->pParent = nullptr;
                if ((pFirst = pANext))
                    pFirst->pPrev = nullptr;
                else
                    pLast = nullptr;
            }
            else
                delete pFirst;
        }
    }
 
    void Container::RemoveElement(Element *pChild)
    {
        // safety
        if (!pChild) return;
        // inherited
        Element::RemoveElement(pChild);
        // must be from same container
        if (pChild->pParent != this) return;
        // unlink from list
        if (pChild->pPrev) pChild->pPrev->pNext = pChild->pNext; else pFirst = pChild->pNext;
        if (pChild->pNext) pChild->pNext->pPrev = pChild->pPrev; else pLast = pChild->pPrev;
        // unset parent; invalidates pPrev/pNext
        pChild->pParent = nullptr;
        // element has been removed
        AfterElementRemoval();
    }
 
    void Container::MakeLastElement(Element *pChild)
    {
        // must be from same container
        if (pChild->pParent != this) return;
        // unlink from list
        if (pChild->pPrev) pChild->pPrev->pNext = pChild->pNext; else pFirst = pChild->pNext;
        if (pChild->pNext) pChild->pNext->pPrev = pChild->pPrev; else pLast = pChild->pPrev;
        // readd to front of list
        if (pLast) pLast->pNext = pChild; else pFirst = pChild;
        pChild->pPrev = pLast; pChild->pNext = nullptr; pLast = pChild;
    }
 
    void Container::AddElement(Element *pChild)
    {
        // safety
        if (!pChild) return;
        // remove from any previous container
        if (pChild->pParent) pChild->pParent->RemoveElement(pChild);
        // add to end of list
        if (pLast) pLast->pNext = pChild; else pFirst = pChild;
        pChild->pPrev = pLast; pChild->pNext = nullptr; pLast = pChild;
        pChild->pParent = this;
 
        assert(pChild->pNext != pChild);
        assert(pChild->pPrev != pChild);
        assert(pChild->pParent != pChild);
    }
 
    void Container::ReaddElement(Element *pChild)
    {
        // safety
        if (!pChild || pChild->pParent != this) return;
        // remove from any previous container
        if (pChild->pPrev) pChild->pPrev->pNext = pChild->pNext; else pFirst = pChild->pNext;
        if (pChild->pNext) pChild->pNext->pPrev = pChild->pPrev; else pLast = pChild->pPrev;
        // add to end of list
        if (pLast) pLast->pNext = pChild; else pFirst = pChild;
        pChild->pPrev = pLast; pChild->pNext = nullptr; pLast = pChild;
 
        assert(pChild->pNext != pChild);
        assert(pChild->pPrev != pChild);
        assert(pChild->pParent != pChild);
    }
 
    void Container::InsertElement(Element *pChild, Element *pInsertBefore)
    {
        // add?
        if (!pInsertBefore) { AddElement(pChild); return; }
        // safety
        if (!pChild || pInsertBefore->pParent != this) return;
        // remove from any previous container
        if (pChild->pParent) pChild->pParent->RemoveElement(pChild);
        // add before given element
        if ((pChild->pPrev = pInsertBefore->pPrev))
            pInsertBefore->pPrev->pNext = pChild;
        else
            pFirst = pChild;
        pChild->pNext = pInsertBefore; pInsertBefore->pPrev = pChild;
        pChild->pParent = this;
 
        assert(pChild->pNext != pChild);
        assert(pChild->pPrev != pChild);
        assert(pChild->pParent != pChild);
    }
 
    Element *Container::GetNextNestedElement(Element *pPrevElement, bool fBackwards)
    {
        if (fBackwards)
        {
            // this is last
            if (pPrevElement == this) return nullptr;
            // no previous given?
            if (!pPrevElement)
                // then use last nested for backwards search
                return GetFirstNestedElement(true);
            // get nested, previous element if present
            if (pPrevElement->pPrev) return pPrevElement->pPrev->GetFirstNestedElement(true);
            // if not, return parent (could be this)
            return pPrevElement->pParent;
        }
        else
        {
            // forward search: first element is this
            if (!pPrevElement) return this;
            // check next nested
            Element *pEl;
            if ((pEl = pPrevElement->GetFirstContained())) return pEl;
            // check next in list, going upwards until this container is reached
            while (pPrevElement && pPrevElement != this)
            {
                if ((pEl = pPrevElement->pNext)) return pEl;
                pPrevElement = pPrevElement->pParent;
            }
            // nothing found
        }
        return nullptr;
    }
 
    Element *Container::GetFirstNestedElement(bool fBackwards)
    {
        // get first/last in own list
        if (pFirst) return (fBackwards ? pLast : pFirst)->GetFirstNestedElement(fBackwards);
        // no own list: return this one
        return this;
    }
 
    bool Container::OnHotkey(uint32_t cHotkey)
    {
        if (!IsVisible()) return false;
        // check all nested elements
        for (Element *pEl = pFirst; pEl; pEl=pEl->pNext)
            if (pEl->fVisible)
                if (pEl->OnHotkey(cHotkey)) return true;
        // no match found
        return false;
    }
 
    Element *Container::GetElementByIndex(int32_t i)
    {
        // get next until end of list or queried index is reached
        // if i is negative or equal or larger than childcount, the loop will never break and nullptr returned
        Element *pEl;
        for (pEl = pFirst; i-- && pEl; pEl=pEl->pNext) {}
        return pEl;
    }
 
    int32_t Container::GetElementCount()
    {
        int32_t cnt=0;
        for (Element *pEl = pFirst; pEl; pEl=pEl->pNext) ++cnt;
        return cnt;
    }
 
    bool Container::IsParentOf(Element *pEl)
    {
        // return whether this is the parent container (directly or recursively) of the passed element
        for (Container *pC = pEl->GetParent(); pC; pC = pC->GetParent())
            if (pC == this) return true;
        return false;
    }
 
    void Container::SetVisibility(bool fToValue)
    {
        // inherited
        Element::SetVisibility(fToValue);
        // remove focus from contained elements
        if (!fToValue)
        {
            Dialog *pDlg = GetDlg();
            if (pDlg)
            {
                Control *pFocus = pDlg->GetFocus();
                if (pFocus)
                {
                    if (IsParentOf(pFocus))
                    {
                        pDlg->SetFocus(nullptr, false);
                    }
                }
            }
        }
    }
 
 
// --------------------------------------------------
// Window
 
    void Window::MouseInput(CMouse &rMouse, int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyParam)
    {
        // invisible?
        if (!IsVisible()) return;
        // inherited
        Container::MouseInput(rMouse, iButton, iX, iY, dwKeyParam);
        // get client pos
        C4Rect &rcClientRect = GetClientRect(), &rcBounds = GetBounds();
        iX -= rcClientRect.x - rcBounds.x; iY -= rcClientRect.y - rcBounds.y;
        // forward to topmost child element
        for (Element *pChild = pLast; pChild; pChild = pChild->GetPrev())
            if (pChild->fVisible && pChild->GetBounds().Contains(iX, iY))
            {
                // forward
                pChild->MouseInput(rMouse, iButton, iX - pChild->GetBounds().x, iY - pChild->GetBounds().y, dwKeyParam);
                // forward to one control only
                break;
            }
    }
 
    void Window::Draw(C4TargetFacet &cgo)
    {
        // invisible?
        if (!IsVisible()) return;
        // draw window itself
        DrawElement(cgo);
        // get target area
        C4Rect &rcClientRect = GetClientRect();
        C4Rect &rcClipArea = (IsComponentOutsideClientArea() ? GetBounds() : GetClientRect());
        // clip to window area
        int clx1, cly1, clx2, cly2;
        pDraw->GetPrimaryClipper(clx1, cly1, clx2, cly2);
        float nclx1 = cgo.TargetX+rcClipArea.x, ncly1 = cgo.TargetY+rcClipArea.y, nclx2 = cgo.TargetX+rcClipArea.x+rcClipArea.Wdt-1, ncly2 = cgo.TargetY+rcClipArea.y+rcClipArea.Hgt-1;
        pDraw->ApplyZoom(nclx1, ncly1);
        pDraw->ApplyZoom(nclx2, ncly2);
        pDraw->SubPrimaryClipper(nclx1, ncly1, nclx2, ncly2);
        // update target area
        cgo.TargetX += rcClientRect.x; cgo.TargetY += rcClientRect.y;
        // draw contents
        Container::Draw(cgo);
        // reset target area
        cgo.TargetX -= rcClientRect.x; cgo.TargetY -= rcClientRect.y;
        // reset clipper
        pDraw->SetPrimaryClipper(clx1, cly1, clx2, cly2);
    }
 
    Window::Window() : Container()
    {
        UpdateOwnPos();
    }
 
    void Window::UpdateOwnPos()
    {
        Container::UpdateOwnPos();
        // set client rect
        int32_t iMarginL=GetMarginLeft(), iMarginT=GetMarginTop();
        rcClientRect.Set(rcBounds.x + iMarginL, rcBounds.y + iMarginT, std::max<int32_t>(rcBounds.Wdt - iMarginL - GetMarginRight(), 0), std::max<int32_t>(rcBounds.Hgt - iMarginT - GetMarginBottom(), 0));
    }
 
 
// --------------------------------------------------
// ScrollBar
 
    ScrollBar::ScrollBar(C4Rect &rcBounds, ScrollWindow *pWin) : fAutoHide(false), fHorizontal(false), iCBMaxRange(100), pScrollCallback(nullptr), pCustomGfx(nullptr)
    {
        // set bounds
        this->rcBounds = rcBounds;
        // set initial values
        pScrollWindow = pWin;
        fScrolling = false;
        iScrollThumbSize = C4GUI_ScrollThumbHgt; // vertical
        iScrollPos = 0;
        fTopDown = fBottomDown = false;
        // update scroll bar pos
        Update();
    }
 
    ScrollBar::ScrollBar(C4Rect &rcBounds, bool fHorizontal, BaseParCallbackHandler<int32_t> *pCB, int32_t iCBMaxRange) : fAutoHide(false), fHorizontal(fHorizontal), iCBMaxRange(iCBMaxRange), pScrollWindow(nullptr), pCustomGfx(nullptr)
    {
        // set bounds
        this->rcBounds = rcBounds;
        // set initial values
        if ((pScrollCallback = pCB)) pScrollCallback->Ref();
        fScrolling = true;
        iScrollThumbSize = fHorizontal ? C4GUI_ScrollThumbWdt : C4GUI_ScrollThumbHgt;
        iScrollPos = 0;
        fTopDown = fBottomDown = false;
    }
 
    ScrollBar::~ScrollBar()
    {
        if (pScrollWindow) { pScrollWindow->pScrollBar = nullptr; }
        if (pScrollCallback) pScrollCallback->DeRef();
    }
 
    void ScrollBar::Update()
    {
        // check associated control
        if (pScrollWindow)
        {
            int32_t iVisHgt = pScrollWindow->GetBounds().Hgt;
            int32_t iClientHgt = pScrollWindow->GetClientRect().Hgt;
            if ((fScrolling = (iVisHgt < iClientHgt)))
            {
                // scrolling necessary
                // get vertical scroll pos
                int32_t iMaxWinScroll = iClientHgt - iVisHgt;
                int32_t iMaxBarScroll = GetBounds().Hgt - 2*C4GUI_ScrollArrowHgt - iScrollThumbSize;
                int32_t iWinScroll = pScrollWindow->iScrollY;
                // scroll thumb height is currently hardcoded
                // calc scroll pos
                iScrollPos = Clamp<int32_t>(iMaxBarScroll * iWinScroll / iMaxWinScroll, 0, iMaxBarScroll);
            }
        }
        else fScrolling = !!pScrollCallback;
        // reset buttons
        if (!fScrolling)
            fTopDown = fBottomDown = false;
        // set visibility by scroll status
        if (fAutoHide) SetVisibility(fScrolling);
    }
 
    void ScrollBar::OnPosChanged()
    {
        int32_t iMaxBarScroll = GetMaxScroll();
        if (!iMaxBarScroll) iMaxBarScroll=1;
        // CB - passes scroll pos
        if (pScrollCallback) pScrollCallback->DoCall(Clamp<int32_t>(iScrollPos * (iCBMaxRange-1) / iMaxBarScroll, 0, (iCBMaxRange-1)));
        // safety
        if (!pScrollWindow || !fScrolling) return;
        // get scrolling values
        assert(!fHorizontal); // nyi
        int32_t iVisHgt = pScrollWindow->GetBounds().Hgt;
        int32_t iClientHgt = pScrollWindow->GetClientRect().Hgt;
        int32_t iMaxWinScroll = iClientHgt - iVisHgt;
        int32_t iWinScroll = pScrollWindow->iScrollY;
        // calc new window scrolling
        int32_t iNewWinScroll = Clamp<int32_t>(iMaxWinScroll * iScrollPos / iMaxBarScroll, 0, iMaxWinScroll);
        // apply it, if it is different
        if (iWinScroll != iNewWinScroll)
            pScrollWindow->SetScroll(iNewWinScroll);
    }
 
    void ScrollBar::MouseInput(CMouse &rMouse, int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyParam)
    {
        // inherited
        Element::MouseInput(rMouse, iButton, iX, iY, dwKeyParam);
        // not if scrolling is disabled
        if (!fScrolling) return;
        // reset arrow states
        bool fPrevDown = fTopDown || fBottomDown;
        fTopDown = fBottomDown = false;
        // not if dragging
        if (rMouse.pDragElement) return;
        // left mouse button down?
        if (rMouse.IsLDown())
            // non-scroll-direction area check
            if (fHorizontal ? Inside<int32_t>(iY, 0, C4GUI_ScrollBarHgt) : Inside<int32_t>(iX, 0, C4GUI_ScrollBarWdt))
            {
                // scroll-direction area check: up/left arrow
                if (fHorizontal ? Inside<int32_t>(iX, 0, C4GUI_ScrollArrowWdt-1) : Inside<int32_t>(iY, 0, C4GUI_ScrollArrowHgt-1))
                    fTopDown = true;
                // check down arrow
                else if (fHorizontal ? Inside<int32_t>(iX, GetBounds().Wdt-C4GUI_ScrollArrowWdt, GetBounds().Wdt-1)
                         : Inside<int32_t>(iY, GetBounds().Hgt-C4GUI_ScrollArrowHgt, GetBounds().Hgt-1))
                    fBottomDown = true;
                else if (HasPin() && (fHorizontal ? Inside<int32_t>(iX, C4GUI_ScrollArrowWdt, GetBounds().Wdt-C4GUI_ScrollArrowWdt-1)
                                      : Inside<int32_t>(iY, C4GUI_ScrollArrowHgt, GetBounds().Hgt-C4GUI_ScrollArrowHgt-1)))
                {
                    // move thumb here
                    iScrollPos = GetScrollByPos(iX, iY);
                    // reflect movement in associated window or do CB
                    OnPosChanged();
                    // start dragging
                    rMouse.pDragElement = this;
                    GUISound("UI::Select");
                }
            }
        // sound effekt when buttons are pressed
        if ((fTopDown || fBottomDown) != fPrevDown) GUISound("UI::Tick");
    }
 
    void ScrollBar::DoDragging(CMouse &rMouse, int32_t iX, int32_t iY, DWORD dwKeyParam)
    {
        // move thumb
        iScrollPos = GetScrollByPos(iX, iY);
        // reflect movement in associated window
        OnPosChanged();
    }
 
    void ScrollBar::MouseLeave(CMouse &rMouse)
    {
        // inherited
        Element::MouseLeave(rMouse);
        // reset button states
        fTopDown = fBottomDown = false;
    }
 
    void ScrollBar::DrawElement(C4TargetFacet &cgo)
    {
        // do scrolling
        // not quite perfect; but there's no OnIdle, and it's be a bit of overkill starting a timer
        if (fTopDown && fScrolling && iScrollPos>0)
            { --iScrollPos; OnPosChanged(); }
        if (fBottomDown && fScrolling)
        {
            if (iScrollPos < GetMaxScroll()) { ++iScrollPos; OnPosChanged(); }
        }
        // draw bar
        ScrollBarFacets &rUseGfx = pCustomGfx ? *pCustomGfx : ::GraphicsResource.sfctScroll;
        DynBarFacet bar = rUseGfx.barScroll;
        if (fTopDown) bar.fctBegin = rUseGfx.fctScrollDTop;
        if (fBottomDown) bar.fctEnd = rUseGfx.fctScrollDBottom;
        if (fHorizontal)
            DrawHBarByVGfx(cgo, bar);
        else
            DrawVBar(cgo, bar);
        // draw scroll pin
        if (fScrolling && HasPin())
        {
            if (fHorizontal)
                rUseGfx.fctScrollPin.Draw(cgo.Surface, cgo.TargetX+rcBounds.x+C4GUI_ScrollArrowWdt+iScrollPos, cgo.TargetY+rcBounds.y);
            else
                rUseGfx.fctScrollPin.Draw(cgo.Surface, cgo.TargetX+rcBounds.x, cgo.TargetY+rcBounds.y+C4GUI_ScrollArrowHgt+iScrollPos);
        }
    }
 
 
// --------------------------------------------------
// ScrollWindow
 
    ScrollWindow::ScrollWindow(Window *pParentWindow)
            : Window(), pScrollBar(nullptr), iScrollY(0), iClientHeight(0), fHasBar(true), iFrozen(0)
    {
        // place within client rect
        C4Rect rtBounds = pParentWindow->GetClientRect();
        rtBounds.x = rtBounds.y = 0;
        rtBounds.Wdt -= C4GUI_ScrollBarWdt;
        SetBounds(rtBounds);
        // create scroll bar
        rtBounds.x += rtBounds.Wdt; rtBounds.Wdt = C4GUI_ScrollBarWdt;
        pScrollBar = new ScrollBar(rtBounds, this);
        // add self and scroll bar to window
        if (pParentWindow != this)
        {
            pParentWindow->AddElement(this);
            pParentWindow->AddElement(pScrollBar);
        }
    }
 
    void ScrollWindow::Update()
    {
        // not if window is being refilled
        if (iFrozen) return;
        // do not scroll outside range
        iScrollY = Clamp<int32_t>(iScrollY, 0, std::max<int32_t>(iClientHeight - GetBounds().Hgt, 0));
        // update client rect
        rcClientRect.x = 0;
        rcClientRect.y = -iScrollY;
        rcClientRect.Wdt = rcBounds.Wdt;
        rcClientRect.Hgt = iClientHeight;
        // update scroll bar
        if (pScrollBar) pScrollBar->Update();
    }
 
    void ScrollWindow::SetScroll(int32_t iToScroll)
    {
        // set values
        rcClientRect.y = -(iScrollY = iToScroll);
    }
 
    void ScrollWindow::ScrollToBottom()
    {
        int32_t iVisHgt = GetBounds().Hgt;
        int32_t iClientHgt = GetClientRect().Hgt;
        int32_t iMaxScroll = iClientHgt - iVisHgt;
        if (iScrollY < iMaxScroll)
        {
            // scrolling possible: do it
            iScrollY = iMaxScroll;
            // update (self + bar)
            Update();
        }
    }
 
    void ScrollWindow::ScrollPages(int iPageCount)
    {
        int32_t iVisHgt = GetBounds().Hgt;
        ScrollBy(iPageCount * iVisHgt);
    }
 
    void ScrollWindow::ScrollBy(int iAmount)
    {
        int32_t iVisHgt = GetBounds().Hgt;
        int32_t iClientHgt = GetClientRect().Hgt;
        int32_t iMaxScroll = iClientHgt - iVisHgt;
        int iNewScrollY = Clamp<int>(iScrollY + iAmount, 0, iMaxScroll);
        if (iScrollY != iNewScrollY)
        {
            // scrolling possible: do it
            iScrollY = iNewScrollY;
            // update (self + bar)
            Update();
        }
    }
 
    void ScrollWindow::ScrollRangeInView(int32_t iY, int32_t iHgt)
    {
        // safety bounds
        if (iY<0) iY=0;
        int32_t iClientHgt = GetClientRect().Hgt;
        if (iY+iHgt > iClientHgt) { ScrollToBottom(); return; }
        // check top
        if (iScrollY > iY)
        {
            iScrollY = iY;
            Update(); // update (self+bar)
        }
        else
        {
            // check bottom
            int32_t iVisHgt = GetBounds().Hgt;
            // if no height is given, scroll given Y-pos to top
            if (!iHgt) iHgt = iVisHgt;
            if (iScrollY + iVisHgt < iY + iHgt)
            {
                iScrollY = iY + iHgt - iVisHgt;
                Update(); // update (self+bar)
            }
        }
    }
 
    bool ScrollWindow::IsRangeInView(int32_t iY, int32_t iHgt)
    {
        // returns whether scrolling range is in view
        // check top
        if (iScrollY > iY) return false;
        // check height
        return iScrollY + GetBounds().Hgt >= iY+iHgt;
    }
 
    void ScrollWindow::UpdateOwnPos()
    {
        if (!GetParent()) { Update(); return; }
        // place within client rect
        C4Rect rtBounds = GetParent()->GetContainedClientRect();
        rtBounds.x = rtBounds.y = 0;
        if (fHasBar) rtBounds.Wdt -= C4GUI_ScrollBarWdt;
        if (GetBounds() != rtBounds)
        {
            SetBounds(rtBounds);
            // scroll bar
            if (fHasBar)
            {
                rtBounds.x += rtBounds.Wdt; rtBounds.Wdt = C4GUI_ScrollBarWdt;
                pScrollBar->SetBounds(rtBounds);
            }
        }
        // standard updates
        Update();
    }
 
    void ScrollWindow::SetScrollBarEnabled(bool fToVal, bool noAutomaticPositioning)
    {
        if (fHasBar == fToVal) return;
        pScrollBar->SetVisibility(fHasBar = fToVal);
        // in some cases the windows will already care for the correct positioning themselves (see C4ScriptGuiWindow)
        if (!noAutomaticPositioning)
            UpdateOwnPos();
    }
 
    void ScrollWindow::MouseInput(CMouse &rMouse, int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyParam)
    {
        // process wheel: Scroll
        if (iButton == C4MC_Button_Wheel)
        {
            short iDelta = (short)(dwKeyParam >> 16);
            ScrollBy(-iDelta);
            return;
        }
        // other mouse input: inherited (forward to children)
        Window::MouseInput(rMouse, iButton, iX, iY, dwKeyParam);
    }
 
 
// --------------------------------------------------
// GroupBox
 
    CStdFont *GroupBox::GetTitleFont() const
    {
        // get font; fallback to GUI caption font
        return pFont ? pFont : &(::GraphicsResource.CaptionFont);
    }
 
    void GroupBox::DrawElement(C4TargetFacet &cgo)
    {
        // draw background
        if (dwBackClr != 0xffffffff)
        {
            pDraw->DrawBoxDw(cgo.Surface, cgo.TargetX+rcBounds.x, cgo.TargetY+rcBounds.y, cgo.TargetX+rcBounds.x+rcBounds.Wdt-1, cgo.TargetY+rcBounds.y+rcBounds.Hgt-1, dwBackClr);
        }
        // draw title label
        int32_t iBorderYOff = 0;
        int32_t iTitleGapX = 0;
        int32_t iTitleGapWdt = 0;
        if (HasTitle())
        {
            CStdFont *pTitleFont = GetTitleFont();
            iBorderYOff = pTitleFont->GetLineHeight()/2;
            pTitleFont->GetTextExtent(sTitle.getData(), iTitleGapWdt, iTitleGapX, true);
            iTitleGapX = 7; iTitleGapWdt += 4;
            pDraw->TextOut(sTitle.getData(), *pTitleFont, 1.0f, cgo.Surface, cgo.TargetX+rcBounds.x+iTitleGapX+2, cgo.TargetY+rcBounds.y, dwTitleClr);
        }
        // draw frame
        if (dwFrameClr)
        {
            int32_t x1=cgo.TargetX+rcBounds.x,y1=cgo.TargetY+rcBounds.y+iBorderYOff,x2=x1+rcBounds.Wdt,y2=y1+rcBounds.Hgt-iBorderYOff;
            if (iTitleGapWdt)
            {
                for (int i=0; i<2; ++i)
                {
                    pDraw->DrawLineDw(cgo.Surface, (float) x1+i, (float)y1, (float)(x1+i), (float)(y2-1), dwFrameClr); // left
                    pDraw->DrawLineDw(cgo.Surface, (float) (x1+2), (float)(y1+i), (float)(x1+iTitleGapX), (float)(y1+i), dwFrameClr); // top - left side
                    pDraw->DrawLineDw(cgo.Surface, (float) (x1+iTitleGapX+iTitleGapWdt), (float)(y1+i), (float)(x2-3), (float)(y1+i), dwFrameClr); // top - right side
                    pDraw->DrawLineDw(cgo.Surface, (float) (x2-1-i), (float)y1, (float)(x2-1-i), (float)(y2-1), dwFrameClr); // right
                    pDraw->DrawLineDw(cgo.Surface, (float) (x1+2), (float)(y2-1-i), (float)(x2-3), (float)(y2-1-i), dwFrameClr); // bottom
                }
            }
            else
            {
                pDraw->DrawFrameDw(cgo.Surface, x1, y1, x2, (y2-1), dwFrameClr);
                pDraw->DrawFrameDw(cgo.Surface, (x1+1), (y1+1), (x2-1), (y2-2), dwFrameClr);
            }
        }
        else
            // default frame color
            // 2do: Make this work with titled group boxes
            Draw3DFrame(cgo);
    }
 
 
// --------------------------------------------------
// Control
 
    Control::Control(const C4Rect &rtBounds) : Window()
    {
        // set bounds
        SetBounds(rtBounds);
        // context menu key binding
        pKeyContext = new C4KeyBinding(C4KeyCodeEx(K_MENU), "GUIContext", KEYSCOPE_Gui,
                                       new ControlKeyCB<Control>(*this, &Control::KeyContext), C4CustomKey::PRIO_Ctrl);
    }
 
    Control::~Control()
    {
        delete pKeyContext;
    }
 
    void Control::MouseInput(CMouse &rMouse, int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyParam)
    {
        if (!IsVisible()) return;
        // left down on click=focus-components?
        if (IsFocusOnClick() && IsFocusElement()) if (iButton == C4MC_Button_LeftDown && !HasFocus())
            {
                // then set focus
                Dialog *pParentDlg = GetDlg();
                if (pParentDlg)
                {
                    // but do not set focus to this if a child control has it already
                    Control *pActiveCtrl = pParentDlg->GetFocus();
                    if (!pActiveCtrl || !IsParentOf(pActiveCtrl))
                        pParentDlg->SetFocus(this, true);
                }
            }
        // inherited - processing child elements
        Window::MouseInput(rMouse, iButton, iX, iY, dwKeyParam);
    }
 
    bool Control::HasDrawFocus()
    {
        // has focus at all?
        if (!HasFocus()) return false;
        // is screen ready and not in context?
        if (GetScreen() && GetScreen()->HasContext()) return false;
        // get dlg
        Dialog *pDlg=GetDlg();
        // dlg-less control has focus, OK (shouldn't happen)
        if (!pDlg) return true;
        // check if dlg is active
        return pDlg->IsActive(true);
    }
 
    void Control::DisableFocus()
    {
        // has it any focus at all?
        if (!HasFocus()) return;
        // then de-focus it
        Dialog *pDlg=GetDlg();
        if (!pDlg) return;
        pDlg->AdvanceFocus(true);
    }
 
} // end of namespace