_host_frontend_model_8h

Wwise SDK 2024.1.0

 /*******************************************************************************
 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
 released in source code form as part of the SDK installer package.
  
 Commercial License Usage
  
 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
 may use this file in accordance with the end user license agreement provided 
 with the software or, alternatively, in accordance with the terms contained in a
 written agreement between you and Audiokinetic Inc.
  
 Apache License Usage
  
 Alternatively, this file may be used under the Apache License, Version 2.0 (the 
 "Apache License"); you may not use this file except in compliance with the 
 Apache License. You may obtain a copy of the Apache License at 
 http://www.apache.org/licenses/LICENSE-2.0.
  
 Unless required by applicable law or agreed to in writing, software distributed
 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
 the specific language governing permissions and limitations under the License.
  
   Copyright (c) 2024 Audiokinetic Inc.
 *******************************************************************************/
  
 /**
  * \brief Wwise Authoring Plug-ins - Plug-in API for the Frontend Model.
  * \file AK/Wwise/Plugin/HostFrontendModel.h
  */
  
 #pragma once
  
 #include "PluginInfoGenerator.h"
 #include "PluginDef.h"
  
 /**
  * \brief Interface used to interact with the frontend model.
  * 
  * The frontend model is the service in charge of building GUI views and managing the
  * objects's lifetime. It takes the description of a view in the form of a WAFM
  * file, creates the widget hierarchy, and stores the objects in a specific handle.
  * The handle is shared to the user to allow interaction with the view's widgets.
  */
 struct ak_wwise_plugin_host_frontend_model_v1
 #ifdef __cplusplus
     : public ak_wwise_plugin_base_interface
 #endif
 {
 #ifndef __cplusplus
     ak_wwise_plugin_base_interface m_baseInterface;
 #endif
  
 #ifdef __cplusplus
     /// Base host-provided instance type for ak_wwise_plugin_host_frontend_model_v1.
     using Instance = ak_wwise_plugin_host_frontend_model_instance_v1;
     ak_wwise_plugin_host_frontend_model_v1() :
         ak_wwise_plugin_base_interface(AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_FRONTEND_MODEL, 1)
     {}
 #endif
  
     /**
      * \brief Checks if a specific widget exists.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_absoluteId Text id uniquely identifying the widget.
      * \return True if the widget exists.
      */
     bool(*HasWidget)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         const char * in_absoluteId
     );
  
     /**
      * \brief Returns the parent widget of a given Frontend Handle hierarchy.
      * 
      * \param[in] in_this Current instance of this interface.
      * \return Pointer to the parent widget.
      */
     ak_wwise_plugin_widget*(*GetParentWidget)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         const char* in_absoluteId
     );
  
     /**
      * \brief Returns the main layout widget of a given Frontend Handle hierarchy.
      * 
      * \param[in] in_this Current instance of this interface.
      * \return Pointer to the root widget.
      */
     ak_wwise_plugin_widget*(*GetRootWidget)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this
     );
  
     /**
      * \brief Returns a specific widget of a given Frontend Handle hierarchy.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_absoluteId Text id uniquely identifying the widget.
      * \return Pointer to the widget if it exists, otherwise nullptr.
      */
     ak_wwise_plugin_widget*(*GetWidget)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         const char* in_absoluteId
     );
  
     /**
      * \brief Gets the ID of a widget.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \return String ID of the widget.
      */
     const char*(*GetWidgetID)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget
     );
  
     /**
      * \brief Gets the type ID of a widget.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \return String ID of the widget's type.
      */
     const char*(*GetWidgetType)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget
     );
  
     /**
      * \brief Checks if the widget can contain other widgets.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \return True if the widget is a container.
      */
     bool(*IsWidgetContainer)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget
     );
  
     /**
      * \brief Checks if the widget is top-level.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \return True if the widget is top-level.
      */
     bool(*IsWidgetTopLevel)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget
     );
  
     /**
      * \brief Determines the visibility state of the given widget.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \return True if the widget is visible.
      */
     bool(*IsWidgetVisible)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget
     );
  
     /**
      * \brief Determines if a widget is enabled for mouse and keyboard input.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \return True if the widget is enabled.
      */
     bool(*IsWidgetEnabled)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget
     );
  
     /**
      * \brief Enables or disables mouse and keyboard input for the widget.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \param[in] in_enable True to enable the widget, False to disable.
      */
     void(*EnableWidget)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget,
         bool in_enable
     );
  
     /**
      * \brief Sets the visibility state of the widget.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \param[in] in_show True to show the widget, False to hide.
      */
     void(*ShowWidget)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget,
         bool in_show
     );
  
     /**
      * \brief Claims the input focus for the widget.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      */
     void(*SetWidgetFocus)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget
     );
  
     /**
      * \brief Connects a signal to a handler taking some user-defined data.
      *
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_widget Pointer to the widget.
      * \param[in] in_name Name of the signal.
      * \param[in] in_handler Static function of the form 'void StaticHandler(void* in_owner, ArgsT... in_args, void* in_data)'.
      * \param[in] in_userData Pointer to user-defined data. This is forwarded to the handler
      * when the signal gets emitted. The user must perform the necessary casts in the handler.
      * \return True if the signal isn't already connected and was successfully connected.
      */
     bool(*Connect)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         ak_wwise_plugin_widget* in_widget,
         const char* in_name,
         void (*in_handler)(),
         void* in_userData
     );
  
     /**
      * \brief Applies a user-defined handler to every child of a container.
      *
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_absoluteId Text id uniquely identifying the widget container.
      * \param[in] in_handler Static function of the form 'void StaticHandler(ak_wwise_plugin_widget*, void* in_data)'.
      * \param[in] in_userData Pointer to user-defined data. This is forwarded to the handler.
      * The user must perform the necessary casts in the handler.
      */
     void(*ForEachChildren)(
         struct ak_wwise_plugin_host_frontend_model_instance_v1* in_this,
         const char * in_absoluteId,
         void (*in_handler)(ak_wwise_plugin_widget*, void*),
         void* in_userData
     );
 };
  
 #define AK_WWISE_PLUGIN_HOST_FRONTEND_MODEL_V1_ID() \
     AK_WWISE_PLUGIN_BASE_INTERFACE_FROM_ID(AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_FRONTEND_MODEL, 1)
 #define AK_WWISE_PLUGIN_HOST_FRONTEND_MODEL_V1_CTOR() \
 { \
     .m_baseInterface = AK_WWISE_PLUGIN_HOST_FRONTEND_MODEL_V1_ID() \
 }
  
 #ifdef __cplusplus
 namespace AK::Wwise::Plugin
 {
     namespace V1
     {
         using CHostFrontendModel = ak_wwise_plugin_host_frontend_model_v1;
  
         /// \copydoc ak_wwise_plugin_host_frontend_model_v1
         class FrontendModel : public CBaseInstanceGlue<CHostFrontendModel>
         {
         public:
             using Interface = CHostFrontendModel;
  
             using GenericCallback = void(*)();
             using ForEachCallback = void(*)(ak_wwise_plugin_widget*, void*);
  
             /**
              * \brief The interface type, as requested by this plug-in.
              */
             enum : InterfaceTypeValue
             {
                 /**
                  * \brief The interface type, as requested by this plug-in.
                  */
                 k_interfaceType = AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_FRONTEND_MODEL
             };
             /**
              * \brief The interface version, as requested by this plug-in.
              */
             enum : InterfaceVersion
             {
                 /**
                  * \brief The interface version, as requested by this plug-in.
                  */
                 k_interfaceVersion = 1
             };
  
             /**
              * \brief Checks if a specific widget exists.
              * 
              * \param[in] in_absoluteId Text id uniquely identifying the widget.
              * \return True if the widget exists.
              */
             [[nodiscard]] inline bool HasWidget(const char * in_absoluteId)
             {
                 return MKBOOL(g_cinterface->HasWidget(this, in_absoluteId));
             }
  
             /**
              * \brief Returns the parent widget of a given Frontend Handle hierarchy.
              * 
              * \return Pointer to the parent widget.
              */
             [[nodiscard]] inline ak_wwise_plugin_widget* GetParentWidget(const char* in_absoluteId)
             {
                 return g_cinterface->GetParentWidget(this, in_absoluteId);
             }
  
             /**
              * \brief Returns the main layout widget of a given Frontend Handle hierarchy.
              * 
              * \return Pointer to the root widget.
              */
             [[nodiscard]] inline ak_wwise_plugin_widget* GetRootWidget()
             {
                 return g_cinterface->GetRootWidget(this);
             }
  
             /**
              * \brief Returns a specific widget of a given Frontend Handle hierarchy.
              * 
              * \param[in] in_absoluteId Text id uniquely identifying the widget.
              * \return Pointer to the widget if it exists, otherwise nullptr.
              */
             [[nodiscard]] inline ak_wwise_plugin_widget* GetWidget(const char* in_absoluteId)
             {
                 return g_cinterface->GetWidget(this, in_absoluteId);
             }
  
             /**
              * \brief Gets the ID of a widget.
              * 
              * \param[in] in_widget Pointer to the widget.
              * \return String ID of the widget.
              */
             [[nodiscard]] inline const char* GetWidgetID(ak_wwise_plugin_widget* in_widget)
             {
                 return g_cinterface->GetWidgetID(this, in_widget);
             }
  
             /**
              * \brief Gets the type ID of a widget.
              * 
              * \param[in] in_widget Pointer to the widget.
              * \return String ID of the widget's type.
              */
             [[nodiscard]] inline const char* GetWidgetType(ak_wwise_plugin_widget* in_widget)
             {
                 return g_cinterface->GetWidgetType(this, in_widget);
             }
  
             /**
              * \brief Checks if the widget can contain other widgets.
              * 
              * \param[in] in_widget Pointer to the widget.
              * \return True if the widget is a container.
              */
             [[nodiscard]] inline bool IsWidgetContainer(ak_wwise_plugin_widget* in_widget)
             {
                 return g_cinterface->IsWidgetContainer(this, in_widget);
             }
  
             /**
              * \brief Checks if the widget is top-level.
              * 
              * \param[in] in_widget Pointer to the widget.
              * \return True if the widget is top-level.
              */
             [[nodiscard]] inline bool IsWidgetTopLevel(ak_wwise_plugin_widget* in_widget)
             {
                 return g_cinterface->IsWidgetTopLevel(this, in_widget);
             }
  
             /**
              * \brief Determines the visibility state of the given widget.
              * 
              * \param[in] in_widget Pointer to the widget.
              * \return True if the widget is visible.
              */
             [[nodiscard]] inline bool IsWidgetVisible(ak_wwise_plugin_widget* in_widget)
             {
                 return g_cinterface->IsWidgetVisible(this, in_widget);
             }
  
             /**
              * \brief Determines if a widget is enabled for mouse and keyboard input.
              * 
              * \param[in] in_widget Pointer to the widget.
              * \return True if the widget is enabled.
              */
             [[nodiscard]] inline bool IsWidgetEnabled(ak_wwise_plugin_widget* in_widget)
             {
                 return g_cinterface->IsWidgetEnabled(this, in_widget);
             }
  
             /**
              * \brief Enables or disables mouse and keyboard input for the widget.
              * 
              * \param[in] in_widget Pointer to the widget.
              * \param[in] in_enable True to enable the widget, False to disable.
              */
             inline void EnableWidget(
                 ak_wwise_plugin_widget* in_widget,
                 bool in_enable
             )
             {
                 g_cinterface->EnableWidget(this, in_widget, in_enable);
             }
  
             /**
              * \brief Sets the visibility state of the widget.
              * 
              * \param[in] in_widget Pointer to the widget.
              * \param[in] in_show True to show the widget, False to hide.
              */
             inline void ShowWidget(
                 ak_wwise_plugin_widget* in_widget,
                 bool in_show
             )
             {
                 g_cinterface->ShowWidget(this, in_widget, in_show);
             }
  
             /**
              * \brief Claims the input focus for the widget.
              * 
              * \param[in] in_widget Pointer to the widget.
              */
             inline void SetWidgetFocus(ak_wwise_plugin_widget* in_widget)
             {
                 return g_cinterface->SetWidgetFocus(this, in_widget);
             }
  
             /**
              * \brief Connects a signal to a handler taking some user-defined data.
              *
              * \param[in] in_widget Pointer to the widget.
              * \param[in] in_name Name of the signal.
              * \param[in] in_handler Static function of the form 'void StaticHandler(void* in_owner, ArgsT... in_args, void* in_data)'.
              * \param[in] in_userData Pointer to user-defined data. This is forwarded to the handler
              * when the signal gets emitted. The user must perform the necessary casts in the handler.
              * \return True if the signal isn't already connected and was successfully connected.
              */
             inline bool Connect(
                 ak_wwise_plugin_widget* in_widget,
                 const char* in_name,
                 GenericCallback in_handler,
                 void* in_userData
             )
             {
                 return g_cinterface->Connect(this, in_widget, in_name, in_handler, in_userData);
             }
  
             /**
              * \brief Applies a user-defined handler to every child of a container.
              *
              * \param[in] in_absoluteId Text id uniquely identifying the widget container.
              * \param[in] in_handler Static function of the form 'void StaticHandler(ak_wwise_plugin_widget*, void* in_data)'.
              * \param[in] in_userData Pointer to user-defined data. This is forwarded to the handler.
              * The user must perform the necessary casts in the handler.
              */
             inline void ForEachChildren(
                 const char* in_absoluteId,
                 ForEachCallback in_handler,
                 void* in_userData
             )
             {
                 return g_cinterface->ForEachChildren(this, in_absoluteId, in_handler, in_userData);
             }
         };
  
         /**
          * \brief Requests a FrontendModel interface, provided as m_frontendModel variable.
          * 
          * Deriving your plug-in class from RequestFrontendModel will automatically request the FrontendModel interface.
          * From this point, you will be able to access the host-provided functions in the `m_frontendModel` variable.
          * 
          * \aknote The AK::Wwise::Plugin::RequestFrontendModel classe is automatically derived when providing Frontend in C++.
          * \endaknote
          */
         using RequestFrontendModel = RequestedHostInterface<FrontendModel>;
  
     } // of namespace V1
  
     /// Latest version of the C FrontendModel interface.
     using CHostFrontendModel = V1::CHostFrontendModel;
     /// Latest version of the C++ FrontendModel interface.
     using FrontendModel = V1::FrontendModel;
     /// Latest version of the requested C++ FrontendModel interface.
     using RequestFrontendModel = V1::RequestFrontendModel;
  
     AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE(FrontendModel, frontendModel);
     AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS(FrontendModel);
     AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION(FrontendModel);
 } // of namespace AK::Wwise::Plugin
  
 #endif

