Display.h

Go to the documentation of this file.

// Display.h
//
// Copyright (c) 2013-2015 Michael Imamura.
//
// Licensed under GrokkSoft HoverRace SourceCode License v1.0(the "License");
// you may not use this file except in compliance with the License.
//
// A copy of the license should have been attached to the package from which
// you have taken this file. If you can not find the license you can not use
// this file.
//
//
// The author makes no representations about the suitability of
// this software for any purpose.  It is provided "as is" "AS IS",
// 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.

#pragma once

#include "../Vec.h"
#include "Styles.h"
#include "UiLayoutFlags.h"
#include "ViewAttacher.h"

#if defined(_WIN32) && defined(HR_ENGINE_SHARED)
#   ifdef MR_ENGINE
#       define MR_DllDeclare   __declspec( dllexport )
#   else
#       define MR_DllDeclare   __declspec( dllimport )
#   endif
#else
#   define MR_DllDeclare
#endif

namespace HoverRace {
    namespace Display {
        class ActiveText;
        class BaseContainer;
        class Button;
        class ClickRegion;
        class FillBox;
        class KeycapIcon;
        class Label;
        class Picture;
        class RuleLine;
        class ScreenFade;
        class Slider;
        class SymbolIcon;
        class TypeCase;
        class Wallpaper;
    }
    namespace VideoServices {
        class VideoBuffer;
    }
}

namespace HoverRace {
namespace Display {

class MR_DllDeclare Display :
    public ViewAttacher<ActiveText>,
    public ViewAttacher<BaseContainer>,
    public ViewAttacher<Button>,
    public ViewAttacher<ClickRegion>,
    public ViewAttacher<FillBox>,
    public ViewAttacher<KeycapIcon>,
    public ViewAttacher<Label>,
    public ViewAttacher<Picture>,
    public ViewAttacher<RuleLine>,
    public ViewAttacher<ScreenFade>,
    public ViewAttacher<Slider>,
    public ViewAttacher<SymbolIcon>,
    public ViewAttacher<Wallpaper>
{
public:
    Display() : uiOrigin(0, 0), uiLayoutFlags(0), uiScale(1.0),
        uiOffset(0, 0), uiScreenSize(1280, 720) { }
    virtual ~Display() { }

public:
    std::shared_ptr<TypeCase> GetTypeCase(const UiFont &font);

    void CleanTypeCaseCache();

protected:
    virtual std::shared_ptr<TypeCase> MakeTypeCase(const UiFont &font) = 0;

public:
    virtual VideoServices::VideoBuffer &GetLegacyDisplay() const = 0;

    virtual void OnDesktopModeChanged(int width, int height) = 0;

    virtual void OnDisplayConfigChanged();

public:
    using displayConfigChangedSignal_t =
        boost::signals2::signal<void(int, int)>;
    displayConfigChangedSignal_t &GetDisplayConfigChangedSignal() { return displayConfigChangedSignal; }
protected:
    void FireDisplayConfigChangedSignal(int width, int height) const;

public:
    using uiScaleChangedSignal_t =
        boost::signals2::signal<void(double)>;
    uiScaleChangedSignal_t &GetUiScaleChangedSignal() { return uiScaleChangedSignal; }
protected:
    void FireUiScaleChangedSignal(double scale) const;

public:
    virtual void Flip() = 0;

    virtual void Screenshot() = 0;

public:
    const Vec2 &GetUiOrigin() const noexcept { return uiOrigin; }

    void SetUiOrigin(const Vec2 &vec) noexcept { uiOrigin = vec; }

    Vec2 AddUiOrigin(const Vec2 &vec) noexcept
    {
        Vec2 oldOrigin = uiOrigin;
        uiOrigin += vec;
        return oldOrigin;
    }

    void SetUiLayoutFlags(uiLayoutFlags_t flags) noexcept { uiLayoutFlags = flags; }

    uiLayoutFlags_t AddUiLayoutFlags(uiLayoutFlags_t flags) noexcept
    {
        auto oldFlags = uiLayoutFlags;
        uiLayoutFlags |= flags;
        return oldFlags;
    }

    double GetUiScale() const noexcept { return uiScale; }
    const Vec2 &GetUiOffset() const noexcept { return uiOffset; }

    Vec2 LayoutUiPosition(const Vec2 &relPos, uiLayoutFlags_t layoutFlags = 0)
        noexcept
    {
        Vec2 adjustedPos = relPos;
        adjustedPos += GetUiOrigin();
        if (!((layoutFlags | uiLayoutFlags) & UiLayoutFlags::UNSCALED)) {
            adjustedPos *= GetUiScale();
        }
        if (!((layoutFlags | uiLayoutFlags) & UiLayoutFlags::FLOATING)) {
            adjustedPos += GetUiOffset();
        }
        return adjustedPos;
    }

    const Vec2 &GetUiScreenSize() const noexcept { return uiScreenSize; }

private:
    Vec2 uiOrigin;
    uiLayoutFlags_t uiLayoutFlags;
    double uiScale;
    Vec2 uiOffset;
    Vec2 uiScreenSize;
    std::unordered_map<UiFont, std::weak_ptr<TypeCase>> typeCases;
    displayConfigChangedSignal_t displayConfigChangedSignal;
    uiScaleChangedSignal_t uiScaleChangedSignal;

public:
    Styles styles;
};

}  // namespace Display
}  // namespace HoverRace

#undef MR_DllDeclare