GLX/GteWindowSystem.h

Go to the documentation of this file.

// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2017
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// File Version: 3.0.1 (2016/07/01)

#pragma once

#include <Applications/GLX/GteWindow.h>
#include <memory>

// Forward declarations to avoid name conflicts caused by #include-ing X11/Xlib.h.
struct _XDisplay;
struct __GLXcontextRec;

namespace gte
{

class GTE_IMPEXP WindowSystem
{
public:
    // Construction and destruction. This is a singleton class.
    ~WindowSystem ();
    WindowSystem ();

    // Create and destroy windows.  Derived classes may extend the inputs
    // using a nested class derived from Window::Parameters
    template <typename WindowType>
    std::shared_ptr<WindowType> Create(typename WindowType::Parameters& parameters);

    // Creation of information used for a compute-shader-only GLXEngine.
    bool Create(_XDisplay*& display, __GLXcontextRec*& context, unsigned long& window);

    template <typename WindowType>
    void Destroy(std::shared_ptr<WindowType>& window);

    enum
    {
        DEFAULT_ACTION = 0,
        NO_IDLE_LOOP = 1
    };

    template <typename WindowType>
    void MessagePump(std::shared_ptr<WindowType> const& window, unsigned int flags);

private:
    // Window creation and destruction.
    void CreateFrom(Window::Parameters& parameters);

    char const* mDisplayName;
    _XDisplay* mDisplay;
    std::map<unsigned long, std::shared_ptr<Window>> mWindowMap;
};

extern GTE_IMPEXP WindowSystem TheWindowSystem;

template <typename WindowType>
std::shared_ptr<WindowType> WindowSystem::Create(typename WindowType::Parameters& parameters)
{
    CreateFrom(parameters);
    if (parameters.created)
    {
        std::shared_ptr<WindowType> window = std::make_shared<WindowType>(parameters);
        mWindowMap[parameters.window] = window;
        if (parameters.created)
        {
            return window;
        }
        Destroy(window);
    }
    // else: CreateFrom will report the problem via the logger system.
    return nullptr;
}

template <typename WindowType>
void WindowSystem::Destroy(std::shared_ptr<WindowType>& window)
{
    if (window)
    {
        mWindowMap.erase(window->mWindow);
        window->OnClose();
        window = nullptr;
    }
}

template <typename WindowType>
void WindowSystem::MessagePump(std::shared_ptr<WindowType> const& window, unsigned int flags)
{
    if (window)
    {
        window->ShowWindow();

        for (;;)
        {
            int result = window->ProcessedEvent();
            if (result == Window::EVT_QUIT)
            {
                return;
            }

            if (result == Window::EVT_NONE_PENDING)
            {
                if (!(flags & NO_IDLE_LOOP))
                {
                    if (!window->IsMinimized())
                    {
                        window->OnIdle();
                    }
                }
            }
        }
    }
}

}