ak_wwise_plugin_widget

void ak_wwise_plugin_widget

Definition: PluginDef.h:507

AK.Wwise::Plugin::RequestedHostInterface< FrontendModel >

Definition: HostFrontendModel.h:500

ak_wwise_plugin_host_frontend_model_v1::HasWidget

bool(* HasWidget)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, const char *in_absoluteId)

Checks if a specific widget exists.

Definition: HostFrontendModel.h:69

AK.Wwise::Plugin::V1::FrontendModel::GetParentWidget

ak_wwise_plugin_widget * GetParentWidget(const char *in_absoluteId)

Returns the parent widget of a given Frontend Handle hierarchy.

Definition: HostFrontendModel.h:312

AK.Wwise::Plugin::V1::FrontendModel::IsWidgetContainer

bool IsWidgetContainer(ak_wwise_plugin_widget *in_widget)

Checks if the widget can contain other widgets.

Definition: HostFrontendModel.h:366

AK.Wwise::Plugin::V1::FrontendModel::k_interfaceVersion

@ k_interfaceVersion

The interface version, as requested by this plug-in.

Definition: HostFrontendModel.h:293

ak_wwise_plugin_host_frontend_model_v1::GetRootWidget

ak_wwise_plugin_widget *(* GetRootWidget)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this)

