View.h

/*
This file is part of Hummingbird, a modern user interface library.

Copyright (c) 2012-2017 Coherent Labs AD and/or its licensors. All
rights reserved in all media.

The coded instructions, statements, computer programs, and/or related
material (collectively the "Data") in these files contain confidential
and unpublished information proprietary Coherent Labs and/or its
licensors, which is protected by United States of America federal
copyright law and by international treaties.

This software or source code is supplied under the terms of a license
agreement and nondisclosure agreement with Coherent Labs AD and may
not be copied, disclosed, or exploited except in accordance with the
terms of that agreement. The Data may not be disclosed or distributed to
third parties, in whole or in part, without the prior written consent of
Coherent Labs AD.

COHERENT LABS MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS
SOURCE CODE FOR ANY PURPOSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER, ITS AFFILIATES,
PARENT COMPANIES, LICENSORS, SUPPLIERS, OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OR PERFORMANCE OF THIS SOFTWARE OR SOURCE CODE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once

#include <cohtml/Declarations.h>
#include <cohtml/ResourceHandler.h>
#include <cohtml/Binding/Binder.h>

#if !defined(COHTML_TRIGGER_EVENT_SCOPE)
#define COHTML_TRIGGER_EVENT_SCOPE(CompileTimeArgsCount, RuntimeEventName)
#endif

namespace cohtml
{
class Binder;
class IViewListener;
struct TouchEventData;
struct MouseEventData;
struct KeyEventData;
struct GestureEventData;
class IEventHandler;
class INodeProxy;
typedef void* BoundEventHandle;

template <typename T>
void CoherentCreateModelBindPointer(Binder* binder, T* model)
{
    binder->BeginType();
    CoherentBind(binder, model);
    binder->EndType(model);
}

#if defined(IW_SDK)
template <typename T>
void CoherentGenericBind(Binder* b, const void* arg)
{
    CoherentBindInternal(b, *(const T*)arg);
}
typedef void(*CoherentGenericBindFuncPtr)(Binder*, const void*);
#endif
}

#if defined(IW_SDK)
extern "C"
{
void HummingbirdTriggerEventOnOSThread(void* binder, const char* name, int numArgs,
    void* functions, const void** args);
}
#endif

namespace cohtml
{

enum RenderingTasksAvailableType
{
    RTA_ViewReadyForRendering,
    RTA_RenderingSubSystemTask
};

typedef void (*OnRenderingTasksAvailableFunc)(void* userData, unsigned viewId, unsigned frameId, RenderingTasksAvailableType type);
typedef double (*OnMonotonicallyIncreasingTimeRequestFunc)(void* userdata, unsigned viewId);

struct ViewSettings
{
    IViewListener* Listener;

    unsigned Width;

    unsigned Height;

    OnRenderingTasksAvailableFunc OnRenderingTasksAvailable;

    OnMonotonicallyIncreasingTimeRequestFunc OnMonotonicallyIncreasingTimeRequest;

    void* UserData;

    bool EnableComplexCSSSelectorsStyling;

    ViewSettings()
        : Listener(nullptr)
        , Width(1280u)
        , Height(720u)
        , OnRenderingTasksAvailable(nullptr)
        , OnMonotonicallyIncreasingTimeRequest(nullptr)
        , UserData(nullptr)
        , EnableComplexCSSSelectorsStyling(false)
    {}
};

namespace InputEventPhase
{
    enum PhaseType
    {
        NONE = 0,

        CAPTURING_PHASE = 1,

        AT_TARGET = 2,

        BUBBLING_PHASE = 3
    };
}

namespace EventAction
{
    enum Actions
    {
        ContinueHandling,

        InterruptHandling
    };
};

namespace TextInputControlType
{
    enum ControlType
    {
        TextInput,

        Other
    };
};

struct ScreenInfo
{
    unsigned Width;

    unsigned Height;

    unsigned AvailableWidth;

    unsigned AvailableHeight;

    unsigned ColorDepth;

    unsigned PixelDepth;

    ScreenInfo()
        : Width(0)
        , Height(0)
        , AvailableWidth(0)
        , AvailableHeight(0)
        , ColorDepth(0)
        , PixelDepth(0)
    {}
};

class COHTML_API IViewListener
{
public:
    virtual ~IViewListener();


    virtual bool OnNavigateTo(const char* url) = 0;

    virtual void OnScriptContextCreated() = 0;

    virtual void OnDOMBuilt() = 0;

    virtual void OnLoadFailed(const char* url, const char* error) = 0;

    virtual void OnFinishLoad(const char* url) = 0;

    virtual void OnReadyForBindings() = 0;

    virtual void OnBindingsReleased() = 0;

    virtual ScreenInfo OnScreenInfoRequested() = 0;

    virtual EventAction::Actions OnNodeTouched(const INodeProxy* node,
        const TouchEventData* event,
        void* userData,
        const InputEventPhase::PhaseType phase) = 0;

    virtual EventAction::Actions OnNodeMouseEvent(const INodeProxy* node,
        const MouseEventData* event,
        void* userData,
        const InputEventPhase::PhaseType phase) = 0;

    virtual EventAction::Actions OnNodeKeyEvent(const INodeProxy* node,
        const KeyEventData* event,
        void* userData,
        const InputEventPhase::PhaseType phase) = 0;

    virtual void OnAudioStreamCreated(int id, int bitDepth, int channels,
        float samplingRate)
    {
        UNUSED_PARAM(id);
        UNUSED_PARAM(bitDepth);
        UNUSED_PARAM(channels);
        UNUSED_PARAM(samplingRate);
    }

    virtual void OnAudioStreamClosed(int id)
    {
        UNUSED_PARAM(id);
    }

    virtual void OnAudioStreamPlay(int id)
    {
        UNUSED_PARAM(id);
    }

    virtual void OnAudioStreamPause(int id)
    {
        UNUSED_PARAM(id);
    }

    virtual void OnAudioDataReceived(int id, int samples, float** pcm,
        int channels)
    {
        UNUSED_PARAM(id);
        UNUSED_PARAM(samples);
        UNUSED_PARAM(pcm);
        UNUSED_PARAM(channels);
    }

    virtual void OnAudioStreamEnded(int id)
    {
        UNUSED_PARAM(id);
    }

    virtual void OnAudioStreamVolumeChanged(int id, float volume)
    {
        UNUSED_PARAM(id);
        UNUSED_PARAM(volume);
    }

    virtual void OnTextInputTypeChanged(TextInputControlType::ControlType type) = 0;

    virtual void OnCaretRectChanged(int x,
        int y,
        unsigned width,
        unsigned height) = 0;

    virtual void OnIMEShouldCancelComposition() = 0;
};

struct DebugDump
{
    enum DumpFlags
    {
        DF_None = 0,
        DF_IncludeStyles = 1 << 1,
        DF_IncludeLayout = 1 << 2,
    };

    const char* Dump;
    virtual void Release() = 0;
};

struct FrameCapture
{
    const char* Data;

    unsigned long long Size;

    virtual void Release() = 0;
};

typedef void(*FrameCaptureCallback)(void* userData, FrameCapture* capture);

class View
{
public:
    virtual ~View();

    virtual void Destroy() = 0;

    virtual void LoadURL(const char* url) = 0;

    virtual void Reload() = 0;

    virtual void UnloadDocument() = 0;

    virtual unsigned Advance(TimePoint timeMilliseconds) = 0;

    virtual unsigned GetId() const = 0;

    virtual TaskFamilyId GetTaskFamilyId() const = 0;

    virtual void Resize(unsigned width, unsigned height) = 0;

    virtual unsigned GetWidth() const = 0;

    virtual unsigned GetHeight() const = 0;

    virtual void ContinuousRepaint(bool enable) = 0;

    virtual void ShowPaintRectangles(bool show) = 0;

    virtual void ShowElementAABBs(bool show) = 0;

    virtual DebugDump* DebugDumpDOMTree(unsigned flags) = 0;

    virtual void TouchEvent(const cohtml::TouchEventData* events, unsigned count, bool* handled, void* userData) = 0;

    virtual void GestureEvent(const cohtml::GestureEventData& event, bool* handled, void* userData) = 0;

    virtual void MouseEvent(const cohtml::MouseEventData& event, bool* handled, void* userData) = 0;

    virtual void KeyEvent(const cohtml::KeyEventData& event, bool* handled, void* userData) = 0;

    virtual bool IMESetComposition(const char* composition,
        unsigned targetStart,
        unsigned targetEnd) = 0;

    virtual bool IMEConfirmComposition(const char* composition) = 0;

    virtual bool IMECancelComposition() = 0;

    virtual void SetUserAgent(const char* userAgent) = 0;

    virtual void BeginCaptureDebugFrame(void* userData, FrameCaptureCallback callback) = 0;

    virtual void EndCaptureDebugFrame() = 0;

    virtual void CaptureSingleDebugFrame(void* userData, FrameCaptureCallback callback) = 0;

    virtual BoundEventHandle RegisterForEvent(const char* name,
        IEventHandler* handler) = 0;

    virtual void UnregisterFromEvent(BoundEventHandle handle) = 0;

    virtual BoundEventHandle BindCall(const char* name, IEventHandler* handler)
        = 0;

    virtual void UnbindCall(BoundEventHandle handle) = 0;

    virtual void UnbindObject(const void* object) = 0;

    template <typename T>
    void ExposeAsGlobal(const char* name, T* object)
    {
        Binder* binder = GetBinder();
        binder->BeginExposeObject();
        CoherentBindInternal(binder, object);
        binder->SetAsGlobal(name, object);
    }

    virtual void DestroyExposedObject(void* object) = 0;

    virtual bool IsReadyForBindings() const = 0;

    virtual void ExecuteScript(const char* script) = 0;

    virtual void AddInitialScript(const char* script) = 0;

    virtual void ResetInitialScripts() = 0;

    virtual Binder* GetBinder() = 0;


    typedef void(*CoherentInternalBindGenericFunc)(cohtml::Binder*, void*);

    template <typename T>
    void CreateModel(const char* name, T* model)
    {
        typedef void(*CoherentInternalBindFunc)(cohtml::Binder*, T*);
        CoherentInternalBindFunc bindFuncPtr = &CoherentCreateModelBindPointer<T>;
        CoherentInternalBindGenericFunc bindGenericPtr = reinterpret_cast<CoherentInternalBindGenericFunc>(bindFuncPtr);
        RegisterModel(name, model, bindGenericPtr);
    }

    virtual void UpdateWholeModel(void* model) = 0;

    virtual void SynchronizeModels() = 0;

    virtual void RegisterModel(const char* name, void* model, CoherentInternalBindGenericFunc func) = 0;

    virtual void UnregisterModel(void* model) = 0;




#if !defined(IW_SDK)
    virtual void TriggerEvent(const char* name) = 0;

    template <typename T1>
    void TriggerEvent(const char* name, const T1& argument1)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_1_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            binder->BeginEvent(name, 1);

            CoherentBindInternal(binder, argument1);

            binder->EndEvent();
        }
    }

    template <typename T1, typename T2>
    void TriggerEvent(const char* name,
        const T1& argument1,
        const T2& argument2)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_2_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {

            binder->BeginEvent(name, 2);

            CoherentBindInternal(binder, argument1);
            CoherentBindInternal(binder, argument2);

            binder->EndEvent();
        }
    }

    template <typename T1, typename T2, typename T3>
    void TriggerEvent(const char* name,
        const T1& argument1,
        const T2& argument2,
        const T3& argument3)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_3_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            binder->BeginEvent(name, 3);

            CoherentBindInternal(binder, argument1);
            CoherentBindInternal(binder, argument2);
            CoherentBindInternal(binder, argument3);

            binder->EndEvent();
        }
    }

    template <typename T1, typename T2, typename T3, typename T4>
    void TriggerEvent(const char* name,
        const T1& argument1,
        const T2& argument2,
        const T3& argument3,
        const T4& argument4)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_4_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            binder->BeginEvent(name, 4);

            CoherentBindInternal(binder, argument1);
            CoherentBindInternal(binder, argument2);
            CoherentBindInternal(binder, argument3);
            CoherentBindInternal(binder, argument4);

            binder->EndEvent();
        }
    }

    template <typename T1, typename T2, typename T3, typename T4, typename T5>
    void TriggerEvent(const char* name,
        const T1& argument1,
        const T2& argument2,
        const T3& argument3,
        const T4& argument4,
        const T5& argument5)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_5_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            binder->BeginEvent(name, 5);

            CoherentBindInternal(binder, argument1);
            CoherentBindInternal(binder, argument2);
            CoherentBindInternal(binder, argument3);
            CoherentBindInternal(binder, argument4);
            CoherentBindInternal(binder, argument5);

            binder->EndEvent();
        }
    }

#else
    inline void TriggerEventOnOSThread(const char* name)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_0_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            HummingbirdTriggerEventOnOSThread(binder, name, 0, NULL, NULL);
        }
    }

    template <typename T1>
    void TriggerEvent(const char* name, const T1& argument1)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_1_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            CoherentGenericBindFuncPtr functions[] = {
                &CoherentGenericBind<T1>
            };
            const void* args[] = {
                &argument1
            };
            HummingbirdTriggerEventOnOSThread(binder, name, 1, functions, args);
        }
    }

    template <typename T1, typename T2>
    void TriggerEvent(const char* name,
        const T1& argument1,
        const T2& argument2)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_2_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            CoherentGenericBindFuncPtr functions[] = {
                &CoherentGenericBind<T1>,
                &CoherentGenericBind<T2>
            };
            const void* args[] = {
                &argument1,
                &argument2
            };
            HummingbirdTriggerEventOnOSThread(binder, name, 2, functions, args);
        }
    }

    template <typename T1, typename T2, typename T3>
    void TriggerEvent(const char* name,
        const T1& argument1,
        const T2& argument2,
        const T3& argument3)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_3_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            CoherentGenericBindFuncPtr functions[] = {
                &CoherentGenericBind<T1>,
                &CoherentGenericBind<T2>,
                &CoherentGenericBind<T3>,
            };
            const void* args[] = {
                &argument1,
                &argument2,
                &argument3
            };
            HummingbirdTriggerEventOnOSThread(binder, name, 3, functions, args);
        }
    }

    template <typename T1, typename T2, typename T3, typename T4>
    void TriggerEvent(const char* name,
        const T1& argument1,
        const T2& argument2,
        const T3& argument3,
        const T4& argument4)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_4_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            CoherentGenericBindFuncPtr functions[] = {
                &CoherentGenericBind<T1>,
                &CoherentGenericBind<T2>,
                &CoherentGenericBind<T3>,
                &CoherentGenericBind<T4>
            };
            const void* args[] = {
                &argument1,
                &argument2,
                &argument3,
                &argument4
            };
            HummingbirdTriggerEventOnOSThread(binder, name, 4, functions, args);
        }
    }

    template <typename T1, typename T2, typename T3, typename T4, typename T5>
    void TriggerEventOnUIThread(const char* name,
        const T1& argument1,
        const T2& argument2,
        const T3& argument3,
        const T4& argument4,
        const T5& argument5)
    {
        COHTML_TRIGGER_EVENT_SCOPE(TriggerEvent_5_Param, name);
        Binder* binder = GetBinder();

        if (binder)
        {
            CoherentGenericBindFuncPtr functions[] = {
                &CoherentGenericBind<T1>,
                &CoherentGenericBind<T2>,
                &CoherentGenericBind<T3>,
                &CoherentGenericBind<T4>,
                &CoherentGenericBind<T5>,
            };
            const void* args[] = {
                &argument1,
                &argument2,
                &argument3,
                &argument4,
                &argument5
            };
            HummingbirdTriggerEventOnOSThread(binder, name, 5, functions, args);
        }
    }
#endif
};

}