AWindow.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * 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/.
 */
 
#pragma once
 
#include "AUI/Views.h"
#include "AUI/Common/AString.h"
 
#include "AUI/Common/AObject.h"
#include "AUI/Common/ASignal.h"
 
#include "AUI/Platform/AWindowBase.h"
#include "AUI/Thread/IEventLoop.h"
#include "AUI/Util/AMetric.h"
#include "AWindowNativePtr.h"
#include <AUI/Enum/WindowStyle.h>
#include <AUI/Enum/AScreenOrientation.h>
 
#if AUI_PLATFORM_WIN
#include <windows.h>
 
#elif AUI_PLATFORM_ANDROID
#include <jni.h>
#elif AUI_PLATFORM_APPLE
#else
 
#endif
 
class ARender;
class AWindowManager;

class API_AUI_VIEWS AWindow: public AWindowBase
{
    friend class OpenGLRenderingContext;
    friend class CommonRenderingContext;
    friend class SoftwareRenderingContext;
    friend class AWindowManager;
    friend struct painter;
public:
    AWindow(const AString& name = "My window", int width = 854_dp, int height = 500_dp, AWindow* parent = nullptr, WindowStyle ws = WindowStyle::DEFAULT) {
        windowNativePreInit(name, width, height, parent, ws);
    }
    virtual ~AWindow();
 
    [[nodiscard]]
    unsigned frameMillis() const noexcept override {
        return mFrameMillis;
    }
 
    void redraw();
 
    void blockUserInput(bool blockUserInput = true) override;

    static bool isRedrawWillBeEfficient();
 
    void setIcon(const AImage& image);

    void quit();
 
    void setWindowStyle(WindowStyle ws);

    void minimize();

    bool isMinimized() const;

    void maximize();

    bool isMaximized() const;

    void restore();
 
    void flagRedraw() override;

    void show();
    void close();
    void hide();
 
    [[nodiscard]]
    bool isClosed() const noexcept;
 
#if AUI_PLATFORM_WIN
    HWND getNativeHandle() { return mHandle; }
#elif AUI_PLATFORM_ANDROID
    jobject getNativeHandle() { return mHandle; }
#elif AUI_PLATFORM_APPLE
#else
    AWindowNativePtr getNativeHandle() { return mHandle; }
#endif
 
    auto nativeHandle() const {
        return mHandle;
    }
 
    const AString& getWindowTitle() const
    {
        return mWindowTitle;
    }
 
    glm::ivec2 getWindowPosition() const;
 
    void setPosition(glm::ivec2 position) override;
    void setSize(glm::ivec2 size) override;
    void setGeometry(int x, int y, int width, int height) override;
 
#if AUI_PLATFORM_LINUX
    void applyGeometryToChildren() override;
#endif
 
    void onFocusAcquired() override;
    void onFocusLost() override;
 
    void onKeyDown(AInput::Key key) override;
    void onKeyRepeat(AInput::Key key) override;
 
    void setFocusNextViewOnTab(bool value) {
        mFocusNextViewOnTab = value;
    }

    static _<AWindow> wrapViewToWindow(const _<AView>& view, const AString& title, int width = 854_dp, int height = 500_dp, AWindow* parent = nullptr, WindowStyle ws = WindowStyle::DEFAULT);

    static AWindowBase* current();

    [[nodiscard]] glm::ivec2 mapPositionTo(const glm::ivec2& position, _<AWindow> other);

    [[nodiscard]] glm::ivec2 unmapPosition(const glm::ivec2& position);

    [[nodiscard]] glm::ivec2 mapPosition(const glm::ivec2& position);
 
    _<AOverlappingSurface> createOverlappingSurfaceImpl(const glm::ivec2& position, const glm::ivec2& size) override;
 
    void closeOverlappingSurfaceImpl(AOverlappingSurface* surface) override;
    virtual void onCloseButtonClicked();
 
    void forceUpdateCursor() override;
 
    void showTouchscreenKeyboardImpl() override;
    void hideTouchscreenKeyboardImpl() override;

    void moveToCenter();

    void setMobileScreenOrientation(AScreenOrientation screenOrientation);
 
signals:
    emits<> closed;
    emits<> shown;

    emits<glm::vec2> moving;

    emits<> maximized;

    emits<> minimized;

    emits<> restored;
 
    bool consumesClick(const glm::ivec2& pos) override;
 
    void onPointerMove(glm::vec2 pos, const APointerMoveEvent& event) override;
 
protected:
#if AUI_PLATFORM_WIN
    HICON mIcon = nullptr;
    virtual LRESULT winProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
#elif AUI_PLATFORM_ANDROID
#elif AUI_PLATFORM_APPLE
#endif
    AWindowNativePtr mHandle = 0; // on linux AWindowNativePtr is not a pointer type so using zero here
    WindowStyle mWindowStyle = WindowStyle::DEFAULT;
 
    virtual void doDrawWindow();
    virtual void onClosed();
 
    void windowNativePreInit(const AString& name, int width, int height, AWindow* parent, WindowStyle ws);

    void allowDragNDrop();

    AWindow(std::nullptr_t) {}
 
    void createDevtoolsWindow() override;
 
    float fetchDpiFromSystem() const override;

    bool mFocusNextViewOnTab = false;
 
private:
#if AUI_PLATFORM_WIN
 
#elif AUI_PLATFORM_ANDROID
#elif AUI_PLATFORM_LINUX
    struct {
        uint32_t lo = 0;
        uint32_t hi = 0;
        /* XID */ unsigned long counter;
    } mXsyncRequestCounter;
    bool mWasMaximized = false;
 
    void* mIC = nullptr; // input context
#endif
#ifdef AUI_PLATFORM_MACOS
    bool mRedrawFlag = false;
#else
    bool mRedrawFlag = true;
#endif
    AString mWindowClass;
    AWindow* mParentWindow;
 
    unsigned mFrameMillis = 1;

    _<AWindow> mSelfHolder;
 
    AString mWindowTitle;
 
#if AUI_PLATFORM_WIN
    friend LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
#endif
#if AUI_PLATFORM_LINUX
    unsigned long xGetWindowProperty(unsigned long property, unsigned long type, unsigned char** value) const;
    void xSendEventToWM(unsigned long atom, long a, long b, long c, long d, long e) const;
#endif
 
};