Returns the main layout widget of a given Frontend Handle hierarchy.

Definition: HostFrontendModel.h:91

ak_wwise_plugin_host_frontend_model_v1::EnableWidget

void(* EnableWidget)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget, bool in_enable)

Enables or disables mouse and keyboard input for the widget.

Definition: HostFrontendModel.h:186

AK.Wwise::Plugin::V1::FrontendModel::GenericCallback

void(*)() GenericCallback

Definition: HostFrontendModel.h:272

AK.Wwise::Plugin::CBaseInterfaceGlue< CHostFrontendModel >::g_cinterface

static GluedInterface * g_cinterface

The unique instance of the CInterface interface. Defined at nullptr first, overridden by the Host onc...

Definition: PluginInfoGenerator.h:89

AK.Wwise::Plugin::V1::FrontendModel

Interface used to interact with the frontend model.

Definition: HostFrontendModel.h:268

AK.Wwise::Plugin::InterfaceVersion

decltype(BaseInterface::m_version) InterfaceVersion

PluginInfoGenerator: Type for the m_version value in BaseInterface.

Definition: PluginInfoGenerator.h:50

ak_wwise_plugin_host_frontend_model_v1::SetWidgetFocus

void(* SetWidgetFocus)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget)

Claims the input focus for the widget.

