///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Copyright (c) 2000-2019 Ericsson Telecom AB                               //
//                                                                           //
// All rights reserved. This program and the accompanying materials          //
// are made available under the terms of the Eclipse Public License v2.0     //
// which accompanies this distribution, and is available at                  //
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html                                 //
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
//  Module: EPTF_CLL_UIHandlerClient_Functions
// 
//  Purpose:
//    This module contains the implementation of generic CLL_UIHandlerClient functions.
// 
//  Module depends on:
//    <EPTF_CLL_UIHandler_MsgDefinitions>
//    <EPTF_CLL_UIHandlerClient_Definitions>
//    <EPTF_CLL_UIHandler_Definitions>
//    <EPTF_CLL_Variable_Functions>
//    <EPTF_CLL_Base_Functions>
//    <EPTF_CLL_Semaphore_Functions>
//    <EPTF_CLL_Logging_Definitions>
//    <EPTF_CLL_Logging_Functions>
// 
//  Current Owner:
//    Laszlo Skumat (ELSZSKU)
// 
//  Last Review Date:
//    2007-xx-xx
//
//  Detailed Comments:
//    This module contains the interface functions for the EPTF_UIHandlerClient_CT. 
//
///////////////////////////////////////////////////////////////
module EPTF_CLL_UIHandlerClient_Functions
// [.objid{ itu_t(0) identified_organization(4) etsi(0) 
// identified_organization(127) ericsson(5) testing(0)
// <put further nodes here if needed>}]
{
//=========================================================================
// Import Part
//=========================================================================
import from EPTF_CLL_UIHandler_MsgDefinitions all;
import from EPTF_CLL_UIHandlerClient_Definitions all;
import from EPTF_CLL_UIHandler_Definitions all;
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_Variable_Functions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_Semaphore_Functions all;
import from EPTF_CLL_Logging_Definitions all;
import from EPTF_CLL_Logging_Functions all;
import from ttcn_ericsson_se_protocolModules_xtdp_xtdl all;
import from EPTF_CLL_UIHandler_ConvertFunctions all;

//=========================================================================
// Module Parameters
//=========================================================================
modulepar boolean tsp_debug_EPTF_UIHandlerClient_Functions := false;
modulepar float tsp_EPTF_UIHandlerClient_MaxWaitTime := 3.0;
//=========================================================================
// Functions
//=========================================================================
group Public_Functions{
  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_init_CT
  //
  //  Purpose:
  //    Initialises the EPTF_UIHandlerClient_CT component
  //
  //  Parameters:
  //    pl_selfName - *in* *charstring* - The name of the component.
  //    pl_DefaultUIHandler - *in* <EPTF_UIHandler_CT> - The default UIHandler 
  //
  //  Detailed Comments:
  //    This function should be called before using the EPTF_UIHandlerClient_CT
  //    component. It initializes the extended EPTF_Var_CT component.
  //    If you use only one UIHandler, you can use the  version of 
  //    subscription functions where there are no subscriber in the parameter list. That
  //    functions will use the default UIHandler as subscriber.
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_init_CT(
    in charstring pl_selfName,
    in EPTF_UIHandler_CT pl_DefaultUIHandler) runs on EPTF_UIHandlerClient_CT {
    if (v_UIHandlerClient_initialized) {
      return;
    }
    f_EPTF_Var_init_CT(pl_selfName);
    f_EPTF_Semaphore_init_CT(pl_selfName);
    f_EPTF_Logging_init_CT(pl_selfName);
    v_UIHandlerClient_loggingMaskId := f_EPTF_Logging_registerComponentMasks(
      tsp_EPTF_UIHandlerClient_loggingComponentMask,
      c_EPTF_UIHandler_loggingEventClasses,
      EPTF_Logging_CLL);
    if(tsp_debug_EPTF_UIHandlerClient_Functions) {
      f_EPTF_Logging_enableLocalMask(v_UIHandlerClient_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
    } else {
      f_EPTF_Logging_disableLocalMask(v_UIHandlerClient_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
    }

    v_UIHandlerClient_pendingMsgCounter := 0;
    v_UIHandlerClient_hangingConnections := {};
    v_UIHandlerClient_openUIConnections := {};
    v_UIHandlerClient_subsRetList := {};
    v_UIHandlerClient_widgetExistsRespList := {};
    v_UIHandlerClient_DefaultUIHandler := pl_DefaultUIHandler;
    v_UIHandlerClient_def := activate(as_handle_main_EPTF_UIHandlerClient_MgmtIf());
    v_UIHandlerClient_initialized := true;
    // register cleanup function
    f_EPTF_Base_registerCleanup(refers(f_EPTF_UIHandlerClient_cleanup_CT));
    //      log("DEBUG: ","----CLL_UIHandlerClient INIT DONE----");
    f_EPTF_UIHandlerClient_debug("----CLL_UIHandlerClient INIT DONE----");
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_defaultUIHandler
  //  Purpose:
  //    Returns the default UIHandler component
  //
  //  Detailed Comments:
  //    See <f_SendSubscribeNoteTo>
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_defaultUIHandler()
  runs on EPTF_UIHandlerClient_CT return EPTF_UIHandler_CT {
    return v_UIHandlerClient_DefaultUIHandler;
  }


  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_subscribeMe
  //  Purpose:
  //    Orders the default UIHandler to subscribe to a specified variable 
  //    on this component and optionally connect to a widget
  //
  //  Detailed Comments:
  //    See <f_SendSubscribeNoteTo>
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_subscribeMe ( 
    in charstring pl_providedParamName,
    in charstring pl_destParamName := "",
    in EPTF_UIHandler_WidgetIdString pl_widgetId := "",
    in EPTF_Var_SubscriptionMode pl_subsMode := timeLine,
    in integer pl_refreshRate := -1)
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_subscribeMeTo( 
      v_UIHandlerClient_DefaultUIHandler, 
      pl_providedParamName,
      pl_destParamName,
      pl_widgetId,
      pl_subsMode,
      pl_refreshRate);
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_subscribeMeTo
  //  Purpose:
  //    Orders an UIHandler to subscribe to a specified variable
  //    on this component and optionally connect to a widget
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_subscribeMeTo ( 
    in EPTF_UIHandler_CT  pl_subscriber,
    in charstring pl_providedParamName,
    in charstring pl_destParamName := "",
    in EPTF_UIHandler_WidgetIdString pl_widgetId := "",
    in EPTF_Var_SubscriptionMode pl_subsMode := timeLine,
    in integer pl_refreshRate := -1)
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_subscribeTo( 
      v_UIHandlerClient_DefaultUIHandler, 
      self,
      pl_providedParamName,
      pl_destParamName,
      pl_widgetId,
      pl_subsMode,
      pl_refreshRate);
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_subscribe
  //  Purpose:
  //    Orders the default UIHandler to subscribe to a specified variable
  //    on a specified component and optionally connect to a widget
  //
  //  Detailed Comments:
  //    See <f_SendSubscribeNoteTo>
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_subscribe ( 
    in EPTF_Var_CT pl_remoteCompRef,
    in charstring pl_providedParamName,
    in charstring pl_destParamName := "",
    in EPTF_UIHandler_WidgetIdString pl_widgetId := "",
    in EPTF_Var_SubscriptionMode pl_subsMode := timeLine,
    in integer pl_refreshRate := -1)
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_subscribeTo( 
      v_UIHandlerClient_DefaultUIHandler, 
      pl_remoteCompRef,
      pl_providedParamName,
      pl_destParamName,
      pl_widgetId,
      pl_subsMode,
      pl_refreshRate);
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_subscribeTo
  //  Purpose:
  //    Orders an UIHandler to subscribe to a specified variable
  //    on a specified component and optionally connect to a widget
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_subscribeTo ( 
    in EPTF_UIHandler_CT  pl_subscriber,
    in EPTF_Var_CT pl_remoteCompRef,
    in charstring pl_providedParamName,
    in charstring pl_destParamName := "",
    in EPTF_UIHandler_WidgetIdString pl_widgetId := "",
    in EPTF_Var_SubscriptionMode pl_subsMode := timeLine,
    in integer pl_refreshRate := -1)
  runs on EPTF_UIHandlerClient_CT{
    if (v_UIHandlerClient_maxTimeoutReached) {
      return;
    }
    
    var integer vl_semaphoreId := f_EPTF_Semaphore_new();
    var integer vl_msgId := vl_semaphoreId;//f_EPTF_UIHandlerClient_getMsgId();
    f_EPTF_UIHandlerClient_addVarConnection(
      pl_subscriber, 
      pl_providedParamName,
      vl_msgId);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;

    v_UIHandlerClient_adminPortIf.send({
        subscribeNoteMsg := {
          remoteCompRef := pl_remoteCompRef,
          providedParamName := pl_providedParamName,
          destParamName := pl_destParamName,
          widgetId := pl_widgetId,
          subsMode := pl_subsMode,
          messageId := vl_msgId,
          refreshRate := pl_refreshRate
        }
      }) to pl_subscriber;
    // wait until subscribe finishes
    if(f_EPTF_Semaphore_waitForUnlock(vl_semaphoreId,tsp_EPTF_UIHandlerClient_MaxWaitTime)) {
      f_EPTF_UIHandlerClient_debug(log2str(%definitionId&
          ": MaxWaitTime expired. No reponse received for subscribeNoteMsg with Id ",vl_semaphoreId, ". Going on..."));
      v_UIHandlerClient_maxTimeoutReached := true;
    }
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_subscribeVariable
  //  Purpose:
  //    Orders the default UIHandler to subscribe to a specified variable
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_subscribeVariable( 
    in charstring             pl_providedParamName,
    in charstring             pl_destParamName,
    in EPTF_Var_SubscriptionMode pl_subsMode := timeLine,
    in integer pl_refreshRate := -1) 
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_subscribeVariableTo(
      v_UIHandlerClient_DefaultUIHandler, 
      pl_providedParamName, 
      pl_destParamName,
      pl_subsMode,
      pl_refreshRate); 
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_subscribeVariableTo
  //  Purpose:
  //    Orders an UIHandler to subscribe to a specified variable
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_subscribeVariableTo ( 
    in EPTF_UIHandler_CT  pl_subscriber,
    in charstring             pl_providedParamName,
    in charstring             pl_destParamName,
    in EPTF_Var_SubscriptionMode pl_subsMode := timeLine,
    in integer pl_refreshRate := -1) 
  runs on EPTF_UIHandlerClient_CT{
    if (v_UIHandlerClient_maxTimeoutReached) {
      return;
    }
    var integer vl_semaphoreId := f_EPTF_Semaphore_new();
    var integer vl_msgId := vl_semaphoreId;//f_EPTF_UIHandlerClient_getMsgId();
    f_EPTF_UIHandlerClient_addVarConnection(pl_subscriber, pl_providedParamName, vl_msgId);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send({
        subscribeNoteMsg := {
          remoteCompRef := self,
          providedParamName := pl_providedParamName,
          destParamName := pl_destParamName,
          widgetId := omit,
          subsMode := pl_subsMode,
          messageId := vl_semaphoreId,
          refreshRate := pl_refreshRate
        }
      }) to pl_subscriber;
    // wait until subscribe finishes
    if (f_EPTF_Semaphore_waitForUnlock(vl_semaphoreId,tsp_EPTF_UIHandlerClient_MaxWaitTime)) {
      // max wait time expired, no response received
      f_EPTF_UIHandlerClient_debug(log2str(%definitionId&
          ": MaxWaitTime expired. No reponse received for subscribeNoteMsg with Id ",vl_semaphoreId, ". Going on..."));
      v_UIHandlerClient_maxTimeoutReached := true;
    }
  }

  
  // XSD begin

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_XSD_addElementToGUI
  //  Purpose:
  //    Orders the default UIHandler to add a widget to the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_XSD_addElementToGUI(
    in Widgets pl_xul, 
    in EPTF_UIHandler_WidgetIdString pl_parentWidgetId)
  runs on EPTF_UIHandlerClient_CT
  return EPTF_UIHandlerClient_SubsRet{
    return f_EPTF_UIHandlerClient_XSD_addElementToGUITo( pl_xul, pl_parentWidgetId, v_UIHandlerClient_DefaultUIHandler );
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_XSD_addElementToGUITo
  //  Purpose:
  //    Orders an UIHandler to add a widget to the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_XSD_addElementToGUITo(
    in Widgets pl_xul,
    in EPTF_UIHandler_WidgetIdString pl_parentWidgetId, 
    in EPTF_UIHandler_CT pl_UIHandler)
  runs on EPTF_UIHandlerClient_CT
  return EPTF_UIHandlerClient_SubsRet{  
    if (v_UIHandlerClient_maxTimeoutReached) {
      return sr_Fail;
    }
    var integer vl_semaphoreId := f_EPTF_Semaphore_new();
    f_EPTF_UIHandlerClient_connectUIHandler(pl_UIHandler);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send(
      t_UIHandler_AdminAddElementToGUI(
        pl_parentWidgetId, 
        vl_semaphoreId, 
        pl_xul)) to pl_UIHandler;
    // wait until reponse is received:
    if (f_EPTF_Semaphore_waitForUnlock(vl_semaphoreId,tsp_EPTF_UIHandlerClient_MaxWaitTime)) {
      f_EPTF_UIHandlerClient_debug(log2str(%definitionId&
          ": MaxWaitTime expired. No reponse received for AddElementToGUI with Id ",vl_semaphoreId, ". Going on..."));
      v_UIHandlerClient_maxTimeoutReached := true;
      return sr_Fail; // max wait timer expired, no response received in time
    }
    return v_UIHandlerClient_subsRetList[vl_semaphoreId];
  }

  // XSD end

  ///////////////////////////////////////////////////////////
  //  Altstep: as_EPTF_UIHandlerClient_handleAddElementToGUIResp
  //  Purpose:
  //    Handles the responses to AddElementToGUI
  ///////////////////////////////////////////////////////////
  private altstep as_EPTF_UIHandlerClient_handleAddElementToGUIResp() runs on EPTF_UIHandlerClient_CT {
    var EPTF_UIHandler_WidgetMsg vl_msg;
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminAddElementToGUIAck(?,?))-> value vl_msg{
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      if(vl_msg.addElementToGUIAck.widgetExists){
        v_UIHandlerClient_subsRetList[vl_msg.addElementToGUIAck.messageID] := sr_Exists;
      }else{
        v_UIHandlerClient_subsRetList[vl_msg.addElementToGUIAck.messageID] := sr_Success;
      }
      f_EPTF_Semaphore_unlock(vl_msg.addElementToGUIAck.messageID);
      repeat;
    };
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminAddElementToGUINAck(?))-> value vl_msg{
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      v_UIHandlerClient_subsRetList[vl_msg.addElementToGUINAck.messageID] := sr_Fail;
      f_EPTF_Semaphore_unlock(vl_msg.addElementToGUINAck.messageID);
      repeat;
    }
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_removeElementFromGUI
  //  Purpose:
  //    Orders the default UIHandler to remove a widget from the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_removeElementFromGUI(
    in EPTF_UIHandler_WidgetIdString pl_Widget2Remove)
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_removeElementFromGUITo( pl_Widget2Remove, v_UIHandlerClient_DefaultUIHandler );
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_removeElementFromGUITo
  //  Purpose:
  //    Orders an UIHandler to remove a widget from the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_removeElementFromGUITo(
    in EPTF_UIHandler_WidgetIdString pl_Widget2Remove,
    in EPTF_UIHandler_CT pl_UIHandler)
  runs on EPTF_UIHandlerClient_CT{
    if (v_UIHandlerClient_maxTimeoutReached) {
      return;
    }
    f_EPTF_UIHandlerClient_connectUIHandler(pl_UIHandler);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send(t_UIHandler_AdminRemoveElementFromGUI(pl_Widget2Remove,f_EPTF_UIHandlerClient_getMsgId())) to pl_UIHandler;
    /*     alt{ */
    /*       [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminRemoveElementFromGUIAck(?)){}; */
    /*       [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminRemoveElementFromGUINAck(?)){ */
    /*       } */
    /*     }   */
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_enableGUIElement
  //  Purpose:
  //    Orders the default UIHandler to enable a widget on the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_enableGUIElement(
    in EPTF_UIHandler_WidgetIdString pl_WidgetID)
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_enableGUIElementTo( pl_WidgetID, v_UIHandlerClient_DefaultUIHandler );
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_enableGUIElementTo
  //  Purpose:
  //    Orders an UIHandler to enable a widget on the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_enableGUIElementTo(
    in EPTF_UIHandler_WidgetIdString pl_WidgetID,
    in EPTF_UIHandler_CT pl_UIHandler)
  runs on EPTF_UIHandlerClient_CT{
    if (v_UIHandlerClient_maxTimeoutReached) {
      return;
    }
    f_EPTF_UIHandlerClient_connectUIHandler(pl_UIHandler);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send(t_UIHandler_AdminEnableWidgetByWidgetName(pl_WidgetID,f_EPTF_UIHandlerClient_getMsgId())) to pl_UIHandler;
    /*     alt{ */
    /*       [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminEnableWidgetAck(?)){}; */
    /*       [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminEnableWidgetNAck(?)){ */
    /*       } */
    /*     }   */
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_disableGUIElement
  //  Purpose:
  //    Orders the defalut UIHandler to disable a widget on the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_disableGUIElement(
    in EPTF_UIHandler_WidgetIdString pl_WidgetID)
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_disableGUIElementTo( pl_WidgetID, v_UIHandlerClient_DefaultUIHandler );
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_disableGUIElementTo
  //  Purpose:
  //    Orders an UIHandler to disable a widget on the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_disableGUIElementTo(
    in EPTF_UIHandler_WidgetIdString pl_WidgetID,
    in EPTF_UIHandler_CT pl_UIHandler)
  runs on EPTF_UIHandlerClient_CT{
    if (v_UIHandlerClient_maxTimeoutReached) {
      return;
    }
    f_EPTF_UIHandlerClient_connectUIHandler(pl_UIHandler);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send(t_UIHandler_AdminDisableWidgetByWidgetName(pl_WidgetID,f_EPTF_UIHandlerClient_getMsgId())) to pl_UIHandler;
    /*     alt{ */
    /*       [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminDisableWidgetAck(*)){}; */
    /*       [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminDisableWidgetNAck(*)){ */
    /*       } */
    /*     }   */
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_setFocusToGUIElement
  //  Purpose:
  //    Orders the default UIHandler to set a widget being focused on the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_setFocusToGUIElement(
    in EPTF_UIHandler_WidgetIdString pl_WidgetID)
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_setFocusToGUIElementTo( pl_WidgetID, v_UIHandlerClient_DefaultUIHandler );
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_setFocusToGUIElementTo
  //  Purpose:
  //    Orders an UIHandler to set a widget being focused on the runtime GUI
  //    connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_setFocusToGUIElementTo(
    in EPTF_UIHandler_WidgetIdString pl_WidgetID,
    in EPTF_UIHandler_CT pl_UIHandler)
  runs on EPTF_UIHandlerClient_CT{
    if (v_UIHandlerClient_maxTimeoutReached) {
      return;
    }
    f_EPTF_UIHandlerClient_connectUIHandler(pl_UIHandler);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send(t_UIHandler_AdminSetFocusToWidget(pl_WidgetID,f_EPTF_UIHandlerClient_getMsgId())) to pl_UIHandler;
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_setFocusToTab
  //  Purpose:
  //    Orders the default UIHandler to select a particular tab
  //    of a tabbox on the runtime GUI connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_setFocusToTab(
    in EPTF_UIHandler_WidgetIdString pl_TabboxID,
    in integer pl_TabIndex)
  runs on EPTF_UIHandlerClient_CT{
    f_EPTF_UIHandlerClient_setFocusToTabTo( pl_TabboxID, pl_TabIndex, v_UIHandlerClient_DefaultUIHandler );
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_setFocusToTabTo
  //  Purpose:
  //    Orders an UIHandler to select a particular tab of a tabbox
  //    of a tabbox on the runtime GUI connected to the UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_setFocusToTabTo(
    in EPTF_UIHandler_WidgetIdString pl_TabboxID,
    in integer pl_TabIndex,
    in EPTF_UIHandler_CT pl_UIHandler)
  runs on EPTF_UIHandlerClient_CT{
    if (v_UIHandlerClient_maxTimeoutReached) {
      return;
    }
    f_EPTF_UIHandlerClient_connectUIHandler(pl_UIHandler);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send(t_UIHandler_AdminSetFocusToWidget(
        pl_TabboxID,f_EPTF_UIHandlerClient_getMsgId(), pl_TabIndex)) to pl_UIHandler;
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_widgetExists
  //  Purpose:
  //    Checks whether the widget exists on the runtime GUI
  //    connected to the default UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_widgetExists(
    in EPTF_UIHandler_WidgetIdString pl_WidgetID)
  runs on EPTF_UIHandlerClient_CT
  return EPTF_UIHandler_HandledWidgetType{
    return f_EPTF_UIHandlerClient_widgetExistsOn(pl_WidgetID,v_UIHandlerClient_DefaultUIHandler );  
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_widgetExistsOn
  //  Purpose:
  //    Checks whether the widget exists on the runtime GUI
  //    connected to the specified UIHandler
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_widgetExistsOn(
    in EPTF_UIHandler_WidgetIdString pl_WidgetID,
    in EPTF_UIHandler_CT pl_UIHandler)
  runs on EPTF_UIHandlerClient_CT
  return EPTF_UIHandler_HandledWidgetType{
    if (v_UIHandlerClient_maxTimeoutReached) {
      return wtUnknown;
    }
    var integer vl_semaphoreId := f_EPTF_Semaphore_new();
    var EPTF_UIHandler_WidgetMsg vl_msg;
    f_EPTF_UIHandlerClient_connectUIHandler(pl_UIHandler);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send(t_UIHandler_AdminWidgetExists(pl_WidgetID,vl_semaphoreId)) to pl_UIHandler;
    // wait until reponse is received:
    if (f_EPTF_Semaphore_waitForUnlock(vl_semaphoreId,tsp_EPTF_UIHandlerClient_MaxWaitTime)) {
      f_EPTF_UIHandlerClient_debug(log2str(%definitionId&
          ": MaxWaitTime expired. No reponse received for WidgetExists with Id ",vl_semaphoreId, ". Going on..."));
      v_UIHandlerClient_maxTimeoutReached := true;
      return wtUnknown; // max wait timer expired, no response received in time
    }
    return v_UIHandlerClient_widgetExistsRespList[vl_semaphoreId];
  }


  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_createGUI
  //  Purpose:
  //    Handles the responses to createGUI
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_createGUI(
    in charstring pl_xul,
    in charstring pl_parentWidgetId := "" )
  runs on EPTF_UIHandlerClient_CT
  return EPTF_UIHandlerClient_SubsRet {
    if (v_UIHandlerClient_maxTimeoutReached) {
      return sr_Fail;
    }
    var integer vl_semaphoreId := f_EPTF_Semaphore_new();
    f_EPTF_UIHandlerClient_connectUIHandler(v_UIHandlerClient_DefaultUIHandler);
    v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter + 1;
    v_UIHandlerClient_adminPortIf.send(
      t_UIHandler_AdminCreateGUI( pl_xul, pl_parentWidgetId, vl_semaphoreId )) to v_UIHandlerClient_DefaultUIHandler;
    // wait until reponse is received:
    if (f_EPTF_Semaphore_waitForUnlock(vl_semaphoreId,tsp_EPTF_UIHandlerClient_MaxWaitTime)) {
      f_EPTF_UIHandlerClient_debug(log2str(%definitionId&
          ": MaxWaitTime expired. No reponse received for createGUI with Id ",vl_semaphoreId, ". Going on..."));
      v_UIHandlerClient_maxTimeoutReached := true;
      return sr_Fail; // max wait timer expired, no response received in time
    }
    return v_UIHandlerClient_subsRetList[vl_semaphoreId];
  }

  ///////////////////////////////////////////////////////////
  //  Altstep: as_EPTF_UIHandlerClient_handleCreateGUIResp
  //  Purpose:
  //    Handles the responses to createGUI
  ///////////////////////////////////////////////////////////
  private altstep as_EPTF_UIHandlerClient_handleCreateGUIResp() runs on EPTF_UIHandlerClient_CT {
    var EPTF_UIHandler_WidgetMsg vl_msg;
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminCreateGUIAck(?))-> value vl_msg{
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      v_UIHandlerClient_subsRetList[vl_msg.createGUIAck.messageID] := sr_Success;
      f_EPTF_Semaphore_unlock(vl_msg.createGUIAck.messageID);
      repeat;
    };
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminCreateGUINAck(?))-> value vl_msg{
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      v_UIHandlerClient_subsRetList[vl_msg.createGUINAck.messageID] := sr_Fail;
      f_EPTF_Semaphore_unlock(vl_msg.createGUINAck.messageID);
      repeat;
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Altstep: as_EPTF_UIHandlerClient_handleWidgetExistsResp
  //  Purpose:
  //    Handles the response to the WidgetExists message
  ///////////////////////////////////////////////////////////
  private altstep as_EPTF_UIHandlerClient_handleWidgetExistsResp() runs on EPTF_UIHandlerClient_CT {
    var EPTF_UIHandler_WidgetMsg vl_msg;
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminWidgetExistsResp(*, *, *))-> value vl_msg{
      v_UIHandlerClient_widgetExistsRespList[vl_msg.widgetExistsResp.messageID] := vl_msg.widgetExistsResp.widgetType;
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      f_EPTF_Semaphore_unlock(vl_msg.widgetExistsResp.messageID);
      repeat;
    }
  }

  ///////////////////////////////////////////////////////////
  //  Group: GUIConvenienceFunctions
  //  Purpose:
  //    This group of functions allows adding different kind of 
  //    widgets to the GUI easely
  ///////////////////////////////////////////////////////////
  group GUIConvenienceFunctions {

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addButton
    //  Purpose:
    //    Adds a new button to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_addButton(
      in charstring pl_parentWidgetId,
      in charstring pl_widgetId,
      in charstring pl_label,
      in template float pl_flex := omit, 
      in boolean pl_checked := false,
      in boolean pl_disabled := false,
      in template charstring pl_type := omit, 
      in template charstring pl_imageId := omit) 
    runs on EPTF_UIHandlerClient_CT
    return boolean
    {
      var Widgets vl_xul := {
        button := {
          /*checked :=*/ pl_checked,
          /*customclass := */ omit,
          /*disabled :=*/ pl_disabled,
          /*disabledongui := */ omit,
          /*flex :=*/ valueof(pl_flex),
          /*id :=*/ pl_widgetId,
          /*imageid :=*/ valueof(pl_imageId),
          /*label_ :=*/ pl_label,
          /*tooltiptext :=*/ omit,
          /*type_ :=*/ valueof(pl_type),
          /*externaldata :=*/ omit
        }
      }
      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(vl_xul, pl_parentWidgetId); 
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addSpacer
    //  Purpose:
    //    Adds a new spacer to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_addSpacer(in charstring pl_parentWidgetId, in float pl_flex)
    runs on EPTF_UIHandlerClient_CT
    return boolean
    {
      var Widgets vl_xul := {
        spacer := {
          /*flex :=*/ pl_flex,
          /*id :=*/ omit
        }
      }
      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(vl_xul, pl_parentWidgetId); 
    }


    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addLabel
    //  Purpose:
    //    Adds a new taxt label to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_addLabel(in charstring pl_parentWidgetId, in charstring pl_text)
    runs on EPTF_UIHandlerClient_CT
    return boolean
    {
      var Widgets vl_xul := {
        label_ := {
          /*customclass := */ omit,
          /*disabled :=*/ omit,
          /*disabledongui := */ omit,
          /*flex :=*/ omit,
          /*id:=*/ omit,
          /*style:=*/ omit,
          /*tooltiptext :=*/ omit,
          /*value_ :=*/ pl_text,
          /*externaldata :=*/ omit
        }
      }
      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(vl_xul, pl_parentWidgetId); 
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addEmptyHbox
    //  Purpose:
    //    Adds a new empty HBox to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_addEmptyHbox(
      in charstring pl_parentWidgetId,
      in template charstring pl_widgetId, 
      in template float pl_flex := omit, 
      in boolean pl_horizontal := true,
      in template boolean pl_disabled := omit,
      in template boolean pl_scrollable := omit,
      in template Fixedpositions pl_fixedPosition := omit)
    runs on EPTF_UIHandlerClient_CT
    return boolean
    {
      var template Widgets vl_xul := {
        hbox := {
          /*customclass := */ omit,
          /*disabled :=*/ pl_disabled,
          /*disabledongui := */ omit,
          /*fixedposition :=*/ pl_fixedPosition,
          /*flex :=*/ pl_flex,
          /*id :=*/ pl_widgetId,
          /*orientation :=*/ vertical,
          /*scrollable :=*/ pl_scrollable,
          /*embeddedwidgets :=*/ {{}}
        }
      }
      if(pl_horizontal) { vl_xul.hbox.orientation := horizontal; }
      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(valueof(vl_xul), pl_parentWidgetId); 
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addEmptyTabbox
    //  Purpose:
    //    Adds a new TabBox to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_XSD_addEmptyTabbox(
      in charstring pl_parentWidgetId,
      in charstring pl_widgetId,
      in template float pl_flex:=omit, 
      in template Tablayout pl_listcard:=omit,
      in template boolean pl_disabled := omit)
    runs on EPTF_UIHandlerClient_CT
    return boolean
    {
      template Widgets vl_xul := {
        tabpages := {
          /*customclass := */ omit,
          /*disabled :=*/ omit,
          /*disabledongui := */ omit,
          /*flex :=*/ pl_flex,
          /*id :=*/ pl_widgetId,
          /*layout :=*/ pl_listcard,
          /*tabpages :=*/ {{}}
        }
      }
      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(valueof(vl_xul), pl_parentWidgetId); 
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addEmptyTabpages
    //  Purpose:
    //    Adds a new TabBox to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_XSD_addEmptyTabpages(
      in charstring pl_parentWidgetId,
      in charstring pl_widgetId,
      in template float pl_flex:=omit, 
      in template Tablayout pl_listcard:=omit,
      in template boolean pl_disabled := omit)
    runs on EPTF_UIHandlerClient_CT
    return boolean
    {
      template Widgets vl_xul := {
        tabpages := {
          /*customclass := */ omit,
          /*disabled :=*/ omit,
          /*disabledongui := */ omit,
          /*flex :=*/ pl_flex,
          /*id :=*/ pl_widgetId,
          /*layout :=*/ pl_listcard,
          /*tabpages :=*/ {{}}
        }
      }
      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(valueof(vl_xul), pl_parentWidgetId); 
    }
    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addTabpanel
    //  Purpose:
    //    Adds a new TabPanel to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_addTabpanel(
      in charstring pl_parentWidgetId,
      in charstring pl_widgetId,
      in template float pl_maxheight:=omit, 
      in boolean pl_horizontal := true)
    runs on EPTF_UIHandlerClient_CT
    return boolean
    {
      template Widgets vl_xul := {
        tabpage := {
          /*customclass := */ omit,
          /*disabledongui := */ omit,
          /*id :=*/ pl_widgetId,
          /* label := */ "",
          /*maxheight :=*/ pl_maxheight,
          /*orientation :=*/ vertical,
          /*tooltiptext :=*/ omit,
          /*embeddedwidgets :=*/ {{}}
        }
      }
      if(pl_horizontal) { 

        //vl_xul.xtdp_tabpanel.orient := "horizontal"; 
        f_EPTF_UIHandlerClient_warning(log2str(%definitionId&
            ": horizontal tabpanel is not allowed"));
      }
      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(valueof(vl_xul), pl_parentWidgetId); 
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addTab
    //  Purpose:
    //    Adds a new Tab to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_addTab(
      in charstring pl_parentWidgetId,
      in charstring pl_widgetId,
      in charstring pl_label)
    runs on EPTF_UIHandlerClient_CT
    return boolean
    { 
     
      var Widgets vl_xul := { tabpage := c_EPTF_UIHandler_emptyTabpage };
      vl_xul.tabpage.id := pl_widgetId;
      vl_xul.tabpage.label_ := pl_label;
      vl_xul.tabpage.orientation := vertical;
/*
    XSD.String customclass optional,
    XSD.Boolean disabledongui optional,
+    XSD.String id optional,
+    XSD.String label_,
    XSD.Decimal maxheight optional,
+    Orientation orientation optional,
    XSD.String tooltiptext optional,
    Embeddedwidgets embeddedwidgets
*/       
      vl_xul.tabpage.customclass := omit;
      vl_xul.tabpage.disabledongui := omit;
      vl_xul.tabpage.maxheight := omit;
      vl_xul.tabpage.tooltiptext := omit;
      vl_xul.tabpage.embeddedwidgets := {};
      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(vl_xul, pl_parentWidgetId); 
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addEmptyChart
    //  Purpose:
    //    Adds a new chart to the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_addEmptyChart(
      in charstring pl_parentWidgetId,
      in charstring pl_chartWidgetId,
      in template float pl_flex := omit,
      in charstring pl_title := "Zoomable History chart (click to zoom out)",
      in boolean pl_zoomable := true,
      in template charstring pl_axisXType := omit,
      in template charstring pl_axisYType := omit,
      in template charstring pl_fgColor := omit,
      in template charstring pl_bgColor := omit,
      in template charstring pl_gridColor := omit
    )
    runs on EPTF_UIHandlerClient_CT 
    return boolean
    {
      var template Widgets vl_xul := {
        chart := {
          /*axisXType :=*/ omit,
          /*axisYType :=*/ omit,
          /*backgroundColor :=*/ pl_fgColor,
          /*customclass := */ omit,
          /*disabled :=*/ omit,
          /*disabledongui := */ omit,
          /*flex :=*/ pl_flex,
          /*foregroundColor :=*/  pl_fgColor,
          /*gridColor :=*/ pl_gridColor,
          /*gridX :=*/ true,
          /*gridY :=*/ true,
          /*id :=*/ pl_chartWidgetId,
          /*title :=*/ pl_title,
          /*tooltiptext :=*/ omit,
          /*zoomable :=*/ pl_zoomable ,
          /*choice_list :=*/ {{}}
        }
      }

      var AxisType vl_axisXType;

      // Gigahack with ethjgi's recommendation was log2str!= omit 
      if ( isvalue(pl_axisXType)) {
        f_EPTF_UIHandler_convertAxisType(valueof(pl_axisXType), vl_axisXType);
        vl_xul.chart.axisXType := vl_axisXType
      }

      var AxisType vl_axisYType;

      // Gigahack with ethjgi's recommendation was log2str!= omit 
      if ( isvalue(pl_axisYType)) {
        f_EPTF_UIHandler_convertAxisType(valueof(pl_axisYType), vl_axisYType);
        vl_xul.chart.axisYType := vl_axisYType
      }

      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(valueof(vl_xul), pl_parentWidgetId); 
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_XUL_addTrace2Chart
    //  Purpose:
    //    Adds a new trace to a chart on the GUI
    ///////////////////////////////////////////////////////////
    public function f_EPTF_UIHandlerClient_XUL_addTrace2Chart(
      in charstring pl_parentWidgetId,
      in charstring pl_traceWidgetId,
      in charstring pl_name,
      in template charstring pl_unitX := "Time",
      in template charstring pl_unitY := "Value",
      in template integer pl_maxpoints:=omit,
      in template charstring pl_color := omit,
      in template boolean pl_fill := false  
    )
    runs on EPTF_UIHandlerClient_CT 
    return boolean
    {
      var template Widgets vl_xul := {
        trace := {
          /*color :=*/ pl_color,
          /*fill :=*/ pl_fill,
          /*id :=*/ pl_traceWidgetId,
          /*maxPoints :=*/ omit,
          /*name :=*/ pl_name,
          /*physicalUnitX :=*/ pl_unitX,
          /*physicalUnitY :=*/ pl_unitY,
          /*tooltiptext :=*/ omit,
          /*externaldata :=*/ omit,
          /*choice_list :=*/ {}
        }
      }

      // Gigahack with ethjgi's recommendation was log2str!= omit 
      if ( isvalue(pl_maxpoints)) {
        vl_xul.trace.maxPoints := valueof(pl_maxpoints);
      }

      return f_EPTF_UIHandlerClient_XUL_XSD_addWidget(valueof(vl_xul), pl_parentWidgetId); 
    }

  } // end of convenience functions group

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_logAll
  //  Purpose:
  //    Logs all internal variable in EPTF_UIHandlerClient_CT
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_logAll() runs on EPTF_UIHandlerClient_CT {
    log("------Content of EPTF_UIHandlerClient_CT: -------");

    log("v_UIHandlerClient_initialized: ", v_UIHandlerClient_initialized);
    log("f_EPTF_Base_selfName(): ",f_EPTF_Base_selfName());
    log("v_UIHandlerClient_hangingConnections: ", v_UIHandlerClient_hangingConnections);
    log("v_UIHandlerClient_openUIConnections: ",v_UIHandlerClient_openUIConnections);
    log("v_UIHandlerClient_def: ",v_UIHandlerClient_def);
    log("v_UIHandlerClient_DefaultUIHandler: ",v_UIHandlerClient_DefaultUIHandler);
    log("v_UIHandlerClient_lastRequest: ",v_UIHandlerClient_lastRequest);
    log("------Finished Content of EPTF_UIHandlerClient_CT -------");
  }//f_
} // end of public functions group