Definition: HostFrontendModel.h:211

ak_wwise_plugin_host_frontend_model_v1::IsWidgetVisible

bool(* IsWidgetVisible)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget)

Determines the visibility state of the given widget.

Definition: HostFrontendModel.h:162

ak_wwise_plugin_host_frontend_model_v1::Connect

bool(* Connect)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget, const char *in_name, void(*in_handler)(), void *in_userData)

Connects a signal to a handler taking some user-defined data.

Definition: HostFrontendModel.h:227

AK.Wwise::Plugin::V1::FrontendModel::IsWidgetTopLevel

bool IsWidgetTopLevel(ak_wwise_plugin_widget *in_widget)

Checks if the widget is top-level.

Definition: HostFrontendModel.h:377

AK.Wwise::Plugin::V1::FrontendModel::ForEachChildren

void ForEachChildren(const char *in_absoluteId, ForEachCallback in_handler, void *in_userData)

Applies a user-defined handler to every child of a container.

Definition: HostFrontendModel.h:470

AK.Wwise::Plugin::V1::FrontendModel::ShowWidget

void ShowWidget(ak_wwise_plugin_widget *in_widget, bool in_show)

Sets the visibility state of the widget.

Definition: HostFrontendModel.h:424

ak_wwise_plugin_host_frontend_model_v1::GetWidget

ak_wwise_plugin_widget *(* GetWidget)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, const char *in_absoluteId)

Returns a specific widget of a given Frontend Handle hierarchy.

Definition: HostFrontendModel.h:102

ak_wwise_plugin_host_frontend_model_v1::ShowWidget

void(* ShowWidget)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget, bool in_show)

Sets the visibility state of the widget.

Definition: HostFrontendModel.h:199

ak_wwise_plugin_host_frontend_model_v1::GetParentWidget

ak_wwise_plugin_widget *(* GetParentWidget)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, const char *in_absoluteId)

Returns the parent widget of a given Frontend Handle hierarchy.

Definition: HostFrontendModel.h:80

ak_wwise_plugin_host_frontend_model_v1::IsWidgetTopLevel

bool(* IsWidgetTopLevel)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget)

Checks if the widget is top-level.

Definition: HostFrontendModel.h:150

AK.Wwise::Plugin::V1::FrontendModel::Connect

bool Connect(ak_wwise_plugin_widget *in_widget, const char *in_name, GenericCallback in_handler, void *in_userData)

Connects a signal to a handler taking some user-defined data.

Definition: HostFrontendModel.h:452

ak_wwise_plugin_host_frontend_model_v1::GetWidgetType

const char *(* GetWidgetType)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget)

Gets the type ID of a widget.

Definition: HostFrontendModel.h:126

AK.Wwise::Plugin::V1::FrontendModel::GetWidgetID

const char * GetWidgetID(ak_wwise_plugin_widget *in_widget)

Gets the ID of a widget.

Definition: HostFrontendModel.h:344

AK.Wwise::Plugin::V1::FrontendModel::k_interfaceType

@ k_interfaceType

The interface type, as requested by this plug-in.

Definition: HostFrontendModel.h:283

ak_wwise_plugin_host_frontend_model_v1

Interface used to interact with the frontend model.

Definition: HostFrontendModel.h:49

ak_wwise_plugin_host_frontend_model_instance_v1

Definition: PluginDef.h:942

AK.Wwise::Plugin::FrontendModel

V1::FrontendModel FrontendModel

Latest version of the C++ FrontendModel interface.

Definition: HostFrontendModel.h:496

PluginInfoGenerator.h

Wwise Authoring Plug-ins - C++ class helper to automatically determine the plug-in interfaces used in...

ak_wwise_plugin_host_frontend_model_v1::IsWidgetEnabled

bool(* IsWidgetEnabled)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget)

Determines if a widget is enabled for mouse and keyboard input.

Definition: HostFrontendModel.h:174

AK.Wwise::Plugin::V1::FrontendModel::HasWidget

bool HasWidget(const char *in_absoluteId)

Checks if a specific widget exists.

Definition: HostFrontendModel.h:302

AK.Wwise::Plugin::V1::RequestFrontendModel

RequestedHostInterface< FrontendModel > RequestFrontendModel

Requests a FrontendModel interface, provided as m_frontendModel variable.

Definition: HostFrontendModel.h:489

AK.Wwise::Plugin::CBaseInstanceGlue

PluginInfoGenerator: Associates an existing C Interface with a variable that can be used....

Definition: PluginInfoGenerator.h:104

AK.Wwise::Plugin::V1::FrontendModel::GetRootWidget