//------------------------------------------------------------------------------
// private
//------------------------------------------------------------------------------
group EPTF_UIHandlerClient_Private_Functions{
  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_getMsgId
  //  Purpose:
  //    Increases the message counter and retrieves the new value
  ///////////////////////////////////////////////////////////
  private function f_EPTF_UIHandlerClient_getMsgId()  
  runs on EPTF_UIHandlerClient_CT 
  return integer{
    v_UIHandlerClient_lastRequest := v_UIHandlerClient_lastRequest + 1;
    return v_UIHandlerClient_lastRequest;
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_handleSubsNoteAck
  // 
  //  Purpose:
  //    Handles the acceptance response for a sent subscription note.
  ///////////////////////////////////////////////////////////
  private function f_EPTF_UIHandlerClient_handleSubsNoteAck(
    in integer pl_msgId,
    in EPTF_UIHandler_CT pl_EPTF_CLL_UISubscMgmtMsg_sender)
  runs on EPTF_UIHandlerClient_CT {
    if( not f_EPTF_UIHandlerClient_removeHangingVarConnection(pl_msgId)){ 
      //      log("ERROR: "",Invalid hanging connection response!");
      f_EPTF_UIHandlerClient_error("Invalid hanging connection response!");
      //f_EPTF_Base_stop(); 
    }
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_handleSubsNoteNAck
  // 
  //  Purpose:
  //    Handles the refusion response for a sent subscription note.
  ///////////////////////////////////////////////////////////
  private function f_EPTF_UIHandlerClient_handleSubsNoteNAck(
    in integer pl_messageId,
    in EPTF_UIHandler_CT pl_EPTF_CLL_UISubscMgmtMsg_sender)
  runs on EPTF_UIHandlerClient_CT {
    var EPTF_UIHandlerClient_HangingConnection vl_conn;
    if(f_EPTF_UIHandlerClient_getVarConnection(pl_messageId, vl_conn)){
      //      log("ERROR: ","Subscription note to variable ",vl_conn.varName," has been refused.");
      f_EPTF_UIHandlerClient_error("Subscription note to the variable has been refused.");
    }else{
      //      log("ERROR: "",Invalid hanging connection response!");
      f_EPTF_UIHandlerClient_error( "Invalid hanging connection response!");
      //f_EPTF_Base_stop(); 
    }
  }

  ///////////////////////////////////////////////////////////
  //  Altstep: as_UIHandlerClient_handleSubsNoteResp
  // 
  //  Purpose:
  //    Handles the responses for a sent subscription note.
  ///////////////////////////////////////////////////////////
  private altstep as_UIHandlerClient_handleSubsNoteResp() 
  runs on EPTF_UIHandlerClient_CT{
    var EPTF_UIHandler_WidgetMsg vl_EPTF_CLL_UISubscMgmtMsg;
    var EPTF_UIHandler_CT vl_EPTF_CLL_UISubscMgmtMsg_sender;
    //There is no NAck, then it simple stops
    [] v_UIHandlerClient_adminPortIf.receive( {subscribeAck := ?} ) -> 
    value vl_EPTF_CLL_UISubscMgmtMsg 
    sender vl_EPTF_CLL_UISubscMgmtMsg_sender {
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      f_EPTF_UIHandlerClient_handleSubsNoteAck(
        vl_EPTF_CLL_UISubscMgmtMsg.subscribeAck.requestId,
        vl_EPTF_CLL_UISubscMgmtMsg_sender);
      f_EPTF_Semaphore_unlock(vl_EPTF_CLL_UISubscMgmtMsg.subscribeAck.requestId);
      repeat;
    }
    [] v_UIHandlerClient_adminPortIf.receive( {subscribeNAck := ?} ) -> 
    value vl_EPTF_CLL_UISubscMgmtMsg 
    sender vl_EPTF_CLL_UISubscMgmtMsg_sender {
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      f_EPTF_UIHandlerClient_handleSubsNoteNAck(
        vl_EPTF_CLL_UISubscMgmtMsg.subscribeNAck.requestId,
        vl_EPTF_CLL_UISubscMgmtMsg_sender);
      f_EPTF_Semaphore_unlock(vl_EPTF_CLL_UISubscMgmtMsg.subscribeNAck.requestId);
      repeat;
    }
  }

  ///////////////////////////////////////////////////////////
  //  Altstep: as_handle_main_EPTF_UIHandlerClient_MgmtIf
  // 
  //  Purpose:
  //    The main altstep of the UIHandlerClient.
  ///////////////////////////////////////////////////////////
  private altstep as_handle_main_EPTF_UIHandlerClient_MgmtIf() runs on EPTF_UIHandlerClient_CT {
    [] as_UIHandlerClient_handleSubsNoteResp();
    [] as_EPTF_UIHandlerClient_handleAddElementToGUIResp();
    [] as_EPTF_UIHandlerClient_handleCreateGUIResp();
    [] as_EPTF_UIHandlerClient_handleWidgetExistsResp();
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminEnableWidgetAck(?)){
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      repeat;
    }; 
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminEnableWidgetNAck(?)){
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      repeat;
    }; 
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminDisableWidgetAck(*)){
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      repeat;
    }; 
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminDisableWidgetNAck(*)){
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      repeat;
    }; 
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminSetFocusToWidgetAck(*)){
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      repeat;
    }; 
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminSetFocusToWidgetNAck(*)){
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      repeat;
    }; 
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminRemoveElementFromGUIAck(?)){
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      repeat;
    }; 
    [] v_UIHandlerClient_adminPortIf.receive(t_UIHandler_AdminRemoveElementFromGUINAck(?)){
      v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
      repeat;
    }; 
  }
  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_cleanup_CT
  //  Purpose:
  //    Closes the open management ports
  //  Detailed Comments:
  //    This function mustn't be called directly. You must call f_EPTF_Base_cleanup_CT instead.
  ///////////////////////////////////////////////////////////
  private function f_EPTF_UIHandlerClient_cleanup_CT() runs on EPTF_UIHandlerClient_CT {
    if (v_UIHandlerClient_initialized) {

      // wait for receiving all pending messages
      timer t_wait := 0.0;
      t_wait.start;
      timer t_maxWait := tsp_EPTF_UIHandlerClient_maxKillTime;
      t_maxWait.start;
      f_EPTF_UIHandlerClient_debug(log2str(%definitionId&": Waiting for all UIHandler Clients to stop..."));
      var EPTF_UIHandler_WidgetMsg vl_msg;
      alt {
        [v_UIHandlerClient_pendingMsgCounter == 0 or v_UIHandlerClient_maxTimeoutReached] t_wait.timeout;
        [] t_maxWait.timeout {
          f_EPTF_UIHandlerClient_warning(log2str(%definitionId&
              ": MaxWaitTime expired. Not all the pending messages received (still pending:",v_UIHandlerClient_pendingMsgCounter,"). Exiting anyway..."));
        }
        // drop all messages to prevent deadlock (cleanup blocks the function in the alt that calls TP.receive to wait for answer e.g: subscribeMe):
        [] v_UIHandlerClient_adminPortIf.receive(?) -> value vl_msg{
          v_UIHandlerClient_pendingMsgCounter := v_UIHandlerClient_pendingMsgCounter - 1;
          f_EPTF_UIHandlerClient_debug(log2str(
              ": Unexpected message received during cleanup. Message dropped: ",vl_msg));
          repeat;
        }; 
      }

      // iterate through the connected UIHandlers and disconnect them
      for( var integer i := 0; i < sizeof(v_UIHandlerClient_openUIConnections); i := i + 1 ){
        if(v_UIHandlerClient_openUIConnections[i] != null) {
          f_EPTF_UIHandlerClient_closeUIPortToIdx(i);
        }
      }
    }
    v_UIHandlerClient_pendingMsgCounter := 0;
    v_UIHandlerClient_hangingConnections := {};
    //v_openConnections := {};
    v_UIHandlerClient_openUIConnections := {};
    v_UIHandlerClient_initialized := false;
    deactivate(v_UIHandlerClient_def)
    //    log("DEBUG: ","----CLL_UIHandlerClient cleanup DONE----");
    f_EPTF_UIHandlerClient_debug("----CLL_UIHandlerClient cleanup DONE----");
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_UIHandlerClient_XUL_addWidget
  //  Purpose:
  //    Adds a widget to the GUI
  //  Detailed Comments:
  //    This function is used by the convenience functions.
  ///////////////////////////////////////////////////////////
  public function f_EPTF_UIHandlerClient_XUL_XSD_addWidget(in Widgets pl_xul, in charstring pl_parentWidgetId) 
  runs on EPTF_UIHandlerClient_CT
  return boolean 
  {
    if(sr_Success != f_EPTF_UIHandlerClient_XSD_addElementToGUI(pl_xul, pl_parentWidgetId)) {
      f_EPTF_UIHandlerClient_debug(log2str("Could not add element to GUI: ", pl_xul, ", parent:", pl_parentWidgetId));
      return false;
    }
    return true;
  } 

  ///////////////////////////////////////////////////////////
  //  Group: UIHandlerClient_SubscriptionAdministration
  //  Purpose:
  //    Administers the hanging subscriptions from sending to 
  //    the arrival of the ACK or the NACK 
  ///////////////////////////////////////////////////////////
  group UIHandlerClient_SubscriptionAdministration{
    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_removeHangingVarConnection
    //  Purpose:
    //    Clears the record about the given subscription
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_removeHangingVarConnection(in integer pl_messageId) 
    runs on EPTF_UIHandlerClient_CT
    return boolean{
      var integer vl_i := f_EPTF_UIHandlerClient_varConnectionIndex(pl_messageId);
      if(-1 == vl_i){ return false;};
      v_UIHandlerClient_hangingConnections[vl_i] := {null,"",-1};
      return true;
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_varConnectionIndex
    //  Purpose:
    //    Returns the index of the hanging subscription note record
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_varConnectionIndex(in integer pl_messageId) 
    runs on EPTF_UIHandlerClient_CT
    return integer {
      for( var integer i := 0; i < sizeof(v_UIHandlerClient_hangingConnections); i := i + 1 ){
        if(v_UIHandlerClient_hangingConnections[i].messagId == pl_messageId) { return i; }
      }
      return -1;
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_getVarConnection
    //  Purpose:
    //    Returns the hanging subscription note record
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_getVarConnection(
      in integer pl_messageId, 
      out EPTF_UIHandlerClient_HangingConnection pl_hangingConnection) 
    runs on EPTF_UIHandlerClient_CT 
    return boolean{
      var integer vl_connIdx := f_EPTF_UIHandlerClient_varConnectionIndex(pl_messageId);
      if(-1 == vl_connIdx){
        pl_hangingConnection := v_UIHandlerClient_hangingConnections[vl_connIdx];
      }
      return -1 != vl_connIdx;
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_addVarConnection
    //  Purpose:
    //    Adds a record about the subscription note to the list
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_addVarConnection(
      in EPTF_UIHandler_CT pl_RemoteCompRef,
      in charstring pl_ProvidedParamName,
      in integer pl_messageId) 
    runs on EPTF_UIHandlerClient_CT {
      var EPTF_UIHandlerClient_HangingConnection vl_hangingConnection := {pl_RemoteCompRef,pl_ProvidedParamName,pl_messageId};
      if( -1 == f_EPTF_UIHandlerClient_varConnectionIndex(pl_messageId) ) {
        v_UIHandlerClient_hangingConnections[sizeof(v_UIHandlerClient_hangingConnections)] := vl_hangingConnection;
      };
      f_EPTF_UIHandlerClient_connectUIHandler(pl_RemoteCompRef);
    }
  }  // end of subscription admin group 

  ///////////////////////////////////////////////////////////
  //  Group: UIHandlerClient_PortAdministration
  //  Purpose:
  //    Administers the connected <v_UIHandlerClient_adminPortIf> ports
  ///////////////////////////////////////////////////////////
  group UIHandlerClient_PortAdministration{

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_connectUIHandler
    //  Purpose:
    //    Connects the v_UIHandlerClient_adminPortIf port to the specified 
    //    UIHandler and registers the connection
    ///////////////////////////////////////////////////////////
    //UI connection handling
    private function f_EPTF_UIHandlerClient_connectUIHandler(
      in EPTF_UIHandler_CT pl_RemoteCompRef) 
    runs on EPTF_UIHandlerClient_CT {
      if( -1 == f_EPTF_UIHandlerClient_connectionIndex(pl_RemoteCompRef) ) {
        connect(self:v_UIHandlerClient_adminPortIf,pl_RemoteCompRef:EPTF_adminPort_CP);
        v_UIHandlerClient_openUIConnections[sizeof(v_UIHandlerClient_openUIConnections)] := pl_RemoteCompRef;
      };
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_connectionIndex
    //  Purpose:
    //    Returns the index of the open connection record
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_connectionIndex(in EPTF_UIHandler_CT pl_handler) 
    runs on EPTF_UIHandlerClient_CT
    return integer {
      for( var integer i := 0; i < sizeof(v_UIHandlerClient_openUIConnections); i := i + 1 ){
        if(v_UIHandlerClient_openUIConnections[i] == pl_handler) { return i; }
      }
      return -1;
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_closeUIPortToIdx
    //  Purpose:
    //    Closes the specified connection
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_closeUIPortToIdx(in integer pl_handlerIdx)
    runs on EPTF_UIHandlerClient_CT{
      disconnect(self:v_UIHandlerClient_adminPortIf, v_UIHandlerClient_openUIConnections[pl_handlerIdx]:EPTF_adminPort_CP); 
      v_UIHandlerClient_openUIConnections[pl_handlerIdx] := null;
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_closeUIPortToUIHandler
    //  Purpose:
    //    Closes the specified connection
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_closeUIPortToUIHandler(in EPTF_UIHandler_CT pl_handler) 
    runs on EPTF_UIHandlerClient_CT
    return boolean{
      var integer i := f_EPTF_UIHandlerClient_connectionIndex(pl_handler);
      if(-1 == i){ return false;};
      f_EPTF_UIHandlerClient_closeUIPortToIdx(i);
      return true;
    }
  }  // end of port administration group

  group Logging {
    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_error
    // 
    //  Purpose:
    //    Function to log an error from UIHandlerClient feature.
    //
    //  Parameters:
    //    - pl_message - *in* *charstring* - the message to log
    //
    //  Return Value:
    //    -
    //
    //  Errors & assertions:
    //    - 
    //
    //  Detailed Comments:
    //    -
    //
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_error(in charstring pl_message)
    runs on EPTF_UIHandlerClient_CT
    {
      f_EPTF_Logging_error(true, tsp_EPTF_UIHandlerClient_loggingComponentMask&": "&pl_message);
      f_EPTF_Base_stopAll();
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_warning
    // 
    //  Purpose:
    //    Function to log a warning from UIHandlerClient feature.
    //
    //  Parameters:
    //    - pl_message - *in* *charstring* - the message to log
    //
    //  Return Value:
    //    -
    //
    //  Errors & assertions:
    //    - 
    //
    //  Detailed Comments:
    //    -
    //
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_warning(in @lazy charstring pl_message)
    runs on EPTF_UIHandlerClient_CT
    {
      f_EPTF_Logging_warningV2(pl_message, v_UIHandlerClient_loggingMaskId, {c_EPTF_UIHandler_loggingClassIdx_Warning});
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_debug
    // 
    //  Purpose:
    //    Function to log a debug message from UIHandlerClient feature.
    //
    //  Parameters:
    //    - pl_message - *in* *charstring* - the message to log
    //
    //  Return Value:
    //    -
    //
    //  Errors & assertions:
    //    - 
    //
    //  Detailed Comments:
    //    -
    //
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_debug(in @lazy charstring pl_message)
    runs on EPTF_UIHandlerClient_CT
    {
      f_EPTF_Logging_debugV2(pl_message, v_UIHandlerClient_loggingMaskId, {c_EPTF_UIHandler_loggingClassIdx_Debug});
    }

    ///////////////////////////////////////////////////////////
    //  Function: f_EPTF_UIHandlerClient_debugEnabled
    // 
    //  Purpose:
    //    Function to check if debug is enabled for UIHandlerClient
    //
    //  Parameters:
    //    -
    //
    //  Return Value:
    //    *boolean* - true if debug enalbed
    //
    //  Errors & assertions:
    //    - 
    //
    //  Detailed Comments:
    //    -
    //
    ///////////////////////////////////////////////////////////
    private function f_EPTF_UIHandlerClient_debugEnabled()
    runs on EPTF_UIHandlerClient_CT
    return boolean
    {
      return f_EPTF_Logging_isEnabled(v_UIHandlerClient_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
    }

  }  // end of logging group

}  // end of private group

}  // end of module