ak_wwise_plugin_widget * GetRootWidget()

Returns the main layout widget of a given Frontend Handle hierarchy.

Definition: HostFrontendModel.h:322

AK.Wwise::Plugin::V1::FrontendModel::IsWidgetEnabled

bool IsWidgetEnabled(ak_wwise_plugin_widget *in_widget)

Determines if a widget is enabled for mouse and keyboard input.

Definition: HostFrontendModel.h:399

AK.Wwise::Plugin::V1::FrontendModel::IsWidgetVisible

bool IsWidgetVisible(ak_wwise_plugin_widget *in_widget)

Determines the visibility state of the given widget.

Definition: HostFrontendModel.h:388

AK.Wwise::Plugin::InterfaceTypeValue

std::underlying_type< InterfaceType >::type InterfaceTypeValue

PluginInfoGenerator: Underlying storage type for the m_interface value in BaseInterface.

Definition: PluginInfoGenerator.h:49

ak_wwise_plugin_host_frontend_model_v1::GetWidgetID

const char *(* GetWidgetID)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget)

Gets the ID of a widget.

Definition: HostFrontendModel.h:114

AK.Wwise::Plugin::V1::CHostFrontendModel

ak_wwise_plugin_host_frontend_model_v1 CHostFrontendModel

Definition: HostFrontendModel.h:264

AK.Wwise::Plugin::V1::FrontendModel::GetWidgetType

const char * GetWidgetType(ak_wwise_plugin_widget *in_widget)

Gets the type ID of a widget.

Definition: HostFrontendModel.h:355

AK.Wwise::Plugin::AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION

AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION(AudioPlugin)

AK.Wwise::Plugin::V1::FrontendModel::ForEachCallback

void(*)(ak_wwise_plugin_widget *, void *) ForEachCallback

Definition: HostFrontendModel.h:273

ak_wwise_plugin_host_frontend_model_v1::IsWidgetContainer

bool(* IsWidgetContainer)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, ak_wwise_plugin_widget *in_widget)

Checks if the widget can contain other widgets.

Definition: HostFrontendModel.h:138

ak_wwise_plugin_base_interface

Interface description and base class for every Wwise Authoring plug-in interface.

Definition: PluginBaseInterface.h:120

AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_FRONTEND_MODEL

@ AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_FRONTEND_MODEL

Definition: PluginBaseInterface.h:96

AK.Wwise::Plugin::V1::FrontendModel::GetWidget

ak_wwise_plugin_widget * GetWidget(const char *in_absoluteId)

Returns a specific widget of a given Frontend Handle hierarchy.

Definition: HostFrontendModel.h:333

AK.Wwise::Plugin::V1::FrontendModel::SetWidgetFocus

void SetWidgetFocus(ak_wwise_plugin_widget *in_widget)

Claims the input focus for the widget.

Definition: HostFrontendModel.h:437

AK.Wwise::Plugin::V1::FrontendModel::EnableWidget

void EnableWidget(ak_wwise_plugin_widget *in_widget, bool in_enable)

Enables or disables mouse and keyboard input for the widget.

Definition: HostFrontendModel.h:410

MKBOOL

#define MKBOOL(cond)

Definition: PluginHelpers.h:79

AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE

#define AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE(in_name, in_varname,...)

PluginInfoGenerator: Creates a C++ host specialization for interface class specified in in_name,...

Definition: PluginInfoGenerator.h:237

ak_wwise_plugin_host_frontend_model_v1::ak_wwise_plugin_host_frontend_model_v1

ak_wwise_plugin_host_frontend_model_v1()

Definition: HostFrontendModel.h:57

AK.Wwise::Plugin::AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS

AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS(AudioPlugin)

ak_wwise_plugin_host_frontend_model_v1::ForEachChildren

void(* ForEachChildren)(struct ak_wwise_plugin_host_frontend_model_instance_v1 *in_this, const char *in_absoluteId, void(*in_handler)(ak_wwise_plugin_widget *, void *), void *in_userData)

Applies a user-defined handler to every child of a container.

Definition: HostFrontendModel.h:244

PluginDef.h

Wwise Authoring Plug-ins - Base plug-in definitions.

AK.Wwise::Plugin

Definition: AudioPlugin.h:111

Was this page helpful?

Need Support?

Questions? Problems? Need more info? Contact us, and we can help!

Visit our Support page

Tell us about your project. We're here to help.

Get started with Wwise

Wwise SDK