| ///////////////////////////////////////////////////////////////////////////////
|
| // //
|
| // Copyright (c) 2000-2017 Ericsson Telecom AB // |
| // // |
| // All rights reserved. This program and the accompanying materials // |
| // are made available under the terms of the Eclipse Public License v1.0 // |
| // which accompanies this distribution, and is available at // |
| // http://www.eclipse.org/legal/epl-v10.html //
|
| ///////////////////////////////////////////////////////////////////////////////
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Module: EPTF_CLL_UIHandler_WidgetFunctions
|
| //
|
| // Purpose:
|
| // This module contains widget manipulation functions of EPTF_UIHandler_CT.
|
| //
|
| // Module Parameters:
|
| // charstring tsp_EPTF_GUI_Main_Window_WidgetId := "EPTF_Main_Window"; used in
|
| // <f_EPTF_UIHandler_addWindow> creating a new window
|
| // charstring tsp_EPTF_GUI_Main_Toolbar_WidgetId := "EPTF_Main_Toolbar";
|
| // float tsp_EPTF_GUI_Main_Window_Width := 820.0; used in
|
| // <f_EPTF_UIHandler_addWindow> creating a new window
|
| // float tsp_EPTF_GUI_Main_Window_Height := 386.0; used in
|
| // <f_EPTF_UIHandler_addWindow> creating a new window
|
| // charstring tsp_EPTF_GUI_Main_Window_Title := "TTCN constructed window"; used in
|
| // <f_EPTF_UIHandler_addWindow> creating a new window
|
| // charstring tsp_xtdp_listen_addr := "127.0.0.1";
|
| // integer tsp_xtdp_listen_port := 11420;
|
| // charstring tsp_EPTF_savedGUIPrefix := "GUI"; used to create a snapshot
|
| // config file about the GUI
|
| // charstring tsp_EPTF_GUI_DefaultWindow := ""; If it isn't empty, the
|
| // EPTF_UIHandler_CT tries to create a window by this string. It
|
| // can be created by the <f_EPTF_UIHandler_snapshot> and
|
| // <f_EPTF_UIHandler_saveLayout> functions.
|
| // charstring tsp_EPTF_UIHandler_Authmsg := "Enter password" This is the question
|
| // for XTDP authentication that the user of the RuntimeGUI has to answer.
|
| // If it is empty, no authentication performed
|
| // charstring tsp_EPTF_UIHandler_Authresp := ""; This is the expected
|
| // answer for the question <tsp_EPTF_UIHandler_Authmsg> during XTDP
|
| // authentication. If the answer given on RuntimeGUI does not match this
|
| // parameter, the authentication fails and XTDP session will be closed.
|
| // UIHander will enter into headless mode.
|
| // If it is empty, no authentication performed
|
| // float tsp_EPTF_UIHandler_handshakeMaxTimer := 1.0; This is the max handshake
|
| // time for the XDTP protocol. The handshake response should arrive less than
|
| // this time. (See the XTDP protocol module FS for more details)
|
| // float tsp_EPTF_UIHandler_authMaxTimer := 1.0; This is the max authentication time.
|
| // for the XDTP protocol. The authentication response should arrive less than
|
| // this time. (See the XTDP protocol module FS for more details)
|
| // float tsp_EPTF_UIHandler_byeMaxTimer := 1.0; This is the max bye time.
|
| // for the XDTP protocol. The bye response should arrive less than
|
| // this time. (See the XTDP protocol module FS for more details)
|
| // float tsp_EPTF_UIHandler_maxGUIWaitTime := 30.0; The max wait time in the
|
| // init function of the UIhandler (<f_EPTF_UIHandler_init_CT>) to wait
|
| // until Runtime GUI is connected.
|
| //
|
| // Module depends on:
|
| // <XTDPasp_Types>
|
| // <XTDP_PDU_Defs>
|
| // <XUL_XTDL language>
|
| // <EPTF_CLL_UIHandler_MsgDefinitions>
|
| // <EPTF_CLL_UIHandler_Definitions>
|
| // <EPTF_CLL_UIHandler_PrivateFunctions>
|
| // <EPTF_CLL_Base_Definitions>
|
| // <EPTF_CLL_Base_Functions>
|
| // <EPTF_CLL_UIHandler_XTDPTemplateDefinitions>
|
| // <EPTF_CLL_Variable_Definitions>
|
| // <EPTF_CLL_Variable_Functions>
|
| // <EPTF_CLL_UIHandler_ConvertFunctions>
|
| // <EPTF_CLL_Common_Definitions>
|
| // <EPTF_CLL_HashMapStr2Int_Functions>
|
| // <EPTF_CLL_HashMapInt2Int_Functions>
|
| // <EPTF_CLL_Logging_Definitions>
|
| // <EPTF_CLL_Logging_Functions>
|
| // <TCCFileIO_Functions>
|
| // <TCCDateTime_Functions>
|
| // <EPTF_CLL_TransportIPL4_Functions>
|
| // <EPTF_CLL_Transport_CommonDefinitions>
|
| // <EPTF_CLL_Semaphore_Functions>
|
| // <EPTF_CLL_UIHandler_CLIClientDefinitions>
|
| // <EPTF_CLL_UIHandlerCLI_CommandDefinitions>
|
| // <EPTF_CLL_CLI_Functions>
|
| // <EPTF_CLL_CLI_Definitions>
|
| // <Socket_API_Definitions>
|
| // <EPTF_CLL_HashMap_Functions>
|
| //
|
| // Current Owner:
|
| // EFLOATT
|
| //
|
| // Last Review Date:
|
| // 2010-xx-xx
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////////
|
| module EPTF_CLL_UIHandler_WidgetFunctions
|
| // [.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_UIHandler_Definitions all;
|
| import from EPTF_CLL_Base_Functions all;
|
| import from EPTF_CLL_UIHandler_XSD_XTDPTemplateDefinitions all;
|
| import from EPTF_CLL_Variable_Definitions all;
|
| import from EPTF_CLL_Variable_Functions all;
|
| import from EPTF_CLL_UIHandler_ConvertFunctions all;
|
| import from EPTF_CLL_Common_Definitions all;
|
| import from EPTF_CLL_Common_Functions all;
|
| import from EPTF_CLL_HashMapStr2Int_Functions all;
|
| import from EPTF_CLL_HashMapInt2Int_Functions all;
|
| import from EPTF_CLL_Logging_Definitions all;
|
| import from EPTF_CLL_Logging_Functions all;
|
| import from TCCFileIO_Functions all;
|
| import from TCCDateTime_Functions all;
|
| import from TCCConversion_Functions all;
|
| import from EPTF_CLL_TransportIPL4_Functions all;
|
| import from EPTF_CLL_Transport_CommonDefinitions all;
|
| import from EPTF_CLL_TransportMessageBufferManager_Functions all;
|
| import from EPTF_CLL_Semaphore_Functions all;
|
|
|
| import from EPTF_CLL_UIHandler_CLIClientDefinitions all;
|
| import from EPTF_CLL_CLI_Functions all;
|
| import from EPTF_CLL_CLI_Definitions all;
|
| import from Socket_API_Definitions all
|
|
|
| import from XTDP_EncDecFunctions all;
|
| import from ttcn_ericsson_se_protocolModules_xtdp_xtdl all;
|
| import from ttcn_ericsson_se_protocolModules_xtdp_xtdp all;
|
| import from EPTF_CLL_DataSource_Definitions all;
|
| import from EPTF_CLL_DataSource_Functions all;
|
| import from EPTF_CLL_UIHandler_DS_Definitions all;
|
| import from EPTF_CLL_UIHandler_DS_Functions all;
|
| import from EPTF_CLL_DataSourceClient_Functions all;
|
| import from EPTF_CLL_HashMap_Functions all;
|
| import from EPTF_CLL_StatManager_Functions all;
|
| import from EPTF_CLL_UIHandler_BrowserFunctions all;
|
|
|
| import from EPTF_CLL_UIHandler_ChartDataTypeRingBuffer_Functions all;
|
|
|
| //=========================================================================
|
| // Module Parameters
|
| //=========================================================================
|
| modulepar {
|
| charstring tsp_EPTF_GUI_Main_Window_WidgetId := "EPTF_Main_Window";
|
| charstring tsp_EPTF_GUI_Main_Toolbar_WidgetId := "EPTF_Main_Toolbar";
|
| charstring tsp_EPTF_GUI_Main_Tabbox_WidgetId := "EPTF_Main_Tabbox";
|
| float tsp_EPTF_GUI_Main_Window_Width := 820.0;
|
| float tsp_EPTF_GUI_Main_Window_Height := 386.0;
|
| charstring tsp_EPTF_GUI_Main_Window_Title := "TTCN constructed window";
|
| charstring tsp_xtdp_listen_addr := "127.0.0.1";
|
| integer tsp_xtdp_listen_port := 11420;
|
| integer tsp_EPTF_UIHandler_udp_port := 3333; // remote port number for pinger port
|
| charstring tsp_EPTF_UIHandler_localPingerAddr := c_ipv4AnyAddr;
|
| integer tsp_EPTF_UIHandler_localPingerPort := c_anyPort; // 0-> let the kernel choose a local port number automatically
|
| charstring tsp_EPTF_savedGUIPrefix := "GUI";
|
| charstring tsp_EPTF_GUI_DefaultWindow := ""; // OUTDATED, remove it from any config
|
| charstring tsp_EPTF_GUI_DefaultWindowXTDL := "";
|
| boolean tsp_EPTF_UIHandler_headlessmode := true;
|
| boolean tsp_EPTF_UIHandler_servermode := false;
|
| charstring tsp_EPTF_UIHandler_Authmsg := "Enter password";
|
| charstring tsp_EPTF_UIHandler_Authresp := "";
|
| float tsp_EPTF_UIHandler_handshakeMaxTimer := 1.0;
|
| float tsp_EPTF_UIHandler_authMaxTimer := 1.0;
|
| float tsp_EPTF_UIHandler_byeMaxTimer := 1.0;
|
| float tsp_EPTF_UIHandler_bufferedXTDP := 0.5;
|
| float tsp_EPTF_UIHandler_connecttimer := 5.0;
|
| float tsp_EPTF_UIHandler_maxWaitTimer := 5.0;
|
| integer tsp_EPTF_UIHandler_CommPortIPL4_minBufferSize := 2000;
|
| boolean tsp_debug_EPTF_UIHandler_Functions := false;
|
| float tsp_EPTF_UIHandler_maxGUIWaitTime := 30.0;
|
| boolean tsp_EPTF_UIHandler_enableBrowserGUI := true;
|
| EPTF_Var_SubscriptionMode tsp_EPTF_UIHandler_subscriptionMode := sampled; // sampled is the default for tsp_EPTF_DataSource_subscriptionMode, with pull widgets on RuntimeGUI do not update
|
| }
|
|
|
| friend module EPTF_CLL_UIHandlerVariableUI_Functions, EPTF_CLL_UIHandlerCLI_Functions,EPTF_CLL_UIHandler_XULFunctions;
|
| friend module EPTF_UIHandler_Test_Testcases, EPTF_CLL_UIHandler_BrowserFunctions;
|
| friend module EPTF_UIHandler_Test_Functions;
|
|
|
| const charstring cg_ExternalVariableSign := "__ExternalValue";
|
|
|
| //=========================================================================
|
| // Public functions
|
| //=========================================================================
|
| group PublicFunctions {
|
|
|
| public external function f_EPTF_UIHandler_init_XML();
|
| public external function f_EPTF_UIHandler_cleanup_XML();
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_init_CT
|
| //
|
| // Purpose:
|
| // Initialises the EPTF_UIHandler_CT
|
| //
|
| // Parameters:
|
| // pl_selfName - *in* *charstring* - the name used in the initialization
|
| // of the f_EPTF_Base_CT
|
| // pl_CLI_compRef - *in* <EPTF_CLI_CT> - the CLI to use.
|
| // Default: null (== local CLI ports are disabled)
|
| // pl_connectGUI - *in* *boolean* - default: true. If it is true
|
| // UIHandler will try to connect to the RuntimeGUI and will perform
|
| // the XTDP handshake and authentication. The init function will
|
| // exit after the XTDP session is connected. If the transport connection
|
| // failed but the headless mode is true, the init function will exit
|
| // with XTDP session not established and the UIHandler will enter
|
| // into headless mode.
|
| // pl_windowLayout - *in template* *charstring* - This parameter defines the initial
|
| // gui layout in xml format. Must fit the XTDL.xsd. If it is omit (default value),
|
| // UIHandler gets the <tsp_EPTF_GUI_DefaultWindowXTDL> module parameter, which can
|
| // describe the GUI true. If it contains an empty string, there is no initial GUI.
|
| // pl_prefix - *in* *charstring* - (default:tsp_EPTF_UIHandler_CLIPrefix) -
|
| // common prefix for the UIHandler Command-Line Interface commands
|
| // pl_simulationMode - *in* *boolean* - (default:false) -
|
| // If this parameter is true, UIHandler will be initialized in simulation mode
|
| // pl_simulation_buildDB_file - *in* *charstring* - (default:"") -
|
| // The parameter is definies the file, what will be used to save the database
|
| // or load the database in simulation mode
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // Error occurs in client mode (i.e. if tsp_EPTF_UIHandler_servermode is false)
|
| // if
|
| // - pl_connectGUI true, headless mode is false, and it is not possible
|
| // to connect to the RuntimeGUI.
|
| // - pl_connectGUI false and headless mode is false
|
| // - pl_connectGUI true but XTDP handshake&authentication is not
|
| // performed in time (during tsp_EPTF_UIHandler_maxGUIWaitTime seconds)
|
| //
|
| // Detailed Comments:
|
| // This function should be called before using the EPTF_UIHandler_CT
|
| // component.
|
| // Currently simulation mode is not supported, so do not change the values of
|
| // the following parameters:
|
| // pl_simulationMode
|
| // pl_simulation_buildDB_file
|
| // To get it (simulation mode) working nonblocking version of the f_EPTF_UIHandler_simulation_getData
|
| // function needs to be implemented.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_init_CT(
|
| in charstring pl_selfName,
|
| in boolean pl_connectGUI := true,
|
| in template charstring pl_windowLayout := "",
|
| in EPTF_CLI_CT pl_CLI_compRef := null,
|
| in charstring pl_prefix := tsp_EPTF_UIHandler_CLIPrefix,
|
| in boolean pl_simulationMode := false,
|
| in charstring pl_simulation_buildDB_file := "",
|
| in boolean pl_headlessmode := tsp_EPTF_UIHandler_headlessmode,
|
| in boolean pl_servermode := tsp_EPTF_UIHandler_servermode,
|
| in charstring pl_authresp := tsp_EPTF_UIHandler_Authresp )
|
| runs on EPTF_UIHandler_Private_CT {
|
| if (not v_UIHandler_initialized) {
|
| v_EPTF_UIHandler_simulatonMode := pl_simulationMode;
|
| v_EPTF_UIHandler_simulation_buildDB_file := pl_simulation_buildDB_file;
|
| v_UIHandler_simulation_directContentDB := {};
|
|
|
| if(isvalue(pl_windowLayout)){
|
| v_UIHandler_windowLayout := valueof(pl_windowLayout);
|
| v_UIHandler_emptyGUI := false;
|
| }else{
|
| v_UIHandler_windowLayout := "";
|
| v_UIHandler_emptyGUI := true;
|
| }
|
| v_EPTF_UIHandler_createLayoutCallback := refers(f_EPTF_UIHandler_newCreateInitialLayout);
|
| f_EPTF_UIHandler_init_XML();
|
| f_EPTF_UIHandler_initComponent(pl_selfName, pl_CLI_compRef, pl_prefix, pl_headlessmode, pl_servermode, pl_authresp);
|
| f_EPTF_UIHandler_connect(pl_connectGUI);
|
| f_EPTF_UIHandler_simulation_Subscribe2saveDBButton_vars();
|
|
|
| if(v_EPTF_UIHandler_simulatonMode == true) {
|
| f_EPTF_UIHandler_simulation_createDBFromFile(pl_simulation_buildDB_file, v_UIHandler_simulation_directContentDB);
|
| var integer vl_directContentDBSize := sizeof(v_UIHandler_simulation_directContentDB);
|
| for(var integer vl_i := 0; vl_i < vl_directContentDBSize; vl_i := vl_i + 1) {
|
| f_EPTF_str2int_HashMap_Insert(v_UIHandler_simulation_varsHashMapId, v_UIHandler_simulation_directContentDB[vl_i].key, vl_i);
|
| f_EPTF_Var_newVar(v_UIHandler_simulation_directContentDB[vl_i].key, v_UIHandler_simulation_directContentDB[vl_i].directContent)
|
| }
|
| }
|
| v_EPTF_UIHandler_WidgetFunctions_XTDP_XSD_filepath := "";
|
| }
|
| }
|
|
|
| friend function f_EPTF_UIHandler_initComponent(
|
| in charstring pl_selfName,
|
| in EPTF_CLI_CT pl_CLI_compRef := null,
|
| in charstring pl_prefix := tsp_EPTF_UIHandler_CLIPrefix,
|
| in boolean pl_headlessmode := tsp_EPTF_UIHandler_headlessmode,
|
| in boolean pl_servermode := tsp_EPTF_UIHandler_servermode,
|
| in charstring pl_authresp := tsp_EPTF_UIHandler_Authresp)
|
| runs on EPTF_UIHandler_Private_CT {
|
| v_EPTF_UIHandler_headlessmode := pl_headlessmode;
|
| v_EPTF_UIHandler_servermode := pl_servermode;
|
| v_EPTF_UIHandler_Authresp := pl_authresp;
|
|
|
| v_UIHandler_initToGUIClient := false;
|
| v_UIHandler_createGUIRunning := false;
|
| t_UIHandler_initGUIToClientTimer.start;
|
|
|
| v_UIHandler_cleanupCalled := false;
|
| v_UIHandler_openSubscriptions := {};
|
| v_UIHandler_subscriptions := {};
|
| v_UIHandler_guiLayoutReady := false;
|
| v_UIHandler_guiItemList := {};
|
| v_UIHandler_tracePointers := {};
|
| v_UIHandler_windowIndex := -1;
|
|
|
| //KI - 2013.11.04. - ez kimehetne, most kikotom a hasznalatat
|
| v_UIHandler_GUI_DescriptionDB := {};
|
| v_UIHandler_GUI_DescriptionDB_Idx := -1;
|
|
|
| v_UIHandler_nofRunning_processExternalData_handlers := 0;
|
| v_UIHandler_GUIFunctions_nofRunning_processExternalData_handlers := {}; // used to wait for all EPTF_CLL_UIHandler_GUIFunctions.cc[expand_current_node] functions to finish
|
|
|
| f_EPTF_HashMap_init_CT (pl_selfName);
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets := {};
|
|
|
| v_handshakeMaxTime := tsp_EPTF_UIHandler_handshakeMaxTimer;
|
| v_handshakeErrorMsg := "";
|
|
|
| v_authMaxTime := tsp_EPTF_UIHandler_authMaxTimer;
|
| v_byeMaxTime := tsp_EPTF_UIHandler_byeMaxTimer;
|
| v_UIHandler_byeTimer := -1;
|
|
|
| f_EPTF_Var_init_CT(pl_selfName);
|
| f_EPTF_Logging_init_CT(pl_selfName);
|
| f_EPTF_DataSource_init_CT(pl_selfName);
|
| f_EPTF_StatManager_init_CT(pl_selfName);
|
| if(self == pl_CLI_compRef) {
|
| // if I am the CLI: initialize it (with telnet ports enabled):
|
| f_EPTF_CLI_init_CT(pl_selfName)
|
| } else {
|
| // if remote or null CLI is used, disable all telnet ports in the CLI:
|
| f_EPTF_CLI_init_CT(pl_selfName,*,*);
|
| }
|
| // NOTE:
|
| // If pl_CLI_compRef is null: the CLI client will be initialized with self as CLI
|
| // and the commands will be registered also.
|
| // This is because if f_EPTF_UIHandler_CLI_init_CT is called later,
|
| // that will enable the telnet ports, so the commands should be there.
|
| if(null == pl_CLI_compRef){pl_CLI_compRef := self}
|
| f_EPTF_CLI_Client_init_CT(pl_selfName, pl_CLI_compRef)
|
| f_EPTF_UIHandler_CLIClient_init_CT(pl_prefix);
|
| f_EPTF_DataSource_CLI_init_CT(pl_selfName, pl_CLI_compRef);
|
| v_UIHandler_loggingMaskId := f_EPTF_Logging_registerComponentMasks(tsp_EPTF_UIHandler_loggingComponentMask, c_EPTF_UIHandler_loggingEventClasses, EPTF_Logging_CLL);
|
| if(tsp_debug_EPTF_UIHandler_Functions) {
|
| f_EPTF_Logging_enableLocalMask(v_UIHandler_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
|
| } else {
|
| f_EPTF_Logging_disableLocalMask(v_UIHandler_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
|
| }
|
|
|
| v_UIHandler_widgetHashMapId := f_EPTF_str2int_HashMap_New(c_EPTF_UIHandler_widgetIdHashMapName);
|
| v_UIHandler_tracePointerHashMapId := f_EPTF_int2int_HashMap_New(c_EPTF_UIHandler_tracePointerHashMapName);
|
| v_UIHandler_subscriptionHashMapId := f_EPTF_str2int_HashMap_New(c_EPTF_UIHandler_subscriptionHashMapName);
|
| v_UIHandler_subscriptionHashMapIdVar := f_EPTF_str2int_HashMap_New(c_EPTF_UIHandler_subscriptionHashMapNameVar);
|
| v_UIHandler_simulation_varsHashMapId := f_EPTF_str2int_HashMap_New(c_EPTF_UIHandler_simulation_varsHashMapName);
|
|
|
| f_EPTF_Semaphore_init_CT(pl_selfName);
|
| v_UIHandler_xtdpReceivedMessageSemaphore_r := f_EPTF_Semaphore_new();
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| v_UIHandler_layoutResponseReceivedSemaphore := f_EPTF_Semaphore_new();
|
| v_UIHandler_exitButtonPressedSemaphore := f_EPTF_Semaphore_new();
|
|
|
| v_UIHandler_progressEnabled := true;
|
|
|
| f_EPTF_UIHandler_initProgressBar();
|
|
|
| f_EPTF_Transport_init(IPL4, pl_selfName)
|
| //FIXME use the new API
|
| f_EPTF_Transport_registerMsgLenCallback4LGenType(IPL4, refers(f_EPTF_UIHandler_getMsgLen_XTDP), {}, c_EPTF_UIHandler_XTDPType);
|
| f_EPTF_Transport_registerMsgCallback(IPL4, c_EPTF_UIHandler_XTDPType, refers(f_EPTF_UIHandler_HandleMsgs_XTDP), refers(f_EPTF_UIHandler_HandleEvent_XTDP));
|
|
|
| f_EPTF_MessageBufferManager_MaxBufferSize_setMinValue(tsp_EPTF_UIHandler_CommPortIPL4_minBufferSize);
|
| f_EPTF_Base_registerCleanup(refers(f_EPTF_UIHandler_cleanup_CT));
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("----EPTF_UIHandler 0.8610 INIT DONE----");
|
| }
|
|
|
| f_EPTF_DataSourceClient_init_CT(f_EPTF_Base_selfName(), self);
|
| f_EPTF_DataSourceClient_registerData(c_UIHandler_DS_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_UIhandler_DSProcessData), self);
|
| f_EPTF_DataSourceClient_registerDataValue(c_UIHandler_DS_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_UIHandler_DSProcessDataValue), self);
|
| f_EPTF_DataSourceClient_sendReady(c_UIHandler_DS_sourceId, f_EPTF_Base_selfName());
|
|
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI){
|
| f_EPTF_UIHandler_Browser_init_CT( );
|
| }
|
|
|
| v_EPTF_UIHandler_Traces_HashmapId := f_EPTF_str2int_HashMap_New("TracesHashMap");
|
|
|
| v_UIHandler_initialized := true;
|
| if(f_EPTF_UIHandler_layoutReady()) {
|
| //f_EPTF_UIHandler_createInitialLayout(pl_windowLayout); // initial window is created in internal DB before trying to connect to GUI
|
| if(null != v_EPTF_UIHandler_createLayoutCallback){
|
| v_EPTF_UIHandler_createLayoutCallback.apply();
|
| }
|
| }
|
| f_EPTF_UIHandler_updateOwnProgress("Initializing: Done.");
|
| f_EPTF_Base_waitForCondition(refers(f_EPTF_UIHandler_checkDataSourceReady))
|
| }
|
|
|
| private function f_EPTF_UIHandler_checkDataSourceReady()
|
| runs on EPTF_UIHandler_Private_CT return boolean{
|
| var charstring vl_varName := "";
|
| var integer vl_returnVal := f_EPTF_DataSource_checkData(
|
| pl_dataVarName := vl_varName,
|
| pl_source := c_UIHandler_DS_sourceId,
|
| pl_ptcName := "",
|
| pl_element := c_UIHandler_dataElement_progressBar,
|
| pl_params := {});
|
| return vl_returnVal == 0;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_updateProgress
|
| //
|
| // Purpose:
|
| // Update the value of the dataSource containing the progress information
|
| //
|
| // Parameters:
|
| // pl_progressInfo - *in* *charstring* - the new progress information to show
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // The progress history is updated automatically
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_updateProgress(in charstring pl_progressInfo, in float vl_progressPercent := -1.0) runs on EPTF_UIHandler_Private_CT {
|
| if (not v_UIHandler_initialized){ return }
|
| var charstring vl_progressPercentStr := "";
|
| if (vl_progressPercent>=0.0) {
|
| vl_progressPercentStr := ": "&int2str(float2int(vl_progressPercent))&"%";
|
| }
|
| f_EPTF_Var_adjustContent(f_EPTF_Var_getId(c_UIHandler_DS_var_prefix&c_UIHandler_dataElement_progressBar),{charstringVal := pl_progressInfo&vl_progressPercentStr});
|
| }
|
|
|
| private function f_EPTF_UIHandler_initProgressBar() runs on EPTF_UIHandler_Private_CT {
|
| // create progress bar variable:
|
| var integer vl_progressBar_Idx, vl_progressBarHistory_Idx;
|
| f_EPTF_Var_newCharstring(c_UIHandler_DS_var_prefix&c_UIHandler_dataElement_progressBar,"",vl_progressBar_Idx);
|
| f_EPTF_Var_newCharstring(c_UIHandler_DS_var_prefix&c_UIHandler_dataElement_progressBarHistory,"",vl_progressBarHistory_Idx);
|
| f_EPTF_Var_addPostProcFn(vl_progressBar_Idx,{
|
| refers(f_EPTF_UIHandler_progressBarHistory_PostProc),
|
| {vl_progressBarHistory_Idx}
|
| });
|
| f_EPTF_Var_setSubsCanAdjust(vl_progressBarHistory_Idx,false);
|
| f_EPTF_UIHandler_updateOwnProgress("Initializing...");
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_enableOwnProgress
|
| //
|
| // Purpose:
|
| // Enables UIHandler's own progress information updates
|
| //
|
| // Parameters:
|
| // pl_enableOwnProgress - *in* *boolean* - true: enable, false: disable
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_enableOwnProgress(in boolean pl_enableOwnProgress) runs on EPTF_UIHandler_Private_CT {
|
| v_UIHandler_progressEnabled := pl_enableOwnProgress;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_updateOwnProgress
|
| //
|
| // Purpose:
|
| // Update the value of the dataSource containing the progress information with the UIHandler's own progress info
|
| //
|
| // Parameters:
|
| // pl_progressInfo - *in* *charstring* - the new progress information to show
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // The progress history is updated automatically
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_updateOwnProgress(in charstring pl_progressInfo, in float vl_progressPercent := -1.0) runs on EPTF_UIHandler_Private_CT {
|
| if (v_UIHandler_progressEnabled) {
|
| f_EPTF_UIHandler_updateProgress(c_UIHandler_DS_sourceId&": "&pl_progressInfo,vl_progressPercent);
|
| }
|
| }
|
|
|
| // appends the progressBar var content to the progressBarHistory var:
|
| private function f_EPTF_UIHandler_progressBarHistory_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_UIHandler_Private_CT {
|
| // content of the progressBar var:
|
| var integer vl_progressBarHistory_Idx := pl_argList[0];
|
| f_EPTF_Var_adjustContent(
|
| vl_progressBarHistory_Idx,
|
| {
|
| charstringVal := f_EPTF_Var_getCharstringValue(vl_progressBarHistory_Idx)&"\n"&f_EPTF_Var_getCharstringValue(pl_idx)
|
| }
|
| );
|
| }
|
|
|
| friend function f_EPTF_UIHandler_connect(in boolean pl_connectGUI)
|
| runs on EPTF_UIHandler_Private_CT {
|
| var ConnectionId vl_connId := -1;
|
| var boolean vl_UIHandler_transportConnectionFailed := false;
|
| if (v_EPTF_UIHandler_servermode){
|
| // server mode
|
| f_EPTF_UIHandler_headlessmode();
|
| } else {
|
|
|
| // client mode
|
| f_EPTF_Transport_registerMsgCallback(IPL4, c_EPTF_UIHandler_pingerTransport, refers(f_EPTF_UIHandler_pingerReceive));
|
| var Result vl_result
|
| f_EPTF_Transport_listen(IPL4, { udp := {} }, tsp_EPTF_UIHandler_localPingerAddr, tsp_EPTF_UIHandler_localPingerPort, c_EPTF_UIHandler_pingerTransport, vl_result, false)
|
| if (ispresent(vl_result.errorCode) and (vl_result.errorCode != ERROR_TEMPORARILY_UNAVAILABLE)) {
|
| f_EPTF_UIHandler_error("Could not open pinger port: " & log2str(vl_result));
|
| }
|
| v_UIHandler_pingerConnectionId := vl_result.connId;
|
| v_UIHandler_udp_port := tsp_EPTF_UIHandler_udp_port;
|
| // Checks for GUI address that is set by the user.
|
| // If not use the address from module parameter.
|
| if (v_UIHandler_GUI_Host == c_EPTF_UIHandler_Invalid_GUI_Host or
|
| v_UIHandler_GUI_Port == c_EPTF_UIHandler_Invalid_GUI_Port) {
|
| v_UIHandler_GUI_Host := tsp_xtdp_listen_addr;
|
| v_UIHandler_GUI_Port := tsp_xtdp_listen_port;
|
| }
|
| if(pl_connectGUI){
|
| // try to connect to GUI
|
| var EPTF_UIHandler_connectionResult vl_res := f_EPTF_UIHandler_connectAndInitGui(vl_connId);
|
| if(connected != vl_res){
|
| if (v_EPTF_UIHandler_headlessmode) {
|
| // connect to GUI failed -> switch to headless mode
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("initGUI failed, switch to headless mode");
|
| }
|
| f_EPTF_UIHandler_headlessmode();
|
| vl_UIHandler_transportConnectionFailed := vl_res != temporarilyUnavailable;
|
| } else {
|
| // connecting to GUI failed and headless mode not enabled -> stop running
|
| f_EPTF_UIHandler_error("initGUI failed!");
|
| }
|
| }
|
| } else if (v_EPTF_UIHandler_headlessmode) {
|
| // headless mode enabled -> switch to headless mode
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("UIHandler started in headless mode");
|
| }
|
| f_EPTF_UIHandler_headlessmode();
|
| } else {
|
| // uncorrect starrtup configuration: client mode, not to connect to GUI, headless mode disabled -> stop running
|
| f_EPTF_UIHandler_error("Uncorrect UIHandler configuration for startup: client mode, not to connect to GUI, headless mode disabled");
|
| }
|
|
|
| }
|
| if (tsp_EPTF_UIHandler_bufferedXTDP != 0.0){
|
| //v_UIHandler_Requestbuffer.data.noNamespaceSchemaLocation := omit;
|
| v_UIHandler_Requestbuffer.data.transactionID := omit;
|
| v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.ackRequested := omit;
|
| f_EPTF_UIHandler_requestBuffer_clear();
|
| t_UIHandler_bufferedXTDP.start(tsp_EPTF_UIHandler_bufferedXTDP);
|
| }
|
| v_UIHandler_def := activate(as_handle_main_EPTF_UIHandler_MgmtIf());
|
| // wait for gui connect (handshake and authentication) if transport is already connected
|
| if ((pl_connectGUI and not v_EPTF_UIHandler_servermode) and not vl_UIHandler_transportConnectionFailed) {
|
| timer t_wait_for_connectGUI := 0.0;
|
| timer t_max_wait_for_connectGUI := tsp_EPTF_UIHandler_maxGUIWaitTime;
|
| t_max_wait_for_connectGUI.start;
|
| t_wait_for_connectGUI.start;
|
| alt {
|
| [v_UIHandler_guiConnected or (vl_connId != -1 and not f_EPTF_UIHandler_isConnectedClientid(vl_connId))] t_wait_for_connectGUI.timeout {
|
| // connection established, or lost
|
| }
|
| [] t_max_wait_for_connectGUI.timeout {
|
| // bugfix_HR17649 - error => warning
|
| f_EPTF_UIHandler_warning("In client mode connecting to the RuntimeGUI on " & v_UIHandler_GUI_Host & ":" & log2str(v_UIHandler_GUI_Port) & " failed: Timeout during handshake&authentication. RuntimeGUI is not responding. Please correct the tsp_xtdp_listen_addr / tsp_xtdp_listen_port parameter(s) or restart the RuntimeGUI! ");
|
| f_EPTF_UIHandler_headlessmode();
|
| }
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_newCreateInitialLayout
|
| //
|
| // Purpose:
|
| // Create initial layout based on settings
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_newCreateInitialLayout()
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| var boolean vl_ret := false;
|
| if(not v_UIHandler_emptyGUI){
|
| // If no window is given neither from parameter nor from tsp, parameter is not given, or contains the default value ->
|
| // create a simple window and a main tabbox
|
| // This is the backward compatible way
|
| if("" == v_UIHandler_windowLayout and "" == tsp_EPTF_GUI_DefaultWindow){
|
| // no window is given -> create a simple window and a main tabbox
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Creating a window and a main tabbox");
|
| }
|
| vl_ret := f_EPTF_UIHandler_addWindow();
|
| vl_ret := vl_ret and f_EPTF_UIHandler_addMainTabbox();
|
| }
|
| else {
|
| if ("" != v_UIHandler_windowLayout) {
|
| // create window given in parameter
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Creating window specified by function parameter: "&log2str(v_UIHandler_windowLayout));
|
| }
|
| f_EPTF_UIHandler_createGUIFromWindow(v_UIHandler_windowLayout);
|
| //vl_wndXul := f_EPTF_UIHandler_XSD_decodeXUL(pl_windowLayout);
|
| }
|
| else if ("" != tsp_EPTF_GUI_DefaultWindow) {
|
| // create window from specified in tsp
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Creating window specified by tsp_EPTF_GUI_DefaultWindowXTDL: "&log2str(tsp_EPTF_GUI_DefaultWindowXTDL));
|
| }
|
| f_EPTF_UIHandler_createGUIFromWindow(tsp_EPTF_GUI_DefaultWindowXTDL);
|
| //vl_wndXul := f_EPTF_UIHandler_XSD_decodeXUL(tsp_EPTF_GUI_DefaultWindow);
|
| }
|
| if (not vl_ret) {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&" failed, could not create initial GUI");
|
| }
|
| }
|
| }
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_createGUIFromWindow(in charstring pl_window)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var Widgets vl_widgets := f_EPTF_UIHandler_XSD_decodeXUL(pl_window);
|
| if(not ischosen(vl_widgets.window)){
|
| f_EPTF_UIHandler_error(%definitionId&": The received XUL is invalid, not window or it can not be decoded fully.\n"&
|
| "For further detailes see the log file above.")
|
| }
|
| f_EPTF_UIHandler_createGUI(pl_window);
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_cleanup_CT
|
| //
|
| // Purpose:
|
| // Destructs the EPTF_UIHandler_CT
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // This function mustn't be called directly. You must call f_EPTF_Base_cleanup_CT instead.
|
| ///
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_cleanup_CT() runs on EPTF_UIHandler_Private_CT {
|
| // f_EPTF_Logging_debug(true, "v_UIHandler_initialized: "& v_UIHandler_initialized &" v_UIHandler_guiConnected: "& v_UIHandler_guiConnected);
|
| if (v_UIHandler_initialized)
|
| {
|
| v_UIHandler_cleanupCalled := true;
|
| if(t_UIHandler_pingtimer.running) {
|
| t_UIHandler_pingtimer.stop;
|
| }
|
| if(t_UIHandler_initGUIToClientTimer.running) {
|
| t_UIHandler_initGUIToClientTimer.stop;
|
| }
|
| if(v_UIHandler_guiConnected)
|
| {
|
| for (var integer i := 0; i<sizeof(v_UIHandler_GUIClientId); i:= i+1)
|
| {
|
| f_EPTF_UIHandler_closeXTDPSession(v_UIHandler_GUIClientId[i].clientId);
|
| //var Result vl_result
|
| //f_EPTF_Transport_send(IPL4, v_UIHandler_GUIClientId[i], char2oct("bye\r\n"), vl_result, false)
|
| }
|
| }
|
|
|
| f_EPTF_Semaphore_delete(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| f_EPTF_Semaphore_delete(v_UIHandler_layoutResponseReceivedSemaphore);
|
| f_EPTF_Semaphore_delete(v_UIHandler_exitButtonPressedSemaphore);
|
|
|
| v_UIHandler_openSubscriptions := {};
|
| v_UIHandler_subscriptions := {}
|
| f_EPTF_str2int_HashMap_Delete(c_EPTF_UIHandler_subscriptionHashMapName);
|
| f_EPTF_str2int_HashMap_Delete(c_EPTF_UIHandler_subscriptionHashMapNameVar);
|
| f_EPTF_str2int_HashMap_Delete(c_EPTF_UIHandler_simulation_varsHashMapName);
|
| v_UIHandler_subscriptionHashMapId := -1;
|
| v_UIHandler_subscriptionHashMapIdVar := -1;
|
| v_UIHandler_simulation_varsHashMapId := -1;
|
| v_UIHandler_guiItemList := {};
|
| v_UIHandler_windowIndex := -1;
|
| v_UIHandler_initialized := false;
|
| f_EPTF_str2int_HashMap_Delete(c_EPTF_UIHandler_widgetIdHashMapName);
|
| v_UIHandler_widgetHashMapId := -1;
|
|
|
| f_EPTF_int2int_HashMap_Delete(c_EPTF_UIHandler_tracePointerHashMapName);
|
| v_UIHandler_tracePointerHashMapId := -1;
|
| v_UIHandler_tracePointers := {};
|
|
|
| f_EPTF_str2int_HashMap_DeleteById(v_EPTF_UIHandler_Traces_HashmapId);
|
| v_EPTF_UIHandler_TraceRingBuffers := {};
|
|
|
| v_UIHandler_initToGUIClient := false;
|
| v_UIHandler_createGUIRunning := false;
|
|
|
| v_EPTF_UIHandler_headlessmode := true;
|
| v_EPTF_UIHandler_servermode := false;
|
| v_EPTF_UIHandler_Authresp := "";
|
| }
|
|
|
| // Reset the GUI address because we don't want to affect the
|
| // subsequence UIHandler initializations.
|
| v_UIHandler_GUI_Host := c_EPTF_UIHandler_Invalid_GUI_Host;
|
| v_UIHandler_GUI_Port := c_EPTF_UIHandler_Invalid_GUI_Port;
|
|
|
| v_UIHandler_guiConnected := false;
|
| // clearing registered callbacks (also registered callbacks exit if not v_UIHandler_initialized):
|
| //f_EPTF_CommPort_IPL4_setMsgLen4LGenType(null, {}, c_EPTF_UIHandler_XTDPType);
|
| f_EPTF_Transport_registerMsgCallback(IPL4, c_EPTF_UIHandler_XTDPType, null, null);
|
|
|
| deactivate(v_UIHandler_def); v_UIHandler_def := null;
|
| // WORKAROUND for some GUI bug, remove it ASAP!
|
| timer t_x := 0.5;t_x.start;t_x.timeout;
|
| if (not v_EPTF_UIHandler_servermode){
|
| var Result vl_result
|
| f_EPTF_Transport_close(IPL4, v_UIHandler_pingerConnectionId, vl_result)
|
| v_UIHandler_pingerConnectionId := -1;
|
| }
|
| f_EPTF_UIHandler_CLIClient_cleanup_CT()
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("----EPTF_UIHandler cleanup DONE----");
|
| }
|
| f_EPTF_UIHandler_cleanup_XML();
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_clearGUI
|
| //
|
| // Purpose:
|
| // Sends a message to user interface via XTDP port to remove
|
| // all the elements and also clears UIHandler's internal DB.
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_clearGUI(in boolean pl_clearDb := true) runs on EPTF_UIHandler_Private_CT {
|
| if (not v_UIHandler_initialized){ return }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| // remove all
|
| for(var integer clientindex:=0;clientindex<sizeof(v_UIHandler_GUIClientId);clientindex := clientindex+1){
|
| var ASP_XSD_XTDP vl_msg :={
|
| v_UIHandler_GUIClientId[clientindex].clientId,
|
| {
|
| choice := {
|
| xTDP_RemoveRequests:= {
|
| xTDP_RemoveRequest_list := {
|
| {
|
| requestId := 1,
|
| widgetId := omit
|
| }
|
| }
|
| }
|
| }
|
| }
|
| };
|
| f_EPTF_UIHandler_send_XTDP(vl_msg);
|
| }
|
| if (pl_clearDb) {
|
| // make internal widget DB empty
|
| f_EPTF_UIHandler_clearInternalWidgetDB();
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addWindow
|
| //
|
| // Purpose:
|
| // Tries to add a new window to the RuntimeGUI
|
| //
|
| // Detailed Comments:
|
| // The parameters of the new window can be controlled via
|
| // the tsp_EPTF_GUI_Main_Window_... module parameters
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_addWindow()
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if (not v_UIHandler_initialized){ return false }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| var Widgets vl_xul := {
|
| window := {
|
| about := omit,
|
| height := tsp_EPTF_GUI_Main_Window_Height,
|
| help := omit,
|
| id := tsp_EPTF_GUI_Main_Window_WidgetId,
|
| orientation := vertical,
|
| title := tsp_EPTF_GUI_Main_Window_Title,
|
| width := tsp_EPTF_GUI_Main_Window_Width,
|
| image_list := {},
|
| embeddedwidgets := {
|
| /* {tabbox := { */
|
| /* id := tsp_EPTF_GUI_Main_Tabbox_WidgetId, */
|
| /* flex := omit, */
|
| /*customclass := omit, */
|
| /* disabled := omit, */
|
| /*disabledongui := omit, */
|
| /* tabs := {}, */
|
| /* tabpanels := {} */
|
| /* } */
|
| /* }, */
|
| embeddedwidget_list := {
|
| /*{
|
| toolbar := {
|
| customclass := omit,
|
| disabled := false,
|
| disabledongui := omit,
|
| id := tsp_EPTF_GUI_Main_Toolbar_WidgetId,
|
| placement := south,
|
| choice_list := {}
|
| }
|
| }*/
|
| }
|
| }
|
| }
|
| };
|
| var boolean vl_dummy := false;
|
| return f_EPTF_UIHandler_XSD_addElementToGui(vl_xul, "", vl_dummy);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addMainTabbox
|
| //
|
| // Purpose:
|
| // Tries to add the main tabbox to the RuntimeGUI
|
| //
|
| // Detailed Comments:
|
| // The id of the tabbox is spesified by
|
| // tsp_EPTF_GUI_Main_Tabbox_WidgetId module parameter
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_addMainTabbox()
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if (not v_UIHandler_initialized){ return false }
|
| var boolean vl_succ := f_EPTF_UIHandler_addMainTabpages();
|
| return vl_succ;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addMainTabpages
|
| //
|
| // Purpose:
|
| // Tries to add the main tabbox to the RuntimeGUI
|
| //
|
| // Detailed Comments:
|
| // The id of the tabbox is spesified by
|
| // tsp_EPTF_GUI_Main_Tabbox_WidgetId module parameter
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_addMainTabpages()
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if (not v_UIHandler_initialized){ return false }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| var Widgets vl_xul := {
|
| tabpages := {
|
| //In case of named fields the compiler won't warn if
|
| //there are uninitializad elements
|
| /*customclass :=*/ omit,
|
| /*disabled :=*/ omit,
|
| /*disabledongui :=*/ omit,
|
| /*flex :=*/ omit,
|
| /*id :=*/ tsp_EPTF_GUI_Main_Tabbox_WidgetId,
|
| /*layout :=*/ omit,
|
| /*tabpage :=*/ { { } }
|
| }
|
| };
|
| var boolean vl_dummy:=false;
|
| return f_EPTF_UIHandler_XSD_addElementToGui(vl_xul, tsp_EPTF_GUI_Main_Window_WidgetId, vl_dummy);
|
| }
|
|
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_removeElementFromGui
|
| //
|
| // Purpose:
|
| // Remove an element from the GUI.
|
| //
|
| // Parameters:
|
| // pl_widgetId - *in* *EPTF_UIHandler_WidgetIdString* - element to be removed
|
| // pl_sendToRTG - *in* *boolean* - if true: request is sent to runtime GUI, otherwise not
|
| //
|
| // Return Value:
|
| // Returns the result of f_EPTF_UIHandler_removeWidgetRecByIdx.
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_removeElementFromGui_old(in EPTF_UIHandler_WidgetIdString pl_widgetId, in boolean pl_sendToRTG := true, in boolean pl_appendTo_GUI_DescriptionDB := true)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if (not v_UIHandler_initialized){ return false }
|
| if(pl_appendTo_GUI_DescriptionDB) {
|
| v_UIHandler_GUI_DescriptionDB[sizeof(v_UIHandler_GUI_DescriptionDB)] := {pl_widgetId, "removed"};
|
| }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| var integer vl_idx := f_EPTF_UIHandler_widgetRecIndex(pl_widgetId);
|
| if(-1 == vl_idx){
|
| f_EPTF_UIHandler_warning("There is no widget with name "&pl_widgetId&" to remove!");
|
| return false;
|
| }
|
| //remove the element from the GUI
|
| if (pl_sendToRTG) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRemoveElementFromGUI(pl_widgetId));
|
| }
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(pl_widgetId);
|
| }
|
| //remove it and its children from the widgetlist and the connectionlist
|
| return f_EPTF_UIHandler_removeWidgetRecByIdx(vl_idx);
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_removeElementFromGui
|
| //
|
| // Purpose:
|
| // Remove an element from the GUI.
|
| //
|
| // Parameters:
|
| // pl_widgetId - *in* *EPTF_UIHandler_WidgetIdString* - element to be removed
|
| // pl_sendToRTG - *in* *boolean* - if true: request is sent to runtime GUI, otherwise not
|
| //
|
| // Return Value:
|
| // Returns the result of f_EPTF_UIHandler_removeWidgetRecByIdx.
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_removeElementFromGui(in EPTF_UIHandler_WidgetIdString pl_widgetId, in boolean pl_sendToRTG := true, in boolean pl_appendTo_GUI_DescriptionDB := true)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if (not v_UIHandler_initialized){ return false }
|
| var boolean vl_ret := true;
|
| if(pl_appendTo_GUI_DescriptionDB) {
|
| v_UIHandler_GUI_DescriptionDB[sizeof(v_UIHandler_GUI_DescriptionDB)] := {pl_widgetId, "removed"};
|
| }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| var integer vl_idx := f_EPTF_UIHandler_widgetRecIndex(pl_widgetId);
|
| if(-1 == vl_idx){
|
| f_EPTF_UIHandler_warning("There is no widget with name "&pl_widgetId&" to remove!");
|
| return false;
|
| }
|
| //remove the element from the GUI
|
| if (pl_sendToRTG) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRemoveElementFromGUI(pl_widgetId));
|
| }
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(pl_widgetId);
|
| }
|
| //remove it and its children from the widgetlist and the connectionlist
|
| vl_ret := f_EPTF_UIHandler_removeWidgetRecByIdx(vl_idx)
|
| if(vl_ret == true) {
|
| // Remove it from document
|
| vl_ret := f_EPTF_UIHandler_removeXML(pl_widgetId);
|
| }
|
| return vl_ret;
|
| }
|
|
|
| public function f_EPTF_UIHandler_printAllXMLfor_Tests( )
|
| runs on EPTF_UIHandler_Private_CT {
|
| if (not v_UIHandler_initialized){ return }
|
| f_EPTF_UIHandler_printAllXML();
|
| return;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_removeElementFromGuiByIdx
|
| //
|
| // Purpose:
|
| // Remove an element from the GUI.
|
| //
|
| // Parameters:
|
| // pl_widgetIdx - *in* *integer* - element to be removed
|
| // pl_sendToRTG - *in* *boolean* - if true: request is sent to runtime GUI, otherwise not
|
| //
|
| // Return Value:
|
| // Returns the result of f_EPTF_UIHandler_removeWidgetRecByIdx.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_removeElementFromGuiByIdx(in integer pl_widgetIdx, in boolean pl_sendToRTG := true, in boolean pl_appendTo_GUI_DescriptionDB := true)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var charstring vl_widgetId := v_UIHandler_guiItemList[pl_widgetIdx].id;
|
| if(pl_appendTo_GUI_DescriptionDB) {
|
| v_UIHandler_GUI_DescriptionDB[sizeof(v_UIHandler_GUI_DescriptionDB)] := {vl_widgetId, "removed"};
|
| }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| if(-1 == pl_widgetIdx){
|
| f_EPTF_UIHandler_warning("There is no widget with name "&vl_widgetId&" to remove!");
|
| return false;
|
| }
|
| //remove the element from the GUI
|
| if (pl_sendToRTG) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRemoveElementFromGUI(vl_widgetId));
|
| }
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(vl_widgetId, pl_widgetIdx);
|
| }
|
| //remove it and its children from the widgetlist and the connectionlist
|
| return f_EPTF_UIHandler_removeWidgetRecByIdx(pl_widgetIdx);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_snapshot
|
| //
|
| // Purpose:
|
| // Makes a snapshot of the GUI as a charstring.
|
| //
|
| // Return Value:
|
| // The returned charstring describes a XUL. It can be saved with
|
| // <f_EPTF_UIHandler_saveLayout> to a config file.
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_snapshot()
|
| runs on EPTF_UIHandler_Private_CT
|
| return charstring{
|
| if (not v_UIHandler_initialized){ return "" }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| var charstring vl_layout := "";
|
| if(v_UIHandler_guiConnected)
|
| {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_layoutRequest);
|
|
|
| if(f_EPTF_Semaphore_waitForUnlock(v_UIHandler_layoutResponseReceivedSemaphore, tsp_EPTF_UIHandler_maxWaitTimer))
|
| {
|
| f_EPTF_UIHandler_warning("Timer timeout! No layout response received!");
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| v_UIHandler_layoutResponseReceivedSemaphore := f_EPTF_Semaphore_new();
|
| return vl_layout;
|
| }
|
| v_UIHandler_layoutResponseReceivedSemaphore := f_EPTF_Semaphore_new();
|
| //f_EPTF_Semaphore_lock(v_UIHandler_layoutResponseReceivedSemaphore);
|
| vl_layout := f_EPTF_UIHandler_XSD_encodeXUL(v_UIHandler_receivedMessage.choice.xTDP_LayoutResponse.widgets);
|
| }else{
|
| var Widgets vl_xul;
|
| f_EPTF_UIHandler_buildXUL(vl_xul);
|
| vl_layout := f_EPTF_UIHandler_XSD_encodeXUL(vl_xul)
|
| }
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| return vl_layout;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_snapshotWindow
|
| //
|
| // Purpose:
|
| // Makes a snapshot of the GUI's root widget (windowelem) as a charstring.
|
| //
|
| // Return Value:
|
| // The returned charstring describes a XUL that can be passed to
|
| // the runtime GUI as a command line parameter if saved as a file.
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_snapshotWindow()
|
| runs on EPTF_UIHandler_Private_CT
|
| return charstring{
|
| if (not v_UIHandler_initialized){ return "" }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| var charstring vl_layout := "";
|
| if(v_UIHandler_guiConnected)
|
| {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_layoutRequest);
|
|
|
| if(f_EPTF_Semaphore_waitForUnlock(v_UIHandler_layoutResponseReceivedSemaphore, tsp_EPTF_UIHandler_maxWaitTimer))
|
| {
|
| f_EPTF_UIHandler_warning("Timer timeout! No layout response received!");
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| v_UIHandler_layoutResponseReceivedSemaphore := f_EPTF_Semaphore_new();
|
| return vl_layout;
|
| }
|
| v_UIHandler_layoutResponseReceivedSemaphore := f_EPTF_Semaphore_new();
|
| //f_EPTF_Semaphore_lock(v_UIHandler_layoutResponseReceivedSemaphore);
|
| if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_LayoutResponse.widgets.window)) {
|
| vl_layout := f_EPTF_UIHandler_XSD_encodeWindowXUL(v_UIHandler_receivedMessage.choice.xTDP_LayoutResponse.widgets.window);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Unexpected XTDP LayoutResponse (not window)!");
|
| }
|
| }else{
|
| var Widgets vl_xul;
|
| f_EPTF_UIHandler_buildXUL(vl_xul);
|
| if(ischosen(vl_xul.window)) {
|
| vl_layout := f_EPTF_UIHandler_XSD_encodeWindowXUL(vl_xul.window);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Unexpected layout (not window)!");
|
| }
|
| }
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| return vl_layout;
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_XSD_encodeXUL
|
| //
|
| // Purpose:
|
| // Encodes a XUL record to its charstring representation
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_XSD_encodeXUL(in Widgets pl_widgets)
|
| return charstring{
|
|
|
| var octetstring vl_ret := enc_Widgets(pl_widgets);
|
| return oct2char(vl_ret)
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_XSD_encodeWindowXUL
|
| //
|
| // Purpose:
|
| // Encodes a XUL Window record to its charstring representation
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_XSD_encodeWindowXUL(in Window pl_windowelem)
|
| return charstring{
|
| var octetstring vl_ret := enc_Window(pl_windowelem);
|
| return oct2char(vl_ret)
|
| }
|
|
|
| public external function dec_Widgets (in octetstring p_oct, out Widgets p_widgets) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
|
|
| public external function enc_Widgets (in Widgets p_widgets) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| public external function enc_Window (in Window p_windowelem) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_XSD_encodeXULEm
|
| //
|
| // Purpose:
|
| // Encodes an Embedded XUL record to its charstring representation
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_XSD_encodeXULEm(in Embeddedwidget pl_widgets)
|
| return charstring{
|
| var octetstring vl_ret := enc_EmbeddedWidget(pl_widgets);
|
| return oct2char(vl_ret)
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_preprocessAliasXUL
|
| //
|
| // Purpose:
|
| // Preprocess alias items in XUL charstring
|
| //
|
| ///////////////////////////////////////////////////////////
|
| // 02.04.2012 made for first version of externalvalue
|
| // handling. not dropped becouse it will be useful once.
|
| type record EPTF_UIHandler_alias {
|
| charstring fromStr,
|
| charstring toStr
|
| };
|
| type record of EPTF_UIHandler_alias EPTF_UIHandler_aliasList;
|
|
|
| public function f_EPTF_UIHandler_preprocessAliasXUL(in charstring pl_xul)
|
| runs on EPTF_UIHandler_Private_CT return charstring {
|
| var EPTF_UIHandler_aliasList vl_aliasList:= {/*{ fromStr := "externalvalue", toStr := "iterator" }*/};
|
| var charstring vl_preprocessed := pl_xul;
|
| if(0 < sizeof(vl_aliasList)) {
|
| for (var integer vl_idx := 0; vl_idx < sizeof(vl_aliasList); vl_idx := vl_idx + 1) {
|
|
|
| var charstring vl_startFromValue := "<"&vl_aliasList[vl_idx].fromStr;
|
| var charstring vl_startToValue := "<"&vl_aliasList[vl_idx].toStr;
|
| var charstring vl_endFromValue := "</"&vl_aliasList[vl_idx].fromStr;
|
| var charstring vl_endToValue := "</"&vl_aliasList[vl_idx].toStr;
|
|
|
| // replace start tag
|
| vl_preprocessed := pl_xul;
|
| var charstring vl_tempStr:= pl_xul;
|
| var charstring vl_LoverStr := f_putInLowercase(pl_xul), vl_tempLowerStr:= vl_LoverStr;
|
| var integer vl_i := f_strstr(vl_LoverStr,vl_startFromValue);
|
|
|
| while (vl_i!=-1) {
|
| vl_preprocessed :=
|
| substr(vl_tempStr,0,vl_i)&vl_startToValue&
|
| substr(vl_tempStr,vl_i+lengthof(vl_startFromValue),
|
| lengthof(vl_tempStr)-vl_i-lengthof(vl_startFromValue));
|
| vl_LoverStr := substr(vl_tempLowerStr,0,vl_i)&vl_startToValue&
|
| substr(vl_tempLowerStr,vl_i+lengthof(vl_startFromValue),
|
| lengthof(vl_tempLowerStr)-vl_i-lengthof(vl_startFromValue));
|
| //continue from saved pointer offset with the length of replacement string
|
| vl_i := vl_i+lengthof(vl_startToValue);
|
| vl_tempStr := vl_preprocessed;
|
| vl_tempLowerStr := vl_LoverStr;
|
| vl_i := f_strstr(vl_LoverStr,vl_startFromValue,vl_i);
|
| }
|
|
|
| // replace end tag
|
| vl_tempStr:= vl_preprocessed;
|
| vl_tempLowerStr:= vl_LoverStr;
|
| vl_i := f_strstr(vl_LoverStr,vl_endFromValue);
|
| while (vl_i!=-1) {
|
| vl_preprocessed :=
|
| substr(vl_tempStr,0,vl_i)&vl_endToValue&
|
| substr(vl_tempStr,vl_i+lengthof(vl_endFromValue),
|
| lengthof(vl_tempStr)-vl_i-lengthof(vl_endFromValue));
|
| vl_LoverStr := substr(vl_tempLowerStr,0,vl_i)&vl_endToValue&
|
| substr(vl_tempLowerStr,vl_i+lengthof(vl_endFromValue),
|
| lengthof(vl_tempLowerStr)-vl_i-lengthof(vl_endFromValue));
|
| //continue from saved pointer offset with the length of replacement string
|
| vl_i := vl_i+lengthof(vl_endToValue);
|
| vl_tempStr := vl_preprocessed;
|
| vl_tempLowerStr := vl_LoverStr;
|
| vl_i := f_strstr(vl_LoverStr,vl_endFromValue,vl_i);
|
| }
|
| }
|
| }
|
|
|
| return vl_preprocessed;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_XSD_decodeXULEm
|
| //
|
| // Purpose:
|
| // Decodes a XUL record to its charstring representation
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_XSD_decodeXULEm(in charstring pl_widgets)
|
| return Embeddedwidget{
|
| var Embeddedwidget vl_ret;
|
| var integer vl_dummy;
|
| vl_dummy := dec_EmbeddedWidget(char2oct(pl_widgets), vl_ret);
|
| return vl_ret;
|
| }
|
|
|
| private external function dec_EmbeddedWidget (in octetstring p_oct, out Embeddedwidget p_widgets) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
|
|
| private external function enc_EmbeddedWidget (in Embeddedwidget p_widgets) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_XSD_decodeXUL
|
| //
|
| // Purpose:
|
| // Decodes a XUL record to its charstring representation
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_XSD_decodeXUL(in charstring pl_widgets)
|
| runs on EPTF_UIHandler_Private_CT
|
| return Widgets{
|
| var Widgets vl_ret;
|
| var integer vl_retval;
|
| vl_retval := dec_Widgets(char2oct(pl_widgets), vl_ret);
|
| if(0 != vl_retval){
|
| f_EPTF_UIHandler_error(%definitionId&": The received XML is invalid, it can not be decoded fully.\n"&
|
| "For further detailes see the log file above.")
|
| }
|
| return vl_ret;
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_saveLayout
|
| //
|
| // Purpose:
|
| // Saves the parameter charstring as a window layout.
|
| //
|
| // Detailed Comments:
|
| // The layout of the window can be retreived with the function
|
| // <f_EPTF_UIHandler_snapshot>.
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_saveLayout(in charstring pl_layout)
|
| runs on EPTF_UIHandler_Private_CT{
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| var charstring vl_currentConfig := "\n// saved by EPTF GUI\n\n[MODULE_PARAMETERS]\n\ntsp_EPTF_GUI_DefaultWindow := """ & f_EPTF_UIHandler_convertLayout(pl_layout) & """";
|
| var charstring vl_FileName := f_getTimeFormatted(f_time(),tsp_EPTF_savedGUIPrefix & "_%d%m%Y_%H_%M.cfg");
|
| var integer vl_file := f_FIO_open_trunc_wronly(vl_FileName);
|
| if(-1 != vl_file){
|
| if(-1 == f_FIO_write_text(vl_file, vl_currentConfig)){
|
| f_EPTF_UIHandler_warning("Couldn't write file "&vl_FileName&".");
|
| var integer int := f_FIO_close(vl_file);
|
| if (int == -1){
|
| f_EPTF_UIHandler_warning("Could not close the file!");
|
| }
|
| // f_EPTF_Base_stop();
|
| }else{
|
| var integer int := f_FIO_close(vl_file);
|
| if (int == -1){
|
| f_EPTF_UIHandler_warning("Could not close the file!");
|
| }
|
| }
|
| }else{
|
| f_EPTF_UIHandler_warning("Couldn't open file "&vl_FileName&" for writing.");
|
| // f_EPTF_Base_stop();
|
| }
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_logAll
|
| //
|
| // Purpose:
|
| // Logs all internal variables in EPTF_UIHandler_CT.
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_logAll() runs on EPTF_UIHandler_Private_CT {
|
| log("------Content of EPTF_UIHandler_CT: -------");
|
| //log("v_UIHandler_CLI_initialized: ", v_UIHandler_CLI_initialized);
|
| log("v_UIHandler_initialized: ", v_UIHandler_initialized);
|
| log("v_UIHandler_lastRequest: ", v_UIHandler_lastRequest);
|
| log("v_UIHandler_guiConnected: ",v_UIHandler_guiConnected);
|
| log("v_UIHandler_windowLayout: ", v_UIHandler_windowLayout);
|
| log("v_UIHandler_guiLayoutReady: ", v_UIHandler_guiLayoutReady);
|
| log("v_UIHandler_guiItemList: ",v_UIHandler_guiItemList);
|
| log("t_UIHandler_pingtimer: ",t_UIHandler_pingtimer);
|
| log("v_UIHandler_succpingcounter: ",v_UIHandler_succpingcounter);
|
| log("v_UIHandler_pingcounter", v_UIHandler_pingcounter);
|
| log("v_UIHandler_prevpingcounter: ", v_UIHandler_prevpingcounter);
|
| log("v_UIHandler_def: ",v_UIHandler_def);
|
| log("v_UIHandler_openSubscriptions: ",v_UIHandler_openSubscriptions);
|
| log("v_UIHandler_subscriptions: ", v_UIHandler_subscriptions);
|
| log("v_UIHandler_windowIndex: ",v_UIHandler_windowIndex);
|
| log("v_UIHandler_GUIClientId: ",v_UIHandler_GUIClientId);
|
| log("v_UIHandler_lastRowId: ",v_UIHandler_lastRowId);
|
| log("v_UIHandler_subscriptInProcess: ", v_UIHandler_subscriptInProcess);
|
| log("t_UIHandler_bufferedXTDP: ",t_UIHandler_bufferedXTDP );
|
| log("t_UIHandler_initGUIToClientTimer: ",t_UIHandler_initGUIToClientTimer );
|
| log("------Finished Content of EPTF_UIHandler_CT -------");
|
| }//f_
|
|
|
| public function f_EPTF_UIHandler_logWidgetDB(in boolean pl_verbose := false)
|
| runs on EPTF_UIHandler_Private_CT
|
| return charstring{
|
| if (not v_UIHandler_initialized){ return "" }
|
| var charstring vl_log := ""
|
| for ( var integer i := 0, s := sizeof(v_UIHandler_guiItemList); i < s ; i := i+1 ){
|
| f_EPTF_UIHandler_log2strWidgetRec(i,vl_log, pl_verbose)
|
| vl_log := vl_log & "\n";
|
| }
|
| return vl_log;
|
| }
|
|
|
| public function f_EPTF_UIHandler_log2strWidgetRec(
|
| in integer pl_recIdx,
|
| inout charstring pl_ret,
|
| in boolean pl_verbose := false)
|
| runs on EPTF_UIHandler_Private_CT{
|
| if (not v_UIHandler_initialized){ return }
|
| pl_ret := pl_ret&"Idx:\t"&log2str(pl_recIdx)&
|
| "\nID:\t"&v_UIHandler_guiItemList[pl_recIdx].id&
|
| "\nType:\t"&log2str(v_UIHandler_guiItemList[pl_recIdx].widgetType)
|
| if(pl_verbose){
|
| pl_ret := pl_ret & "\nData type\t"&log2str(v_UIHandler_guiItemList[pl_recIdx].widgetDataType)
|
| }
|
| pl_ret := pl_ret & "\nParent:\t"&log2str(v_UIHandler_guiItemList[pl_recIdx].parentIdx)&
|
| "\nChildren:\t";
|
| for ( var integer j:=0, sc := sizeof(v_UIHandler_guiItemList[pl_recIdx].children); j < sc ; j := j+1 ){
|
| pl_ret := pl_ret & int2str(v_UIHandler_guiItemList[pl_recIdx].children[j])&", ";
|
| }
|
|
|
| if(pl_verbose){
|
| pl_ret := pl_ret & log2str(v_UIHandler_guiItemList[pl_recIdx].widgetData);
|
| }
|
| //Widgets XULformat optional
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_GUIConnected
|
| //
|
| // Purpose:
|
| // Returns whether the GUI is connected (authenticated)
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_GUIConnected() runs on EPTF_UIHandler_Private_CT return boolean {
|
| return v_UIHandler_guiConnected
|
| }
|
|
|
| public function f_EPTF_UIHandler_initialized() runs on EPTF_UIHandler_Private_CT return boolean {
|
| return v_UIHandler_initialized;
|
| }//f_
|
|
|
| friend function f_EPTF_UIHandler_guiItemList() runs on EPTF_UIHandler_Private_CT return EPTF_UIHandler_GuiItemRecList {
|
| return v_UIHandler_guiItemList;
|
| }
|
|
|
| friend function f_EPTF_UIHandler_openSubscriptions() runs on EPTF_UIHandler_Private_CT return EPTF_UIHandler_OpenSubscriptions {
|
| return v_UIHandler_openSubscriptions;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_exitButtonPressed
|
| //
|
| // Purpose:
|
| // Handles the pressing of the exit button. Only for TESTING purposes!
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_exitButtonPressed(in float pl_timeout := tsp_EPTF_UIHandler_maxWaitTimer) runs on EPTF_UIHandler_Private_CT {
|
| if (not v_UIHandler_initialized){ return }
|
| {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Waiting for the exit button to be pressed.");
|
| }
|
| if(f_EPTF_Semaphore_waitForUnlock(v_UIHandler_exitButtonPressedSemaphore, pl_timeout))
|
| {
|
| f_EPTF_UIHandler_warning(%definitionId&": Timer timeout! Exit button was not pressed!");
|
| }
|
| v_UIHandler_exitButtonPressedSemaphore := f_EPTF_Semaphore_new();
|
| //f_EPTF_Semaphore_lock(v_UIHandler_exitButtonPressedSemaphore);
|
| };
|
| }
|
|
|
| } // group PublicFunctions
|
|
|
| //=========================================================================
|
| // Private functions
|
| //=========================================================================
|
| group PrivateFunctions {
|
|
|
| private function f_EPTF_UIHandler_requestBuffer_clear()
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| v_UIHandler_RequestbufferIsEmpty := true;
|
| v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.xTDP_Request_list := { c_UIHandler_XSD_emptyXTDPRequest };
|
| }
|
|
|
| private function f_EPTF_UIHandler_requestBuffer_size()
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer
|
| {
|
| if (v_UIHandler_RequestbufferIsEmpty) {
|
| return 0;
|
| } else {
|
| return sizeof(v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.xTDP_Request_list);
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_requestBuffer_add(in ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Request pl_request)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| var integer i := 0;
|
| if (not v_UIHandler_RequestbufferIsEmpty) {
|
| i := sizeof(v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.xTDP_Request_list);
|
| }
|
| v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.xTDP_Request_list[i] := pl_request;
|
| v_UIHandler_RequestbufferIsEmpty := false;
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_convertLayout
|
| //
|
| // Purpose:
|
| // Converts the charstring retreived by the <f_EPTF_UIHandler_snapshot>
|
| // function to a storeable format. (Changes the ", \n and \ characters.)
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_convertLayout(in charstring pl_layout)
|
| runs on EPTF_UIHandler_Private_CT
|
| return charstring{
|
| var charstring vl_ret := "";
|
| var integer vl_len := lengthof(pl_layout);
|
| for(var integer vl_i := 0; vl_i < vl_len; vl_i := vl_i + 1){
|
| select(substr(pl_layout,vl_i,1)){
|
| case(""""){ vl_ret := vl_ret & "\\""";}
|
| case("\n"){ vl_ret := vl_ret & "\\n";}
|
| case("\\"){ vl_ret := vl_ret & "\\\\";}
|
| case else {vl_ret := vl_ret & pl_layout[vl_i];}
|
| }
|
| }
|
| return vl_ret;
|
| }
|
|
|
| // ///////////////////////////////////////////////////////////
|
| // // Function: f_EPTF_UIHandler_saveXul
|
| // //
|
| // // Purpose:
|
| // // Saves the parameter charstring as a window layout.
|
| // //
|
| // // Detailed Comments:
|
| // // The layout of the window can be retreived with the function
|
| // // <f_EPTF_UIHandler_snapshot>.
|
| // ///////////////////////////////////////////////////////////
|
| // private function f_EPTF_UIHandler_saveXul(in Widgets pl_xul)
|
| // runs on EPTF_UIHandler_Private_CT{
|
| // var charstring vl_layout := f_EPTF_UIHandler_XSD_encodeXUL(pl_xul);
|
| //// var charstring vl_currentConfig := f_EPTF_UIHandler_convertLayout(vl_layout);
|
| // var charstring vl_FileName := f_getTimeFormatted(f_time(),tsp_EPTF_savedGUIPrefix & "_%d%m%Y_%H_%M.xml");
|
| // var integer vl_file := f_FIO_open_trunc_wronly(vl_FileName);
|
| // if(-1 != vl_file){
|
| //// if(-1 == f_FIO_write_text(vl_file, vl_currentConfig)){
|
| // if(-1 == f_FIO_write_text(vl_file, vl_layout)){
|
| // f_EPTF_UIHandler_warning("Couldn't write file "&vl_FileName&".");
|
| // var integer vl_dummy := f_FIO_close(vl_file);
|
| // if (vl_dummy == -1){
|
| // f_EPTF_UIHandler_warning("Could not close the file!");
|
| // }
|
| // // f_EPTF_Base_stop();
|
| // }else{
|
| // var integer vl_dummy := f_FIO_close(vl_file);
|
| // if (vl_dummy == -1){
|
| // f_EPTF_UIHandler_warning("Could not close the file!");
|
| // }
|
| // }
|
| // }else{
|
| // f_EPTF_UIHandler_warning("Couldn't open file "&vl_FileName&" for writing.");
|
| // // f_EPTF_Base_stop();
|
| // }
|
| // }
|
| //
|
| // ///////////////////////////////////////////////////////////
|
| // // Function: f_EPTF_UIHandler_saveWidgets
|
| // //
|
| // // Purpose:
|
| // // Saves content of the GUI database.
|
| // //
|
| // // Detailed Comments:
|
| // // -
|
| // ///////////////////////////////////////////////////////////
|
| // private function f_EPTF_UIHandler_saveWidgets()
|
| // runs on EPTF_UIHandler_Private_CT{
|
| //
|
| // var charstring vl_widget_info := "";
|
| // var integer limit := sizeof(v_UIHandler_guiItemList);
|
| // for (var integer i := 0; i < limit ; i := i+1 )
|
| // {
|
| // vl_widget_info := vl_widget_info&"\n"&int2str(i)&" widget= "&log2str(v_UIHandler_guiItemList[i]);
|
| // }
|
| //
|
| // var charstring vl_FileName := f_getTimeFormatted(f_time(),"widgetList" & "_%d%m%Y_%H_%M.xml");
|
| // var integer vl_file := f_FIO_open_trunc_wronly(vl_FileName);
|
| // if(-1 != vl_file){
|
| //// if(-1 == f_FIO_write_text(vl_file, vl_currentConfig)){
|
| // if(-1 == f_FIO_write_text(vl_file, vl_widget_info)){
|
| // f_EPTF_UIHandler_warning("Couldn't write file "&vl_FileName&".");
|
| // var integer vl_dummy := f_FIO_close(vl_file);
|
| // if (vl_dummy == -1){
|
| // f_EPTF_UIHandler_warning("Could not close the file!");
|
| // }
|
| // // f_EPTF_Base_stop();
|
| // }else{
|
| // var integer vl_dummy := f_FIO_close(vl_file);
|
| // if (vl_dummy == -1){
|
| // f_EPTF_UIHandler_warning("Could not close the file!");
|
| // }
|
| // }
|
| // }else{
|
| // f_EPTF_UIHandler_warning("Couldn't open file "&vl_FileName&" for writing.");
|
| // // f_EPTF_Base_stop();
|
| // }
|
| // }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_revertLayout
|
| //
|
| // Purpose:
|
| // Restores the charstring converted by the <f_EPTF_UIHandler_convertLayout>
|
| // to a charstring that can be given to
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_revertLayout(in charstring pl_layout)
|
| runs on EPTF_UIHandler_Private_CT
|
| return charstring{
|
| var charstring vl_ret := "";
|
| var integer vl_len := lengthof(pl_layout);
|
| for(var integer vl_i := 0; vl_i < vl_len; vl_i := vl_i + 1){
|
| if("\\" == substr(pl_layout,vl_i,1) and vl_i < vl_len-1){
|
| select(substr(pl_layout,vl_i+1,1)){
|
| case(""""){
|
| vl_ret := vl_ret & """";
|
| vl_i := vl_i + 1;
|
| }
|
| case("n"){
|
| vl_ret := vl_ret & "\n";
|
| vl_i := vl_i + 1;
|
| }
|
| case("\\"){
|
| vl_ret := vl_ret & "\\";
|
| vl_i := vl_i + 1;
|
| }
|
| case else {
|
| f_EPTF_UIHandler_warning("Invalid \\ character in layout string at "&int2str(vl_i));
|
| }
|
| }
|
| }else{
|
| vl_ret := vl_ret & pl_layout[vl_i];
|
| }
|
| }
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_send_XTDP
|
| //
|
| // Purpose:
|
| // function to send a message to user interface via XTDP port
|
| //
|
| // Parameters:
|
| // pl_msg - *in* *template ASP_XTDP* - XTDP message template ONLY one message!
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_send_XTDP(in template ASP_XSD_XTDP pl_msg) runs on EPTF_UIHandler_Private_CT
|
| {
|
| if (v_UIHandler_guiConnected)
|
| {
|
| v_UIHandler_lastRequest := v_UIHandler_lastRequest + 1;
|
| pl_msg.data.transactionID := v_UIHandler_lastRequest;
|
|
|
| if(ischosen(pl_msg.data.choice.xTDP_Requests))
|
| {
|
| pl_msg.data.choice.xTDP_Requests.xTDP_Request_list[0].requestId := v_UIHandler_lastRequest;
|
|
|
| if (tsp_EPTF_UIHandler_bufferedXTDP != 0.0)
|
| {
|
| v_UIHandler_Requestbuffer.client_id := omit;
|
|
|
| for (var integer i := 0; i < sizeof(pl_msg.data.choice.xTDP_Requests.xTDP_Request_list); i := i + 1)
|
| {
|
| // v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.xTDP_Request_list[sizeof(v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.xTDP_Request_list)] :=
|
| // valueof(pl_msg.data.choice.xTDP_Requests.xTDP_Request_list[i]);
|
| f_EPTF_UIHandler_requestBuffer_add(valueof(pl_msg.data.choice.xTDP_Requests.xTDP_Request_list[i]));
|
| }
|
| }
|
| }
|
| else if (ischosen(pl_msg.data.choice.xTDP_Responses))
|
| {
|
| pl_msg.data.choice.xTDP_Responses.xTDP_Response_list[0].requestId := v_UIHandler_lastRequest;
|
| }
|
| else if (ischosen(pl_msg.data.choice.xTDP_AddRequests))
|
| {
|
| pl_msg.data.choice.xTDP_AddRequests.xTDP_AddRequest_list[0].requestId := v_UIHandler_lastRequest;
|
| }
|
| else if (ischosen(pl_msg.data.choice.xTDP_RemoveRequests))
|
| {
|
| pl_msg.data.choice.xTDP_RemoveRequests.xTDP_RemoveRequest_list[0].requestId := v_UIHandler_lastRequest;
|
| }
|
| else if (ischosen(pl_msg.data.choice.xTDP_LayoutRequest))
|
| {
|
| //pl_msg.data.choice.xTDP_LayoutRequest.requestId := v_UIHandler_lastRequest;
|
| }
|
| else if (ischosen(pl_msg.data.choice.xTDP_LayoutResponse))
|
| {
|
| //pl_msg.data.choice.xTDP_LayoutResponse.requestId := v_UIHandler_lastRequest;
|
| }
|
| else if (ischosen(pl_msg.data.choice.xTDP_AuthChallenge) or ischosen(pl_msg.data.choice.xTDP_AuthResponse))
|
| {
|
| }
|
| else
|
| {
|
| f_EPTF_UIHandler_warning("Unknown XTDP message to send!");
|
| return;
|
| }
|
|
|
| if(tsp_EPTF_UIHandler_bufferedXTDP == 0.0 or ( tsp_EPTF_UIHandler_bufferedXTDP != 0.0 and not ischosen(pl_msg.data.choice.xTDP_Requests)))
|
| {
|
| for(var integer i := 0; i < sizeof(v_UIHandler_GUIClientId); i := i + 1)
|
| {
|
| var Result vl_result
|
| f_EPTF_Transport_send(
|
| IPL4, v_UIHandler_GUIClientId[i].clientId, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(valueof(pl_msg.data))), vl_result, false)
|
| }
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Templates: t_UIHandler_Authmsg
|
| //
|
| // Purpose:
|
| // Send template for authenticating the GUI
|
| //
|
| // Parameters:
|
| // pl_client -- the GUI client
|
| //
|
| ///////////////////////////////////////////////////////////
|
| /*private template ASP_XTDP t_UIHandler_Authmsg(in integer pl_clientid) := {
|
| pl_clientid,
|
| {omit,
|
| {xtdp_AuthChallenge := tsp_EPTF_UIHandler_Authmsg}
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Templates: t_UIHandler_Authresp
|
| //
|
| // Purpose:
|
| // Receinving template for authenticating the GUI
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private template ASP_XTDP t_UIHandler_Authresp := {
|
| *,
|
| {omit,
|
| {xtdp_AuthResponse := ?}
|
| }
|
| }
|
| */
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_authclient
|
| //
|
| // Purpose:
|
| // Authenticates the client.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_authclient(in integer pl_clientid) runs on EPTF_UIHandler_Private_CT return boolean{
|
| if (tsp_EPTF_UIHandler_Authmsg=="" or v_EPTF_UIHandler_Authresp == "") {
|
| // no authentication needed
|
| f_EPTF_UIHandler_setClientAuthenticationSuccessful(pl_clientid);
|
| return true;
|
| }
|
| v_UIHandler_lastRequest := v_UIHandler_lastRequest +1;
|
| var integer vl_UIHandler_authResponseReceivedSemaphore := f_EPTF_Semaphore_new();
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message vl_messageToSend :=
|
| {
|
| vl_UIHandler_authResponseReceivedSemaphore+1000*v_UIHandler_lastRequest,
|
| {xTDP_AuthChallenge := tsp_EPTF_UIHandler_Authmsg}
|
| }
|
|
|
| var Result vl_result
|
| f_EPTF_Transport_send(IPL4, pl_clientid, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false)
|
|
|
| if(f_EPTF_Semaphore_waitForUnlock(vl_UIHandler_authResponseReceivedSemaphore, v_authMaxTime))
|
| {
|
| f_EPTF_UIHandler_warning(%definitionId&": Timer timeout! No auth response received!");
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| return false;
|
| }
|
| //f_EPTF_Semaphore_lock(v_UIHandler_authResponseReceivedSemaphore);
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| if(v_UIHandler_receivedMessage.choice.xTDP_AuthResponse == v_EPTF_UIHandler_Authresp)
|
| {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Authentication successful for client: "&log2str(pl_clientid));
|
| }
|
| f_EPTF_UIHandler_setClientAuthenticationSuccessful(pl_clientid);
|
| return true;
|
| }
|
| else
|
| {
|
| f_EPTF_UIHandler_warning("Authentication failed for client: "&log2str(pl_clientid));
|
| return false;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_headlessmode
|
| //
|
| // Purpose:
|
| // Sets the enviroment for the headless mode
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_headlessmode() runs on EPTF_UIHandler_Private_CT{
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("******** HeadlessMode*******");
|
| }
|
| if (not v_EPTF_UIHandler_servermode){
|
| v_UIHandler_pingcounter := 0;
|
| v_UIHandler_prevpingcounter := 0;
|
| v_UIHandler_succpingcounter := 0;
|
| if(not t_UIHandler_pingtimer.running) {
|
| t_UIHandler_pingtimer.start;
|
| }
|
| } else {
|
| f_EPTF_UIHandler_startserverxtdp();
|
| }
|
| v_UIHandler_guiConnected := false;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_headlessmodeover
|
| //
|
| // Purpose:
|
| // Restores the enviroment returning back from headless mode
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_headlessmodeover() runs on EPTF_UIHandler_Private_CT{
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("*********HeadlessModeOVER********")
|
| }
|
| if (not v_EPTF_UIHandler_servermode){
|
| if (t_UIHandler_pingtimer.running) {
|
| t_UIHandler_pingtimer.stop;
|
| }
|
| v_UIHandler_pingcounter := 0;
|
| v_UIHandler_prevpingcounter := 0;
|
| v_UIHandler_succpingcounter := 0;
|
| var ConnectionId vl_connId;
|
| f_EPTF_UIHandler_connectAndInitGui(vl_connId);
|
| //In case of v_EPTF_UIHandler_servermode, the f_EPTF_UIHandler_connectAndInitGui
|
| //simply returns true
|
| //} else {
|
| // if (not f_EPTF_UIHandler_connectAndInitGui()){
|
| // f_EPTF_UIHandler_error("Failed to initialize the GUI!");
|
| // }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_sendSubscAck
|
| //
|
| // Purpose:
|
| // Sends acknowladgement message about a succesfully completed subscription note
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_sendSubscAck(
|
| in integer pl_requestId,
|
| in integer pl_varIdx,
|
| in EPTF_Var_CT pl_sender,
|
| in boolean pl_ack := true)
|
| runs on EPTF_UIHandler_Private_CT {
|
| v_UIHandler_subscriptInProcess := false;
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_CLL_UISubscMgmtMsg := {
|
| subscribeAck := {
|
| requestId := pl_requestId,
|
| varIdx := pl_varIdx}};
|
| EPTF_adminPort_CP.send(vl_EPTF_CLL_UISubscMgmtMsg) to pl_sender
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_sendSubscNAck
|
| //
|
| // Purpose:
|
| // Sends an refusion message about a subscription note
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_sendSubscNAck(
|
| in integer pl_requestId,
|
| in EPTF_Var_CT pl_sender)
|
| runs on EPTF_UIHandler_Private_CT {
|
| v_UIHandler_subscriptInProcess := false;
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_CLL_UISubscMgmtMsg := {
|
| subscribeNAck := {
|
| requestId := pl_requestId,
|
| varIdx := -1
|
| }
|
| };
|
| EPTF_adminPort_CP.send(vl_EPTF_CLL_UISubscMgmtMsg) to pl_sender;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Group: EPTF_SubscriptionAdministrationFunctions
|
| ///////////////////////////////////////////////////////////
|
| group EPTF_SubscriptionAdministrationFunctions{
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_newSubscription
|
| //
|
| // Purpose:
|
| // Appends an EPTF_UIHandler_OpenSubscription record to the <EPTF_UIHandler_OpenSubscriptions> list.
|
| //
|
| // Parameters:
|
| // pl_subscription - *in* *EPTF_UIHandler_OpenSubscription* - The record to append.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_newSubscription(in EPTF_UIHandler_OpenSubscription pl_subscription)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| var integer vl_newIdx := sizeof(v_UIHandler_openSubscriptions);
|
| v_UIHandler_openSubscriptions[vl_newIdx] := pl_subscription;
|
| f_EPTF_UIHandler_addSubscription(pl_subscription.varIdx, vl_newIdx);
|
|
|
| if (pl_subscription.providedParamName != "") {
|
| f_EPTF_str2int_HashMap_Insert(v_UIHandler_subscriptionHashMapIdVar, pl_subscription.providedParamName, pl_subscription.varIdx);
|
| }
|
|
|
| if (pl_subscription.widgetId != "") {
|
| f_EPTF_str2int_HashMap_Insert(v_UIHandler_subscriptionHashMapId, pl_subscription.widgetId, vl_newIdx);
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getSubscriptionsByVarIdx
|
| //
|
| // Purpose:
|
| // Retrieves a list of open subscriptions that are affected by the specified variable.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_getSubscriptionsByVarIdx(in integer pl_varIdx, out EPTF_UIHandler_OpenSubscriptions pl_ret)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
|
|
| var EPTF_IntegerList vl_subs := f_EPTF_UIHandler_getSubscriptions(pl_varIdx);
|
|
|
| pl_ret := {};
|
| for(var integer vl_i := 0; vl_i < sizeof(vl_subs); vl_i := vl_i+1){
|
| pl_ret[sizeof(pl_ret)] := v_UIHandler_openSubscriptions[vl_subs[vl_i]];
|
| }
|
| return sizeof(pl_ret) > 0;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getSubscriptionIdxByWidgetId
|
| //
|
| // Return Value:
|
| // The index of the open subscription that contains the specified widgetId or -1.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_getSubscriptionIdxByWidgetId(in EPTF_UIHandler_WidgetIdString pl_widgetId)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| if("" == pl_widgetId){
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": No subscription belongs to empty ID!");
|
| }
|
| return -1;
|
| }
|
| // find id in subscription hashmap
|
| var integer vl_idx;
|
| if (f_EPTF_str2int_HashMap_Find(v_UIHandler_subscriptionHashMapId, pl_widgetId, vl_idx)) {
|
| return vl_idx;
|
| }
|
| return -1;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getVarIdxByProvidedVarName
|
| //
|
| // Return Value:
|
| // The index of the open subscription that contains the
|
| // specified client variable name.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_getVarIdxByProvidedVarName(in charstring pl_varName)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| if("" == pl_varName){
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": No subscription belongs to empty variable name!");
|
| }
|
| return -1;
|
| }
|
| // find id in subscription hashmap
|
| var integer vl_idx;
|
| if (f_EPTF_str2int_HashMap_Find(v_UIHandler_subscriptionHashMapIdVar, pl_varName, vl_idx)) {
|
| return vl_idx;
|
| }
|
| return -1;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addSubscription
|
| //
|
| // Purpose:
|
| // Adds a subscription item to a variable
|
| //
|
| // Parameters:
|
| // pl_idx - *in* *integer* - the idx of the EPTF_Var
|
| // pl_subsIdx - *in* *integer* - subscription identifier index
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_addSubscription(in integer pl_idx, in integer pl_subsIdx)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if(sizeof(v_UIHandler_subscriptions) <= pl_idx or not isbound(v_UIHandler_subscriptions[pl_idx])) {
|
| v_UIHandler_subscriptions[pl_idx] := {};
|
| }
|
| v_UIHandler_subscriptions[pl_idx][sizeof(v_UIHandler_subscriptions[pl_idx])] := pl_subsIdx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_removeSubscription
|
| //
|
| // Purpose:
|
| // Removes a subscription item from a variable
|
| //
|
| // Parameters:
|
| // pl_idx - *in* *integer* - the idx of the EPTF_Var
|
| // pl_subsIdx - *in* *integer* - subscription identifier index
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_removeSubscription(in integer pl_idx, in integer pl_subsIdx)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_Base_assert(%definitionId&": not a local subscription.",
|
| sizeof(v_UIHandler_subscriptions) > pl_idx and isbound(v_UIHandler_subscriptions[pl_idx]));
|
| var integer vl_subIdx := -1;
|
| for (var integer i := 0; i < sizeof(v_UIHandler_subscriptions[pl_idx]); i := i + 1)
|
| {
|
| if (v_UIHandler_subscriptions[pl_idx][i] == pl_subsIdx)
|
| {
|
| vl_subIdx := i;
|
| break;
|
| }
|
| }
|
|
|
| if (vl_subIdx != -1)
|
| {
|
| var EPTF_IntegerList vl_newSubs := {};
|
| for (var integer i := 0; i < sizeof(v_UIHandler_subscriptions[pl_idx]); i := i + 1)
|
| {
|
| if (vl_subIdx != i) { vl_newSubs[sizeof(vl_newSubs)] := v_UIHandler_subscriptions[pl_idx][i]; }
|
| }
|
| v_UIHandler_subscriptions[pl_idx] := vl_newSubs;
|
| return;
|
| }
|
|
|
| f_EPTF_UIHandler_warning(log2str("The variable: ", f_EPTF_Var_getName(pl_idx), " has no subscription: ", pl_subsIdx));
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getSubscriptions
|
| //
|
| // Purpose:
|
| // Gets the subscription indices of a variable
|
| //
|
| // Parameters:
|
| // pl_idx - *in* *integer* - the idx of the EPTF_Var
|
| //
|
| // Return Value:
|
| // <EPTF_IntegerList> - the list of subscripton indices of the variable
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_getSubscriptions(in integer pl_idx)
|
| runs on EPTF_UIHandler_Private_CT return EPTF_IntegerList
|
| {
|
| if (sizeof(v_UIHandler_subscriptions) <= pl_idx or
|
| not isbound(v_UIHandler_subscriptions[pl_idx])) {
|
| return {};
|
|
|
| }
|
|
|
| return v_UIHandler_subscriptions[pl_idx];
|
| }
|
|
|
| } //EPTF_SubscriptionAdministrationFunctions group
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Group: EPTF_WidgetAdministrationFunctions
|
| ///////////////////////////////////////////////////////////
|
| group EPTF_WidgetAdministrationFunctions{
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_widgetTypeFromId
|
| //
|
| // Purpose:
|
| // Gets the type of a widget
|
| // Detailed Comments:
|
| // There are two main cases:
|
| // the widget ID describes a cell of a tree in form "name of the tree".[row].[column], or
|
| // the ID is the widget's own ID
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_widgetTypeFromId(
|
| in EPTF_UIHandler_WidgetIdString pl_id,
|
| inout EPTF_UIHandler_OpenSubscription pl_subs)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| // cehck if id refers a table cell in format "treeId.[row].[col]"
|
| var integer vl_row, vl_col;
|
| var EPTF_UIHandler_WidgetIdString vl_treeId;
|
| if (f_EPTF_UIHandler_isTreeCellIdFormat(pl_id, vl_treeId, vl_row, vl_col)) {
|
| var EPTF_UIHandler_GuiItemRec widgetRec;
|
| if(f_EPTF_UIHandler_getWidgetRec(vl_treeId, widgetRec)){
|
| if(vl_col <= sizeof(widgetRec.widgetData.treeData.columns)){
|
| pl_subs.widgetType := wtTreecell;
|
| pl_subs.widgetDataType := v_UIHandler_guiItemList[widgetRec.widgetData.treeData.columns[vl_col]].widgetDataType;
|
| return true;
|
| }
|
| }
|
| }else{
|
| var EPTF_UIHandler_GuiItemRec widgetRec;
|
| if(f_EPTF_UIHandler_getWidgetRec(pl_id, widgetRec)){
|
| pl_subs.widgetType := widgetRec.widgetType;
|
| //The cell also contains widgetDataType
|
| pl_subs.widgetDataType := widgetRec.widgetDataType;
|
| return true;
|
| }
|
| }
|
| return false;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_checkSubscriptCompatibility
|
| // Purpose:
|
| // Checks whether the subscriptable variable and the widget
|
| // are compatible
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_checkSubscriptCompatibility(
|
| in EPTF_UIHandler_WidgetIdString pl_widgetid,
|
| in integer pl_varIdx,
|
| in EPTF_Var_DirectContent pl_currentContent := {unknownVal:={omit}})
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var integer vl_index := f_EPTF_UIHandler_widgetRecIndex(pl_widgetid);
|
| if (vl_index==-1) {
|
| f_EPTF_UIHandler_error("The specified '"&pl_widgetid&"' widget can not be connected to variable["&f_EPTF_Var_getName(pl_varIdx)&"]: widget not found!");
|
| return false;
|
| }
|
| var EPTF_Var_DirectContent vl_currentContent := pl_currentContent;
|
| var boolean vl_retval;
|
| var boolean vl_checkReverse := false;
|
| if (ischosen(vl_currentContent.unknownVal)) {
|
| f_EPTF_Var_getContent(pl_varIdx,vl_currentContent);
|
| }
|
|
|
| select(v_UIHandler_guiItemList[vl_index].widgetType){
|
| case(wtWindow, // nothing to check NOW
|
| wtTabbox,
|
| wtTabs,
|
| wtTab,
|
| wtTabpanels,
|
| wtTabpanel,
|
| wtTabpages,
|
| wtTabpage,
|
| wtTree,
|
| wtTreecols,
|
| wtTreecol,
|
| wtTreechildren,
|
| wtTreeitem,
|
| wtTreerow,
|
| wtHbox,
|
| wtLabel,
|
| wtSpacer,
|
|
|
| wtChart,
|
| wtTraceList,
|
|
|
| wtToolbar,
|
| wtToolbarbuttons,
|
|
|
| wtSeparator,
|
| wtListbox,
|
| wtListitem,
|
|
|
| wtNumericalwidget,
|
|
|
| wtMenulist,
|
| wtMenuitem,
|
| wtDistributionchart,
|
| wtIntervallimits,
|
| wtValuelist,
|
| wtImage,
|
| wtUnknown){
|
| vl_retval := true;
|
| }
|
| case(wtTreecell){
|
| vl_checkReverse := true;
|
| select(v_UIHandler_guiItemList[vl_index].widgetDataType){
|
| case(checkBox){vl_retval := ischosen(vl_currentContent.boolVal)}
|
| case(toggleButton){vl_retval := ischosen(vl_currentContent.boolVal)}
|
| case(floatField){vl_retval := ischosen(vl_currentContent.floatVal)}
|
| case(pushButton, integerField){vl_retval := ischosen(vl_currentContent.intVal)}
|
| case(string){ vl_retval := ischosen(vl_currentContent.charstringVal)
|
| or ischosen(vl_currentContent.floatVal)
|
| or ischosen(vl_currentContent.intVal)
|
| /* string forever */
|
| or ischosen(vl_currentContent.bitstringVal) or ischosen(vl_currentContent.hexstringVal) or ischosen(vl_currentContent.octetstringVal)
|
| or ischosen(vl_currentContent.boolVal)
|
| or ischosen(vl_currentContent.statusLEDVal)
|
| or ischosen(vl_currentContent.integerlistVal) or ischosen(vl_currentContent.floatlistVal) or ischosen(vl_currentContent.charstringlistVal)
|
| }
|
| case(statusLED){vl_retval := ischosen(vl_currentContent.statusLEDVal)
|
| /* its not equal, because type without are make errror on runtime gui if returned with text,
|
| text but better if this equal this time just no returned text on request
|
| and (ispresent(vl_currentContent.statusLEDVal.text)==false or vl_currentContent.statusLEDVal.text == "") */; }
|
| case(statusLEDWithText){vl_retval := ischosen(vl_currentContent.statusLEDVal)}
|
| case else { }
|
| }
|
| }
|
| case (wtButton){
|
| vl_retval := ischosen(vl_currentContent.intVal);
|
| }
|
| case (wtPushbutton){
|
| vl_retval := ischosen(vl_currentContent.intVal);
|
| }
|
| case(wtTextbox){vl_retval := true; } // string forever
|
| case(wtHtmlcode){vl_retval := true; } // string forever
|
| case(wtTrace){
|
| vl_retval := (ischosen(vl_currentContent.floatVal) or ischosen(vl_currentContent.intVal));
|
| }
|
| case (wtToolbarbutton, wtTogglebutton){
|
| vl_retval := ischosen(vl_currentContent.boolVal);
|
| }
|
| case else {
|
| vl_retval := true; // all other are true now
|
| }
|
| }
|
| if(isbound(vl_retval)==false) {
|
| f_EPTF_UIHandler_error("The specified '"&pl_widgetid&"' widget with data("&log2str(v_UIHandler_guiItemList[vl_index])&") not match to variable["&f_EPTF_Var_getName(pl_varIdx)&"]: type incompatibility!");
|
| } else if(vl_retval == false) {
|
| f_EPTF_UIHandler_error("The specified '"&pl_widgetid&"' widget with data("&log2str(v_UIHandler_guiItemList[vl_index])&") can not be connected to variable["&f_EPTF_Var_getName(pl_varIdx)&"]: type incompatibility!");
|
| }
|
| else {
|
| if(vl_checkReverse == true and ispresent( v_UIHandler_guiItemList[vl_index].widgetDataType)) {
|
| vl_retval := f_EPTF_UIHandler_checkVariableCompatibility(vl_currentContent, v_UIHandler_guiItemList[vl_index].widgetDataType);
|
| }
|
| if(vl_retval == false) {
|
| f_EPTF_UIHandler_error("The specified variable["&f_EPTF_Var_getName(pl_varIdx)&"] can not be connected to specified '"&pl_widgetid&"' widget with data("&log2str(v_UIHandler_guiItemList[vl_index])&"): type incompatibility!");
|
| }
|
| }
|
|
|
| return vl_retval;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_checkVariableCompatibility
|
| // Purpose:
|
| // Checks whether the the requeted variable and the widget
|
| // type are compatible
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_checkVariableCompatibility(
|
| in EPTF_Var_DirectContent pl_currentContent,
|
| in Widgettype pl_currentwidgetDataType)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var boolean vl_retval := false;
|
|
|
| if(ischosen(pl_currentContent.intVal)) {
|
| vl_retval := (pl_currentwidgetDataType == integerField)
|
| or (pl_currentwidgetDataType == pushButton)
|
| or (pl_currentwidgetDataType == trace)
|
| or (pl_currentwidgetDataType == string); // string forever
|
| }
|
| else
|
| if(ischosen(pl_currentContent.floatVal)) {
|
| vl_retval := (pl_currentwidgetDataType == floatField)
|
| or (pl_currentwidgetDataType == string); // string forever
|
| }
|
| else
|
| if(ischosen(pl_currentContent.charstringVal)) {
|
| vl_retval := (pl_currentwidgetDataType == string)
|
| or (pl_currentwidgetDataType == image);
|
| }
|
| else
|
| if(ischosen(pl_currentContent.bitstringVal) or ischosen(pl_currentContent.hexstringVal) or ischosen(pl_currentContent.octetstringVal)) {
|
| vl_retval := (pl_currentwidgetDataType == string);
|
| }
|
| else
|
| if(ischosen(pl_currentContent.boolVal)) {
|
| vl_retval := (pl_currentwidgetDataType == checkBox)
|
| or (pl_currentwidgetDataType == toggleButton)
|
| or (pl_currentwidgetDataType == string); // string forever
|
| }
|
| else
|
| if(ischosen(pl_currentContent.statusLEDVal)) {
|
| vl_retval := (pl_currentwidgetDataType == statusLED)
|
| or (pl_currentwidgetDataType == statusLEDWithText)
|
| or (pl_currentwidgetDataType == string); // string forever
|
| }
|
| else
|
| if(ischosen(pl_currentContent.integerlistVal) or ischosen(pl_currentContent.floatlistVal) or ischosen(pl_currentContent.charstringlistVal)) {
|
| vl_retval := (pl_currentwidgetDataType == valueList)
|
| or (pl_currentwidgetDataType == string); // string forever
|
| }
|
| // If not matched
|
| if(vl_retval == false) {
|
| vl_retval := (pl_currentwidgetDataType == image)
|
| or (pl_currentwidgetDataType == none_);
|
| }
|
| return vl_retval;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_handleSubscriptNote
|
| // Purpose:
|
| // Handles te subscription note message
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_handleSubscriptNote(
|
| in EPTF_UIHandler_SubscribeNoteMsg pl_msg,
|
| in EPTF_Var_CT pl_sender)
|
| runs on EPTF_UIHandler_Private_CT {
|
| v_UIHandler_subscriptInProcess := true;
|
| var EPTF_UIHandler_OpenSubscription vl_subs := c_UIHandler_defOpenSubscription;
|
| var integer vl_varIdx := -1;
|
| if(ispresent(pl_msg.destParamName) and "" != pl_msg.destParamName){
|
| //we must create a new variable and subscribe it to a provided param
|
| //check if it already exists
|
| if(not f_EPTF_Var_checkName(pl_msg.destParamName,vl_varIdx)) // i.e. vl_varIdx != -1
|
| {
|
| f_EPTF_UIHandler_warning("CLL_UIHandler: the destination variable already exists: " & pl_msg.destParamName);
|
| f_EPTF_UIHandler_sendSubscNAck(pl_msg.messageId, pl_sender);
|
| return;
|
| }
|
| //log("DEBUG: ","------- subscribeRemote ------- ",pl_msg.providedParamName);
|
| //In case of error the remote variable stops the test
|
| f_EPTF_Var_subscribeRemote(
|
| pl_msg.remoteCompRef,
|
| pl_msg.providedParamName,
|
| pl_msg.subsMode,
|
| vl_varIdx,
|
| pl_msg.destParamName,
|
| pl_msg.refreshRate);
|
| f_EPTF_Var_addPostProcFn(vl_varIdx, {refers(f_EPTF_UIHandler_refreshVar),{}});
|
|
|
| // FIXME: test
|
| // FIXME: This should be put back if old gui build using SubsCanAdjust is working:
|
| //f_EPTF_Var_addSubsCanAdjustNotifyFn(vl_varIdx, {refers(f_EPTF_UIHandler_updateDisableStateByVarIdx), {}});
|
|
|
| }else{
|
| //There is no destParamName, so it's an ealrier subscription
|
| //Get the index of the variable
|
| vl_varIdx := f_EPTF_UIHandler_getVarIdxByProvidedVarName(pl_msg.providedParamName);
|
| if(-1 == vl_varIdx){
|
| f_EPTF_UIHandler_warning("CLL_UIHandler: there is no subscription to the variable: " & pl_msg.providedParamName);
|
| f_EPTF_UIHandler_sendSubscNAck(pl_msg.messageId, pl_sender);
|
| return;
|
| }
|
| }
|
| if(ispresent(pl_msg.widgetId)){
|
| if (f_EPTF_UIHandler_Config_connectToWidget(pl_msg.widgetId,vl_varIdx,pl_msg.remoteCompRef,pl_msg.providedParamName)) {
|
| // FIXME: This should be put back if old gui build using SubsCanAdjust is working:
|
| //f_EPTF_UIHandler_updateDisableStateByVarIdx(vl_varIdx, {});
|
| f_EPTF_UIHandler_sendSubscAck(pl_msg.messageId, vl_varIdx, pl_sender);
|
| } else {
|
| f_EPTF_UIHandler_sendSubscNAck(pl_msg.messageId, pl_sender);
|
| }
|
| return;
|
| } else {
|
| vl_subs.widgetId := "";
|
| }
|
| vl_subs.provider := pl_msg.remoteCompRef;
|
| vl_subs.varIdx := vl_varIdx;
|
| vl_subs.providedParamName:=pl_msg.providedParamName;
|
| //FIXME!!!Check compatibility
|
| f_EPTF_UIHandler_newSubscription(vl_subs);
|
| f_EPTF_UIHandler_sendSubscAck(pl_msg.messageId, vl_varIdx, pl_sender);
|
| if(ispresent(pl_msg.widgetId)){
|
| f_EPTF_UIHandler_refreshWidget(vl_subs, true);
|
| // FIXME: This should be put back if old gui build using SubsCanAdjust is working:
|
| //f_EPTF_UIHandler_updateDisableStateByVarIdx(vl_varIdx, {});
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_refreshVar
|
| //
|
| // Purpose:
|
| // Postproc. The component refreshes the content of the GUI
|
| // when the content of the variable changes
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_refreshVar(in integer pl_idx, in EPTF_IntegerList pl_argList)
|
| runs on EPTF_UIHandler_Private_CT {
|
| if (not v_UIHandler_initialized) {
|
| return;
|
| }
|
|
|
| var EPTF_UIHandler_OpenSubscriptions vl_subsList;
|
| if (not f_EPTF_UIHandler_getSubscriptionsByVarIdx(pl_idx, vl_subsList)){
|
| f_EPTF_UIHandler_warning("The subscriptionlist is empty for this variable!");
|
| }
|
| for(var integer vl_i := 0; vl_i < sizeof(vl_subsList); vl_i := vl_i+1){
|
| //Put the received value to the screen. It can differ from the typed value.
|
| //log("DEBUG: ","---- postproc - ",vl_subsList[vl_i].widgetId, " - ", v_EPTF_Vars[vl_subsList[vl_i].varIdx].content.direct);
|
| f_EPTF_UIHandler_refreshWidget(vl_subsList[vl_i]);
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_removeWidgetFromSubscription
|
| // Purpose:
|
| // Clears the widgetId member of the open subscription associated
|
| // with the specified widget.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_removeWidgetFromSubscription(in EPTF_UIHandler_WidgetIdString pl_widgetId)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var integer vl_idx := f_EPTF_UIHandler_getSubscriptionIdxByWidgetId(pl_widgetId);
|
| if(-1 == vl_idx){
|
| return false;
|
| }
|
| f_EPTF_str2int_HashMap_Erase(v_UIHandler_subscriptionHashMapId, pl_widgetId);
|
| v_UIHandler_openSubscriptions[vl_idx].widgetId := "";
|
| return true;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_removeIdFromIdList
|
| // Purpose:
|
| // Removes an integer from an integer list.
|
| //
|
| // Return Value:
|
| // A new list of integers without gaps and the specified integer.
|
| //
|
| // Detailed Comments:
|
| // The function handles only unique integers.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_removeIdFromIdList(in EPTF_IntegerList pl_in, in integer pl_idx)
|
| return EPTF_IntegerList{
|
| var EPTF_IntegerList vl_ret := {};
|
| var integer vl_i := 0;
|
| while(vl_i < sizeof(pl_in)){
|
| if(pl_in[vl_i] != pl_idx){
|
| vl_ret[sizeof(vl_ret)] := pl_in[vl_i];
|
| }
|
| vl_i := vl_i + 1;
|
| }
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addIdx2IdxList
|
| // Purpose:
|
| // Simply append an integer to an integer list.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_addIdx2IdxList(inout EPTF_IntegerList pl_in, in integer pl_idx){
|
| pl_in[sizeof(pl_in)] := pl_idx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_insertIdx2IdxList
|
| // Purpose:
|
| // Insert a new integer into an integer list in a specific index
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_insertIdx2IdxList(inout EPTF_IntegerList pl_in, in integer pl_idx, in integer pl_value){
|
| for ( var integer i := sizeof(pl_in)-1; i >= pl_idx ; i := i-1 ) {
|
| pl_in[i+1] := pl_in[i];
|
| }
|
| pl_in[pl_idx] := pl_value;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_IdxListContains
|
| // Return Value:
|
| // True if the integerlist contains the specified value.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_IdxListContains(in EPTF_IntegerList pl_in, in integer pl_idx)
|
| return boolean{
|
| for(var integer vl_i := 0; vl_i < sizeof(pl_in); vl_i := vl_i + 1){
|
| if(pl_in[vl_i] == pl_idx){return true;}
|
| }
|
| return false;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_parentColOfCell
|
| // Purpose:
|
| // Retrieves the GUI index of the column into which the cell is placed
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_parentColOfCell(in integer pl_parent)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| if(-1 == pl_parent){return -1;}
|
| var integer vl_i := pl_parent;
|
| while(vl_i != -1 and v_UIHandler_guiItemList[vl_i].widgetType != wtTreecol){
|
| vl_i := v_UIHandler_guiItemList[vl_i].parentIdx;
|
| }
|
| if(vl_i != -1 and v_UIHandler_guiItemList[vl_i].widgetType == wtTreecol){
|
| return vl_i;
|
| }
|
| return -1;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addWidgetRec
|
| // Purpose:
|
| // Adds the specified record about a widget to the list
|
| // of the widgets.
|
| //
|
| // Return Value:
|
| // The index of the new record if succes, or -1
|
| //
|
| // Detailed Comments:
|
| // If there is already a widget with the same id with the
|
| // same type under the same parent, the function returns
|
| // the index of the previous widget, and sets the pl_widgetExists to true.
|
| // If pl_indexInParent parameter is given (not -1), widgetrec is placed
|
| // to that position in parents' childrenlist.
|
| // This is needed for tree column insertion.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_addWidgetRec(
|
| in EPTF_UIHandler_GuiItemRec pl_widgetRec,
|
| inout boolean pl_widgetExists/*,
|
| in integer pl_indexInParent := -1*/)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": "&log2str(pl_widgetRec));
|
| }
|
| pl_widgetExists := false;
|
| //Checking the index of the parent item. Less than 0 is valid for the main window.
|
| if(pl_widgetRec.parentIdx> sizeof(v_UIHandler_guiItemList) or
|
| (pl_widgetRec.parentIdx < 0 and (pl_widgetRec.widgetType != wtWindow))){
|
| f_EPTF_UIHandler_warning("Invalid parent index for the widget "&pl_widgetRec.id&".");
|
| return -1;
|
| }
|
|
|
| //If the parent widget from the pl_widgetRec.parentIdx is a tabpages, then pl_widgetRec.widgetType can only be a tabpage,
|
| //else warning and return -1
|
| if( ((pl_widgetRec.parentIdx > -1) and pl_widgetRec.widgetType != wtTabpage and pl_widgetRec.widgetType != wtMetaIterator) and v_UIHandler_guiItemList[pl_widgetRec.parentIdx].widgetType == wtTabpages){
|
| f_EPTF_UIHandler_warning("Under a tabpages widget only widgets with type tabpage is allowed: "&pl_widgetRec.id&".");
|
| return -1;
|
| }
|
|
|
| var boolean vl_xuldisabled := false;
|
| if(ispresent(pl_widgetRec.xuldisabled)){
|
| vl_xuldisabled := pl_widgetRec.xuldisabled;
|
| }
|
| var EPTF_UIHandler_GuiItemRec vl_newRec := {
|
| id := pl_widgetRec.id,
|
| widgetType := pl_widgetRec.widgetType,
|
| widgetDataType := pl_widgetRec.widgetDataType,
|
| parentIdx := pl_widgetRec.parentIdx,
|
| children := {},
|
| widgetData := pl_widgetRec.widgetData,
|
| XULformat := pl_widgetRec.XULformat,
|
| xuldisabled := vl_xuldisabled
|
| };
|
| //Checking ID
|
| var integer vl_idx;
|
| var boolean vl_isexisting := (pl_widgetRec.id != "" and f_EPTF_str2int_HashMap_Find(v_UIHandler_widgetHashMapId, pl_widgetRec.id, vl_idx));
|
| var integer vl_prevIdx := -1;
|
| if(pl_widgetRec.XULformat != omit and ischosen(pl_widgetRec.XULformat.treecell)){
|
| var Treecell vl_treecell := pl_widgetRec.XULformat.treecell;
|
| vl_treecell.id := omit;
|
| vl_prevIdx := f_EPTF_UIHandler_widgetRecIndex(pl_widgetRec.id, f_EPTF_UIHandler_deleteChildrenFromTreecell(vl_treecell));
|
| } else {
|
| vl_prevIdx := f_EPTF_UIHandler_widgetRecIndex(pl_widgetRec.id);
|
| }
|
|
|
| if(vl_isexisting == true){ // old -1 != vl_prevIdx
|
| f_EPTF_UIHandler_setWidgetOriginalDisabled(vl_prevIdx); // Set original [xul] disabled state
|
| if(v_UIHandler_customGUIProcess){
|
| f_EPTF_UIHandler_error(%definitionId&": Duplicate widget ID: "& pl_widgetRec.id&"\nThe GUI descriptor is: "&log2str("v_UIHandler_widgetslist"));
|
| }else{
|
| var integer vl_row, vl_col;
|
| var EPTF_UIHandler_WidgetIdString vl_treeId;
|
| if (not f_EPTF_UIHandler_isTreeCellIdFormat(pl_widgetRec.id, vl_treeId, vl_row, vl_col)){
|
| pl_widgetExists := true;
|
| }
|
| if(v_UIHandler_guiItemList[vl_prevIdx].widgetType != pl_widgetRec.widgetType or
|
| v_UIHandler_guiItemList[vl_prevIdx].parentIdx != pl_widgetRec.parentIdx){
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Duplicate widget ID: "& pl_widgetRec.id);
|
| }
|
| return -1;
|
| }else{
|
| //There is a similar widget
|
| return vl_prevIdx;
|
| }
|
| }
|
| }
|
|
|
| if(-1 == vl_prevIdx){
|
| var integer vl_newIdx := sizeof(v_UIHandler_guiItemList);
|
| v_UIHandler_guiItemList[vl_newIdx] := vl_newRec;
|
| if(vl_newRec.widgetType != wtMetaIterator) {
|
| if( v_UIHandler_actualParentIdxIsFilled == false) {
|
| //window's parent is -1, but getNonMeta gives 0 back, because window has 0 id
|
| if(vl_newRec.widgetType != wtWindow){
|
| v_UIHandler_actualParentIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(vl_newIdx);
|
| } else {
|
| v_UIHandler_actualParentIdx := pl_widgetRec.parentIdx;
|
| }
|
| v_UIHandler_actualParentIdxIsFilled := true
|
| v_UIHandler_widgetIdxList[sizeof(v_UIHandler_widgetIdxList)] := vl_newIdx;
|
| } else if( v_UIHandler_actualParentIdx == f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(vl_newIdx) or
|
| /*because tabpagelist: put all tabpagelist element, if same it has parent as the first tabpage element*/
|
| ( v_UIHandler_actualParentIdx != -1 and vl_newRec.widgetType == wtTabpage and
|
| f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(v_UIHandler_guiItemList[vl_newIdx].parentIdx) ==
|
| f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(v_UIHandler_guiItemList[v_UIHandler_actualParentIdx].parentIdx)
|
| )
|
| ) {
|
| v_UIHandler_widgetIdxList[sizeof(v_UIHandler_widgetIdxList)] := vl_newIdx;
|
| }
|
| }
|
|
|
| // add widget id to the widgetId map
|
| if (vl_newRec.id != "") {
|
| f_EPTF_str2int_HashMap_Insert(v_UIHandler_widgetHashMapId, vl_newRec.id, vl_newIdx);
|
| }
|
| //Add to its parent's childrenlist
|
| if(-1 != vl_newRec.parentIdx){
|
| //if (pl_indexInParent <0) {
|
| v_UIHandler_guiItemList[vl_newRec.parentIdx].children[sizeof(v_UIHandler_guiItemList[vl_newRec.parentIdx].children)] := vl_newIdx;
|
| //}
|
| //else {
|
| // f_EPTF_UIHandler_insertIdx2IdxList(v_UIHandler_guiItemList[vl_newRec.parentIdx].children, pl_indexInParent, vl_newIdx);
|
| // }
|
| }
|
| f_EPTF_UIHandler_setWidgetOriginalDisabled(vl_newIdx); // Set original [xul] disabled state
|
| return vl_newIdx;
|
| } else {
|
| return vl_prevIdx;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_removeWidgetRecByName
|
| // Purpose:
|
| // Removes the specified record about a widget from the list
|
| // of the widgets. See <f_EPTF_UIHandler_removeWidgetRecByIdx>.
|
| //
|
| // Return Value:
|
| // True if succes, false otherwise.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_removeWidgetRecByName(in EPTF_UIHandler_WidgetIdString pl_widgetId)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var integer vl_recIdx := f_EPTF_UIHandler_widgetRecIndex(pl_widgetId);
|
| if(-1 == vl_recIdx){
|
| return false;
|
| }
|
| return f_EPTF_UIHandler_removeWidgetRecByIdx(vl_recIdx);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_removeWidgetRecByIdx
|
| // Purpose:
|
| // Removes the specified record about a widget from the list
|
| // of the widgets.
|
| //
|
| // Return Value:
|
| // True if succes, false otherwise.
|
| //
|
| // Detailed Comments:
|
| // Removes also the children of the widget from the list.
|
| // Removes the index of the widget too from the children's list
|
| // of the parent of the specified widget.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_removeWidgetRecByIdx(in integer pl_recIdx)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| f_EPTF_Base_assert(%definitionId&": Boundary check failed - invalid widget record index",
|
| pl_recIdx >= 0 and pl_recIdx < sizeof(v_UIHandler_guiItemList));
|
| var boolean vl_ret := true;
|
| //Check if there was an open connection
|
| var integer vl_connIdx := f_EPTF_UIHandler_getSubscriptionIdxByWidgetId(v_UIHandler_guiItemList[pl_recIdx].id);
|
| if(-1 != vl_connIdx){
|
| f_EPTF_str2int_HashMap_Erase(v_UIHandler_subscriptionHashMapId, v_UIHandler_openSubscriptions[vl_connIdx].widgetId);
|
| v_UIHandler_openSubscriptions[vl_connIdx].widgetId := "";
|
| }
|
| //parse children
|
| var EPTF_IntegerList vl_children := v_UIHandler_guiItemList[pl_recIdx].children;
|
| for(var integer vl_i := 0; vl_i < sizeof(vl_children); vl_i := vl_i + 1){
|
| if(vl_children[vl_i]> -1){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_removeWidgetRecByIdx(vl_children[vl_i]);
|
| }
|
| }
|
| //remove from the childlist of its parent
|
| if(-1 != v_UIHandler_guiItemList[pl_recIdx].parentIdx){
|
| v_UIHandler_guiItemList[v_UIHandler_guiItemList[pl_recIdx].parentIdx].children :=
|
| f_EPTF_UIHandler_removeIdFromIdList(v_UIHandler_guiItemList[v_UIHandler_guiItemList[pl_recIdx].parentIdx].children,pl_recIdx);
|
| }
|
| // delete widgetId from hashmap
|
| if (v_UIHandler_guiItemList[pl_recIdx].id != "") {
|
| f_EPTF_str2int_HashMap_Erase(v_UIHandler_widgetHashMapId, v_UIHandler_guiItemList[pl_recIdx].id);
|
| }
|
| //clear record
|
| v_UIHandler_guiItemList[pl_recIdx] := c_UIHandler_emptyGUIItem;
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_widgetRecIndex
|
| // Return Value:
|
| // The index of the <EPTF_UIHandler_GuiItemRec> that describes the
|
| // specified widget, or -1.
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_widgetRecIndex(
|
| in EPTF_UIHandler_WidgetIdString pl_id, //The ID of the widget
|
| in Treecell pl_treecell := {omit, omit, omit, omit, omit, omit, omit, omit}
|
| )
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var integer vl_idx := 0;
|
| // check if empty id
|
| if("" == pl_id){
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": widgetRecIndex with empty ID!");
|
| }
|
| return -1;
|
| }
|
| // try to find id in internal database
|
| if (f_EPTF_str2int_HashMap_Find(v_UIHandler_widgetHashMapId, pl_id, vl_idx)) {
|
| return vl_idx;
|
| }
|
|
|
| // // check if id refers a table cell in format "treeId.[row].[col]"
|
| // var integer vl_row, vl_col;
|
| // var EPTF_UIHandler_WidgetIdString vl_treeId;
|
| // if (f_EPTF_UIHandler_isTreeCellIdFormat(pl_id, vl_treeId, vl_row, vl_col)) {
|
| // if (f_EPTF_str2int_HashMap_Find(v_UIHandler_widgetHashMapId, vl_treeId, vl_idx) and
|
| // v_UIHandler_guiItemList[vl_idx].widgetType == wtTree)
|
| // {
|
| // var integer vl_colNum := sizeof(v_UIHandler_guiItemList[vl_idx].widgetData.treeData.columns);
|
| // if (vl_col < vl_colNum) {
|
| // var EPTF_UIHandler_GuiItemRec vl_newRec := {
|
| // pl_id,
|
| // wtTreecell,
|
| // v_UIHandler_guiItemList[v_UIHandler_guiItemList[vl_idx].widgetData.treeData.columns[vl_col]].widgetDataType,
|
| // vl_idx,
|
| // {},
|
| // {cellData := {v_UIHandler_guiItemList[vl_idx].widgetData.treeData.columns[vl_col], omit}},
|
| // { treecell := pl_treecell}};
|
| // var integer vl_newIdx := sizeof(v_UIHandler_guiItemList);
|
| // v_UIHandler_guiItemList[vl_newIdx] := vl_newRec;
|
| // if (vl_newRec.id != "") {
|
| // f_EPTF_str2int_HashMap_Insert(v_UIHandler_widgetHashMapId, vl_newRec.id, vl_newIdx);
|
| // }
|
| // f_EPTF_UIHandler_setWidgetOriginalDisabled(vl_newIdx); // Set original [xul] disabled state
|
| // //Add to its parent's childrenlist
|
| // if(-1 != vl_newRec.parentIdx){
|
| // v_UIHandler_guiItemList[vl_newRec.parentIdx].children[sizeof(v_UIHandler_guiItemList[vl_newRec.parentIdx].children)] := vl_newIdx;
|
| // }
|
| // return vl_newIdx;
|
| // }
|
| // }
|
| // }
|
| return -1;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_isTreeCellIdFormat
|
| //
|
| // Purpose:
|
| // Private function to check whether a widgetId is given in specail table cell format (treeId.[row].[column]),
|
| // and gives back treeId, row, column if possible
|
| // Parameters:
|
| // pl_widgetRec - *out* EPTF_UIHandler_GuiItemRec - The <EPTF_UIHandler_GuiItemRec> that describes the specified widget
|
| // pl_id - *in* EPTF_UIHandler_WidgetIdString - The input widget Id string
|
| // pl_treeId - *out* EPTF_UIHandler_WidgetIdString - The id of the table
|
| // pl_row - *out* integer pl_row - The row number of the cell
|
| // pl_col - *out* integer - The column number of the cell
|
| // Return Value:
|
| // True if widgetId is in special format, false otherwise
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_isTreeCellIdFormat(
|
| in EPTF_UIHandler_WidgetIdString pl_id,
|
| out EPTF_UIHandler_WidgetIdString pl_treeId,
|
| out integer pl_row,
|
| out integer pl_col )
|
| return boolean {
|
| // this function matches pattern "*.[0-9]+.[0-9]+" but without using the unefficient regexp
|
|
|
| // reset out parameters
|
| pl_treeId := "";
|
| pl_row := 0;
|
| pl_col := 0;
|
|
|
| var integer i := lengthof(pl_id)-1, vl_limiterIdx1 := -1, vl_limiterIdx2 := -1;
|
| // check last char is a number
|
| if ( char2int(pl_id[i])<char2int("0") or char2int(pl_id[i])>char2int("9") ) {
|
| return false;
|
| }
|
| // find first '.' from back in Id
|
| for (i := i-1; pl_id[i] != "." and i>=3; i := i-1) {
|
| if (char2int(pl_id[i])<char2int("0") or char2int(pl_id[i])>char2int("9")) {
|
| return false;
|
| }
|
| }
|
| if (i<3) {
|
| return false;
|
| }
|
| vl_limiterIdx1 := i;
|
| // check next char is a number
|
| i := i-1;
|
| if ( char2int(pl_id[i])<char2int("0") or char2int(pl_id[i])>char2int("9") ) {
|
| return false;
|
| }
|
| // find second '.' from back in Id
|
| for (i := i-1; pl_id[i] != "." and i>=1; i := i-1) {
|
| if (char2int(pl_id[i])<char2int("0") or char2int(pl_id[i])>char2int("9")) {
|
| return false;
|
| }
|
| }
|
| if (i<1) {
|
| return false;
|
| }
|
| vl_limiterIdx2 := i;
|
|
|
| // obtain column number
|
| pl_col := str2int(substr(pl_id, vl_limiterIdx1+1, lengthof(pl_id)-vl_limiterIdx1-1));
|
| // obtain row number
|
| pl_row := str2int(substr(pl_id, vl_limiterIdx2 + 1, vl_limiterIdx1 - vl_limiterIdx2 - 1));
|
| // obtain tree id
|
| pl_treeId := substr(pl_id, 0, vl_limiterIdx2);
|
| return true;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getWidgetRec
|
| // Parameters:
|
| // pl_widgetRec - *out* EPTF_UIHandler_GuiItemRec - The <EPTF_UIHandler_GuiItemRec> that describes the specified widget
|
| //
|
| // Return Value:
|
| // True if success, false otherwise.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_getWidgetRec(
|
| in EPTF_UIHandler_WidgetIdString pl_widgetId,
|
| out EPTF_UIHandler_GuiItemRec pl_widgetRec)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var integer vl_idx := f_EPTF_UIHandler_widgetRecIndex(pl_widgetId);
|
| pl_widgetRec := c_UIHandler_emptyGUIItem;
|
| if(-1 < vl_idx){
|
| pl_widgetRec := v_UIHandler_guiItemList[vl_idx];
|
| return true;
|
| }
|
| return false;
|
| }
|
| } //EPTF_WidgetAdministrationFunctions group
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Group: EPTF_WidgetAddInternalFunctions
|
| ///////////////////////////////////////////////////////////
|
| group EPTF_WidgetAddInternalFunctions{
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addElementToTree
|
| //
|
| // Purpose:
|
| // Private function to look through a Tree when adding an column or item or row or cell to it.
|
| //
|
| // Parameters:
|
| // pl_parentWidgetId *integer*
|
| // pl_xul *XTDP_XML_Tag*
|
| // pl_currentTree <Tree>
|
| //
|
| // Return Value:
|
| // *boolean*
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // Returns true if pl_xul has been added to pl_currentTree.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| /*private function f_EPTF_UIHandler_addElementToTree(
|
| in EPTF_UIHandler_WidgetIdString pl_parentWidgetId,
|
| in Widgets pl_xul,
|
| inout ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tree pl_currentTree)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| if(pl_currentTree.id == pl_parentWidgetId) {
|
| // init the one-and-only treeitem (treechildren[0]):
|
| if(sizeof(pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list) == 0) {
|
| pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list := {};
|
| }
|
|
|
| select( true )
|
| {
|
| case (ischosen (pl_xul.treecol)) {
|
| pl_currentTree.treecols.treecolgroups.treecolgroup_list[sizeof(pl_currentTree.treecols.treecolgroups.treecolgroup_list)].treecol := pl_xul.treecol;
|
| return true;
|
| }
|
| case (ischosen (pl_xul.treecols)) {
|
| for(var integer col := 0; col < sizeof(pl_xul.treecols.treecolgroups.treecolgroup_list); col := col + 1) {
|
| if(ischosen(pl_xul.treecols.treecolgroups.treecolgroup_list[col].treecol)){
|
| pl_currentTree.treecols.treecolgroups.treecolgroup_list[sizeof(pl_currentTree.treecols.treecolgroups.treecolgroup_list)].treecol := pl_xul.treecols.treecolgroups.treecolgroup_list[col].treecol;
|
| }else{
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_xul.treecols.treecolgroups.treecolgroup_list[col]));
|
| return false;
|
| }
|
| }
|
| return true;
|
| }
|
| case (ischosen (pl_xul.treerow)) {
|
| pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[sizeof(pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)].treerow := pl_xul.treerow;
|
| return true;
|
| }
|
| case (ischosen (pl_xul.treecell)) {
|
| var integer vl_rowCount := 0;
|
| if(isbound(pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)){
|
| vl_rowCount := sizeof(pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list);
|
| }
|
| var integer vl_cellCount := 0;
|
| if(isbound(pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[vl_rowCount].treerow.treecellgroups.treecellgroup_list)){
|
| vl_cellCount := sizeof(pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[vl_rowCount].treerow.treecellgroups.treecellgroup_list);
|
| }
|
| // add the cell to the last row's cells
|
| pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[vl_rowCount].treerow.treecellgroups.treecellgroup_list[vl_cellCount].treecell := pl_xul.treecell;
|
| return true;
|
| }
|
| case (ischosen (pl_xul.treeitem)) {
|
| // add each row to the one-and-only treeitem (treechildren.treeitemgroup_list[0]):
|
| for(var integer i := 0; i < sizeof(pl_xul.treeitem.treerowgroups.treerowgroup_list); i := i + 1) {
|
| if(ischosen(pl_xul.treeitem.treerowgroups.treerowgroup_list[i].treerow)){
|
| pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[sizeof(pl_currentTree.treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)].treerow := pl_xul.treeitem.treerowgroups.treerowgroup_list[i].treerow;
|
| }else{
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_xul.treeitem.treerowgroups.treerowgroup_list[i]));
|
| return false;
|
| }
|
| }
|
| return true;
|
| }
|
| case else
|
| {
|
|
|
| }
|
| }
|
| }
|
|
|
| return false;
|
| }*/
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addElementToHbox
|
| //
|
| // Purpose:
|
| // Private function to look through a Hbox when adding a widget.
|
| //
|
| // Parameters:
|
| // pl_parentWidgetId *integer*
|
| // pl_xul *XTDP_XML_Tag*
|
| // pl_currentHbox *Tabbox
|
| //
|
| // Return Value:
|
| // *boolean*
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // Returns true if pl_xul has been added to pl_currentHbox or a widget inside.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| /*private function f_EPTF_UIHandler_addElementToHbox(
|
| in EPTF_UIHandler_WidgetIdString pl_parentWidgetId,
|
| in Widgets pl_xul,
|
| inout ttcn_ericsson_se_protocolModules_xtdp_xtdl.Hbox pl_currentHbox)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| if(pl_currentHbox.id == pl_parentWidgetId) {
|
| var integer vl_index := sizeof(pl_currentHbox.embeddedwidgets.embeddedwidget_list);
|
| if (ischosen (pl_xul.tabbox)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].tabbox := pl_xul.tabbox; return true;
|
| } else if (ischosen (pl_xul.tree)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].tree := pl_xul.tree; return true;
|
| } else if (ischosen (pl_xul.hbox)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].hbox := pl_xul.hbox; return true;
|
| } else if (ischosen (pl_xul.label_)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].label_ := pl_xul.label_; return true;
|
| } else if (ischosen (pl_xul.spacer)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].spacer := pl_xul.spacer; return true;
|
| } else if (ischosen (pl_xul.button)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].button := pl_xul.button; return true;
|
| } else if (ischosen (pl_xul.textbox)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].textbox := pl_xul.textbox; return true;
|
| } else if (ischosen (pl_xul.pushbutton)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].pushbutton := pl_xul.pushbutton; return true;
|
| } else if (ischosen (pl_xul.togglebutton)) {
|
| pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_index].togglebutton := pl_xul.togglebutton; return true;
|
| } else { return false; }
|
| } else {
|
| var boolean ok := false;
|
| for(var integer vl_i := 0; vl_i < sizeof(pl_currentHbox.embeddedwidgets.embeddedwidget_list); vl_i := vl_i + 1) {
|
| if(ischosen(pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_i].tabbox)) {
|
| ok := f_EPTF_UIHandler_addElementToTabbox(pl_parentWidgetId, pl_xul, pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_i].tabbox);
|
| } else if(ischosen(pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_i].tree)) {
|
| ok := f_EPTF_UIHandler_addElementToTree(pl_parentWidgetId, pl_xul, pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_i].tree);
|
| } else if(ischosen(pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_i].hbox)) {
|
| ok := f_EPTF_UIHandler_addElementToHbox(pl_parentWidgetId, pl_xul, pl_currentHbox.embeddedwidgets.embeddedwidget_list[vl_i].hbox);
|
| }
|
| if(ok) {
|
| return ok;
|
| }
|
| }
|
| }
|
| return false;
|
| }*/
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromXul
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends all widgetIds
|
| // from request to string list of current runtime GUI widgetIds
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Widgets* - union type of possible gui items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // NOTE: This is the interface function to all list append functions below.
|
| // These functions have been created according to the data structure described in XUL_XSD.asn.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromXul (
|
| inout Widgets pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| select(pl_xul){
|
| //FIXME ischosen?
|
| // iterator in appendAllWidgetIdsFromXul
|
| /*case({iterator := ?}) {
|
| return f_EPTF_UIHandler_Config_processIterator(pl_xul.iterator, pl_widgetsOut, pl_parentIdx, pl_widgetExists);
|
| }*/
|
| case({window := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromWindow(pl_xul.window, pl_widgetExists);
|
| }
|
| case({tabpages := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromTabpages(pl_xul.tabpages, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({tabpage := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromTabpage(pl_xul.tabpage, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({tree := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromTree(pl_xul.tree, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({treecols := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromTreecols(pl_xul.treecols.treecolgroups.treecolgroup_list, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({treecol := ?}) {
|
| return -1 != f_EPTF_UIHandler_appendTreecol(pl_xul.treecol, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({treechildren := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromTreeItemGroups(pl_xul.treechildren.treeitemgroups.treeitemgroup_list, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({treeitem := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromTreeRowGroups(pl_xul.treeitem.treerowgroups.treerowgroup_list, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({treerow := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromTreeCellGroups(pl_xul.treerow.treecellgroups.treecellgroup_list, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({treecell := ?}) {
|
| return f_EPTF_UIHandler_appendCell(pl_xul.treecell, pl_parentIdx, pl_widgetExists, sizeof(v_UIHandler_guiItemList[pl_parentIdx].widgetData.treeData.columns)-1);
|
| }
|
| case({hbox := ?}) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromHbox(pl_xul.hbox, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({label_ := ?}) {
|
| return f_EPTF_UIHandler_appendLabel(pl_xul.label_, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({spacer := ?}) {
|
| return f_EPTF_UIHandler_appendSpacer(pl_xul.spacer, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({button := ?}) {
|
| return f_EPTF_UIHandler_appendButton(pl_xul.button, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({textbox := ?}) {
|
| return f_EPTF_UIHandler_appendTextbox(pl_xul.textbox, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({chart := ?}) {
|
| return f_EPTF_UIHandler_appendChart(pl_xul.chart, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({trace := ?}) {
|
| return f_EPTF_UIHandler_appendTrace(pl_xul.trace, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({toolbar := ?}) {
|
| return f_EPTF_UIHandler_appendToolbar(pl_xul.toolbar, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({toolbarbutton := ?}) {
|
| return f_EPTF_UIHandler_appendToolbarbutton(pl_xul.toolbarbutton, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({toolbarelements := ?}) {
|
| var boolean vl_ret := true;
|
| for(var integer vl_i := 0; vl_i < sizeof(pl_xul.toolbarelements.toolbarelement_list);vl_i := vl_i + 1){
|
| if(ischosen(pl_xul.toolbarelements.toolbarelement_list[vl_i].choice.toolbarbutton)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendToolbarbutton(pl_xul.toolbarelements.toolbarelement_list[vl_i].choice.toolbarbutton, pl_parentIdx, pl_widgetExists);
|
| }else if(ischosen(pl_xul.toolbarelements.toolbarelement_list[vl_i].choice.separator)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendSeparator(pl_xul.toolbarelements.toolbarelement_list[vl_i].choice.separator, pl_parentIdx, pl_widgetExists);
|
| }else{
|
| f_EPTF_UIHandler_warning("Unhandled widgettype as a toolbarelement!");
|
| }
|
| }
|
| return vl_ret;
|
| }
|
| case({tracelist := ?}) {
|
| var boolean vl_ret := true;
|
| for(var integer vl_i := 0; vl_i < sizeof(pl_xul.tracelist.trace_list);vl_i := vl_i + 1){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendTrace(pl_xul.tracelist.trace_list[vl_i], pl_parentIdx, pl_widgetExists);
|
| }
|
| return vl_ret;
|
| }
|
| case({listbox := ?}) {
|
| return f_EPTF_UIHandler_appendListbox(pl_xul.listbox, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({listitem := ?}) {
|
| return f_EPTF_UIHandler_appendListitem(pl_xul.listitem, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({numericalwidget := ?}) {
|
| return f_EPTF_UIHandler_appendNumericalwidget(pl_xul.numericalwidget, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({menulist := ?}) {
|
| return f_EPTF_UIHandler_appendMenulist(pl_xul.menulist, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({menuitem := ?}) {
|
| return f_EPTF_UIHandler_appendMenuitem(pl_xul.menuitem, pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({distributionchart := ?}){
|
| return f_EPTF_UIHandler_appendDistributionchart(pl_xul.distributionchart, pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({valuelist := ?}){
|
| return f_EPTF_UIHandler_appendValuelist(pl_xul.valuelist, pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({image := ?}){
|
| return f_EPTF_UIHandler_appendImage(pl_xul.image, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({pushbutton := ?}) {
|
| return f_EPTF_UIHandler_appendPushbutton(pl_xul.pushbutton, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({togglebutton := ?}) {
|
| return f_EPTF_UIHandler_appendTogglebutton(pl_xul.togglebutton, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({htmlcode := ?}) {
|
| return f_EPTF_UIHandler_appendHtmlcode(pl_xul.htmlcode, pl_parentIdx, pl_widgetExists);
|
| }
|
| case({separator := ?}) {
|
| return f_EPTF_UIHandler_appendSeparator(pl_xul.separator, pl_parentIdx, pl_widgetExists);
|
| }
|
| case else {
|
| f_EPTF_UIHandler_warning("Unhandled widget type in f_EPTF_UIHandler_appendAllWidgetIdsFromXul!");
|
| return false;
|
| }
|
| }
|
| return true;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenFromWindow
|
| //
|
| // Purpose:
|
| // Deletes the childrens from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_window - *in* *Windowtype*
|
| //
|
| // Return Value:
|
| // Windowtype
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromWindow(in Windowtype pl_window)
|
| return Windowtype {
|
| var Windowtype ret := pl_window;
|
| ret.embeddedwidgets.embeddedwidget_list := {};
|
| return ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenFromTree
|
| //
|
| // Purpose:
|
| // Deletes the childrens from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Tree*
|
| //
|
| // Return Value:
|
| // Tree
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromTree(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tree pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tree {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tree ret := pl_xul;
|
| ret.treecols.treecolgroups.treecolgroup_list := {};
|
| ret.treechildren.treeitemgroups.treeitemgroup_list := {};
|
| return ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenFromTabpages
|
| //
|
| // Purpose:
|
| // Deletes the childrens from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Tabpages*
|
| //
|
| // Return Value:
|
| // Tabpages
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromTabpages(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpages pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpages {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpages ret := pl_xul;
|
| ret.tabpagegroups.tabpagegroup_list := {};
|
| return ret;
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenFromHbox
|
| //
|
| // Purpose:
|
| // Deletes the childrens from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Hbox*
|
| //
|
| // Return Value:
|
| // Hbox
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromHbox(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Hbox pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Hbox {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Hbox ret := pl_xul;
|
| ret.embeddedwidgets.embeddedwidget_list := {};
|
| return ret;
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenFromChart
|
| //
|
| // Purpose:
|
| // Deletes the childrens from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Chart*
|
| //
|
| // Return Value:
|
| // Chart
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromChart(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Chart pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Chart {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Chart ret := pl_xul;
|
| ret.tracegroups.tracegroup_list := {};
|
| return ret;
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenFromToolbar
|
| //
|
| // Purpose:
|
| // Deletes the childrens from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Toolbar*
|
| //
|
| // Return Value:
|
| // Toolbar
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromToolbar(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Toolbar pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Toolbar {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Toolbar ret := pl_xul;
|
| ret.choice_list := {};
|
| return ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenFromListbox
|
| //
|
| // Purpose:
|
| // Deletes the childrens from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Listbox*
|
| //
|
| // Return Value:
|
| // Listbox
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromListbox(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Listbox pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Listbox {
|
| pl_xul.externaldata := omit;
|
| pl_xul.listitemgroups.listitemgroup_list := {};
|
| return pl_xul;
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenFromMenulist
|
| //
|
| // Purpose:
|
| // Deletes the childrens from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Menulist*
|
| //
|
| // Return Value:
|
| // Menulist
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromMenulist(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menulist pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menulist {
|
| pl_xul.externaldata := omit;
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menulist ret := pl_xul;
|
| ret.menupopup.choice.menuitemgroups.menuitemgroup_list := {};
|
| return ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_deleteChildrenDistributionchart
|
| //
|
| // Purpose:
|
| // Deletes the children from the widget given in XUL format
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *Distributionchart*
|
| //
|
| // Return Value:
|
| // Distributionchart
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_deleteChildrenFromDistributionchart(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Distributionchart pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Distributionchart {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Distributionchart ret := pl_xul;
|
| ret.externaldatagroups.externaldatagroup_list := {};
|
| return ret;
|
| }
|
|
|
| // The others are just the Identity
|
| private function f_EPTF_UIHandler_deleteChildrenFromMenuitem(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menuitem pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menuitem {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menuitem ret := pl_xul;
|
| return ret;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromNumericalwidget(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Numericalwidget pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Numericalwidget {
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromTreecell(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treecell pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treecell {
|
| //var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treecell ret := pl_xul;
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromListitem(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Listitem pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Listitem {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Listitem ret := pl_xul;
|
| return ret;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromTreerow(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treerow pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treerow {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treerow ret := pl_xul;
|
| return ret;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromTabpage(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpage pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpage {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpage ret := pl_xul;
|
| ret.embeddedwidgets := {{}};
|
| return ret;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromLabel(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Label pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Label {
|
| // if externaldata present then ->
|
| if(ispresent(pl_xul.externaldata)) {
|
| // add customclass to notify the LoadMain.xsl that the content of this label can change (search for "dynamic updatable label" in xsl)
|
| if (ispresent(pl_xul.customclass) and pl_xul.customclass!="") {
|
| pl_xul.customclass := "HasExternalData "&pl_xul.customclass;
|
| } else {
|
| pl_xul.customclass := "HasExternalData";
|
| }
|
| }
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromSpacer(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Spacer pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Spacer {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Spacer ret := pl_xul;
|
| return ret;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromButton(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Button pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Button {
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromTextbox(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Textbox pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Textbox {
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromTrace(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Trace pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Trace {
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromToolbarbutton(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Toolbarbutton pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Toolbarbutton {
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromSeparator(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Separator pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Separator {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Separator ret := pl_xul;
|
| return ret;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromPushbutton(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Pushbutton pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Pushbutton {
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromTogglebutton(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Togglebutton pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Togglebutton {
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
| private function f_EPTF_UIHandler_deleteChildrenFromHtmlcode(in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Htmlcode pl_xul)
|
| return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Htmlcode {
|
| pl_xul.externaldata := omit;
|
| return pl_xul;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_anywidget
|
| //
|
| // Purpose:
|
| // Casting function from XTDP_XML_Tag to AnyWidget
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *XTDP_XML_Tag* - union type of possible gui items
|
| //
|
| // Return Value:
|
| // AnyWidget - an union of some gui items
|
| //
|
| // Errors:
|
| // Unhandled widgettype
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| /* private function f_EPTF_UIHandler_anywidget(in Widgets pl_xul, inout boolean pl_succ)
|
| runs on EPTF_UIHandler_Private_CT
|
| return AnyWidget {
|
| pl_succ := true;
|
| select(pl_xul){
|
| case ({tabbox := ?}) {
|
| return {tabbox := pl_xul.tabbox};
|
| }
|
| case ({tree := ?}) {
|
| return {tree := pl_xul.tree};
|
| }
|
| case ({hbox := ?}) {
|
| return {hbox := pl_xul.hbox};
|
| }
|
| case ({label_ := ?}) {
|
| return {textlabel := pl_xul.label_};
|
| }
|
| case ({spacer := ?}) {
|
| return {spacer := pl_xul.spacer};
|
| }
|
| case ({button := ?}) {
|
| return {button := pl_xul.button};
|
| }
|
| case ({textbox := ?}) {
|
| return {textbox := pl_xul.textbox};
|
| }
|
| case ({chart := ?}) {
|
| return {chart := pl_xul.chart};
|
| }
|
| case ({toolbar := ?}) {
|
| return {toolbar := pl_xul.toolbar};
|
| }
|
| case ({toolbarbutton := ?}) {
|
| return {toolbarbutton := pl_xul.toolbarbutton};
|
| }
|
| case ({listbox := ?}) {
|
| return {listbox := pl_xul.listbox};
|
| }
|
| case ({numericalwidget := ?}) {
|
| return {numericalwidget := pl_xul.numericalwidget};
|
| }
|
| case ({menulist := ?}) {
|
| return {menulist := pl_xul.menulist};
|
| }
|
| case ({distributionchart := ?}) {
|
| return {distributionchart := pl_xul.distributionchart};
|
| }
|
| case ({image := ?}) {
|
| //f_EPTF_UIHandler_debug("f_EPTF_UIHandler_anywidget: image found, skip it");
|
| pl_succ := false;
|
| return {spacer := {0.0,omit}}; // a dummy widget - omit can not be used
|
| }
|
| case else{
|
| f_EPTF_UIHandler_debug("Unhandled widget in f_EPTF_UIHandler_anywidget: " & log2str(pl_xul));
|
| pl_succ := false;
|
| return {spacer := {0.0,omit}}; // a dummy widget - omit can not be used
|
| }
|
| }
|
| // control will never go here, but we need these because of gcc
|
| pl_succ := false;
|
| return {spacer := {0.0,omit}};
|
| }*/
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Widgets
|
| //
|
| // Purpose:
|
| // Casting function from XTDP_XML_Tag to AnyWidget
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *XTDP_XML_Tag* - union type of possible gui items
|
| // pl_returnWidget - *out* *Embeddedwidget* - AnyWidget - an union of some gui items
|
| //
|
| // Errors:
|
| // Unhandled widgettype
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Widgets(in Widgets pl_xul,
|
| inout boolean pl_succ,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Embeddedwidget pl_widgets)
|
| runs on EPTF_UIHandler_Private_CT
|
| // return ttcn_ericsson_se_protocolModules_xtdp_xtdl.Embeddedwidget
|
| {
|
| pl_succ := true;
|
| //FIXME Is not faster the ischosen?
|
| if (ischosen(pl_xul.tabpages)) {
|
| pl_widgets := {tabpages := pl_xul.tabpages};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.tree)) {
|
| pl_widgets := {tree := pl_xul.tree};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.hbox)) {
|
| pl_widgets := {hbox := pl_xul.hbox};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.label_)) {
|
| pl_widgets := {label_ := pl_xul.label_};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.spacer)) {
|
| pl_widgets := {spacer := pl_xul.spacer};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.button)) {
|
| pl_widgets := {button := pl_xul.button};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.textbox)) {
|
| pl_widgets := {textbox := pl_xul.textbox};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.chart)) {
|
| pl_widgets := {chart := pl_xul.chart};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.toolbar)) {
|
| pl_widgets := {toolbar := pl_xul.toolbar};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.listbox)) {
|
| pl_widgets := {listbox := pl_xul.listbox};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.numericalwidget)) {
|
| pl_widgets := {numericalwidget := pl_xul.numericalwidget};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.menulist)) {
|
| pl_widgets := {menulist := pl_xul.menulist};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.distributionchart)) {
|
| pl_widgets := {distributionchart := pl_xul.distributionchart};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.image)) {
|
| //f_EPTF_UIHandler_debug("f_EPTF_UIHandler_anywidget: image found, skip it");
|
| pl_succ := false;
|
| pl_widgets := {spacer := {0.0,omit}}; // a dummy widget - omit can not be used
|
| return;
|
| }
|
| else if (ischosen(pl_xul.pushbutton)) {
|
| pl_widgets := {pushbutton := pl_xul.pushbutton};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.togglebutton)) {
|
| pl_widgets := {togglebutton := pl_xul.togglebutton};
|
| return;
|
| }
|
| else if (ischosen(pl_xul.htmlcode)) {
|
| pl_widgets := {htmlcode := pl_xul.htmlcode};
|
| return;
|
| } else {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Unhandled widget: " & log2str(pl_xul));
|
| }
|
| pl_succ := false;
|
| pl_widgets := {spacer := {0.0,omit}}; // a dummy widget - omit can not be used
|
| return;
|
| }
|
| // control will never go here, but we need these because of gcc
|
| pl_succ := false;
|
| pl_widgets := {spacer := {0.0,omit}};
|
| return;
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_widgetList
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to WidgetList
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| //
|
| // Return Value:
|
| // WidgetList - a list of some gui items
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| /* private function f_EPTF_UIHandler_widgetList(in EPTF_UIHandler_WidgetsList pl_xuls)
|
| runs on EPTF_UIHandler_Private_CT
|
| return WidgetList {
|
| var WidgetList wl:={};
|
| var AnyWidget aw;
|
| var boolean succ := true;
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| aw := f_EPTF_UIHandler_anywidget(pl_xuls[i], succ);
|
| if(succ){
|
| wl[sizeof(wl)] := aw;
|
| }
|
| }
|
| return wl;
|
| }
|
| */
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_embeddedwidgets
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to WidgetList
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| // wl - *out* *ttcn_ericsson_se_protocolModules_xtdp_xtdl.Embeddedwidgets* - a list of some gui items
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_embeddedwidgets(
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Embeddedwidgets wl)
|
| runs on EPTF_UIHandler_Private_CT {
|
|
|
| wl := {{}};
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Embeddedwidget aw;
|
| var boolean succ := true;
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].metaiterator)) {
|
| var integer vl_metaIteratorIdx := f_EPTF_UIHandler_widgetRecIndex(f_EPTF_UIHandler_unichar2charstring(pl_xuls[i].metaiterator.id));
|
| var EPTF_UIHandler_WidgetsList v_xuls_metaIteratorChildren;
|
| f_EPTF_UIHandler_buildchildrenXULs(vl_metaIteratorIdx, v_xuls_metaIteratorChildren);
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Embeddedwidgets vl_embedded;
|
| f_EPTF_UIHandler_embeddedwidgets(v_xuls_metaIteratorChildren,vl_embedded);
|
| wl.embeddedwidget_list := wl.embeddedwidget_list & vl_embedded.embeddedwidget_list;
|
| } else {
|
|
|
| f_EPTF_UIHandler_Widgets(pl_xuls[i], succ, aw);
|
| if(succ){
|
| wl.embeddedwidget_list[sizeof(wl.embeddedwidget_list)] := aw;
|
| }
|
| }
|
| }
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_tabpagegroups
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to WidgetList
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| // wl - *out* *ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpagegroups* - a list of some gui items
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_tabpagegroups(
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpagegroups wl)
|
| runs on EPTF_UIHandler_Private_CT {
|
|
|
| wl := {{}};
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpagegroups aw;
|
| var boolean succ := true;
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
|
|
| if (ischosen(pl_xuls[i].metaiterator)) {
|
| var integer vl_metaIteratorIdx := f_EPTF_UIHandler_widgetRecIndex(f_EPTF_UIHandler_unichar2charstring(pl_xuls[i].metaiterator.id));
|
| var EPTF_UIHandler_WidgetsList v_xuls_metaIteratorChildren;
|
| f_EPTF_UIHandler_buildchildrenXULs(vl_metaIteratorIdx, v_xuls_metaIteratorChildren);
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tabpagegroups vl_embedded;
|
| f_EPTF_UIHandler_tabpagegroups(v_xuls_metaIteratorChildren,vl_embedded);
|
| wl.tabpagegroup_list := wl.tabpagegroup_list & vl_embedded.tabpagegroup_list;
|
|
|
|
|
| } else if (ischosen(pl_xuls[i].tabpage)) {
|
|
|
| wl.tabpagegroup_list[sizeof(wl.tabpagegroup_list)].tabpage := pl_xuls[i].tabpage;
|
|
|
| } else {
|
| //FIXME extra check
|
| //f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_xuls[i]));
|
| }
|
| }
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_TraceList
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to TraceList
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| // pl_tracelist - *out* *TraceList*
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_TraceList(
|
| in integer pl_index,
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tracegroups pl_wl)
|
| runs on EPTF_UIHandler_Private_CT{
|
|
|
| pl_wl := {{}};
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tracelist vl_tracelist:={ /*trace_list :=*/ {} };
|
|
|
| var EPTF_IntegerList vl_nonMetaChildrens := f_EPTF_UIHandler_getNonMetaChildren(pl_index);
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].trace)){
|
| var integer vl_i := sizeof(vl_tracelist.trace_list);
|
| vl_tracelist.trace_list[vl_i] := pl_xuls[i].trace;
|
| pl_wl.tracegroup_list[vl_i].trace := vl_tracelist.trace_list[vl_i];
|
| var integer vl_tracePointer;
|
| if (not f_EPTF_int2int_HashMap_Find(v_UIHandler_tracePointerHashMapId, vl_nonMetaChildrens[i], vl_tracePointer)){
|
| continue;
|
| }
|
| if ( sizeof(pl_xuls[i].trace.choice_list) < pl_xuls[i].trace.maxPoints) {
|
| continue;
|
| }
|
| var integer vl_currTraceID := v_UIHandler_tracePointers[vl_tracePointer];
|
| for (var integer j:=0; j<sizeof(pl_xuls[i].trace.choice_list); j:=j+1) {
|
| vl_tracelist.trace_list[vl_i].choice_list[j] := pl_xuls[i].trace.choice_list[vl_currTraceID];
|
| vl_currTraceID := vl_currTraceID + 1;
|
| if (vl_currTraceID==sizeof(pl_xuls[i].trace.choice_list)) {
|
| vl_currTraceID := 0;
|
| }
|
|
|
| }
|
| //update it
|
| pl_wl.tracegroup_list[vl_i].trace := vl_tracelist.trace_list[vl_i];
|
|
|
| } else if (ischosen(pl_xuls[i].metaiterator)) {
|
| var integer vl_metaIteratorIdx := f_EPTF_UIHandler_widgetRecIndex(f_EPTF_UIHandler_unichar2charstring(pl_xuls[i].metaiterator.id));
|
| var EPTF_UIHandler_WidgetsList v_xuls_metaIteratorChildren;
|
| f_EPTF_UIHandler_buildchildrenXULs(vl_metaIteratorIdx, v_xuls_metaIteratorChildren);
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Tracegroups vl_embedded;
|
| f_EPTF_UIHandler_TraceList(pl_index,v_xuls_metaIteratorChildren,vl_embedded);
|
|
|
| // Insert into both list (pl_wl.tracegroup_list and vl_tracelist.trace_list)
|
| for(var integer vl_idx:=0; vl_idx<sizeof(vl_embedded.tracegroup_list);vl_idx:=vl_idx+1) {
|
| var integer vl_i := sizeof(vl_tracelist.trace_list);
|
| vl_tracelist.trace_list[vl_i] := vl_embedded.tracegroup_list[vl_idx].trace;
|
| pl_wl.tracegroup_list[vl_i].trace := vl_tracelist.trace_list[vl_i]
|
| }
|
|
|
| }else{
|
| //FIXME extra check
|
| //f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_xuls[i]));
|
| }
|
| }
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Toolbarelements
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to Toolbarelements
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| // pl_toolbe - *out* *Toolbarelements*
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Toolbarelements(
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Toolbarelements pl_toolbe)
|
| runs on EPTF_UIHandler_Private_CT{
|
|
|
| pl_toolbe:={
|
| /*toolbarelement_list :=*/ {}
|
| };
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].toolbarbutton)){
|
| pl_toolbe.toolbarelement_list[sizeof(pl_toolbe.toolbarelement_list)].choice.toolbarbutton := pl_xuls[i].toolbarbutton;
|
| } else if (ischosen(pl_xuls[i].pushbutton)){
|
| pl_toolbe.toolbarelement_list[sizeof(pl_toolbe.toolbarelement_list)].choice.pushbutton := pl_xuls[i].pushbutton;
|
| } else if (ischosen(pl_xuls[i].togglebutton)){
|
| pl_toolbe.toolbarelement_list[sizeof(pl_toolbe.toolbarelement_list)].choice.togglebutton := pl_xuls[i].togglebutton;
|
| } else if (ischosen(pl_xuls[i].separator)){
|
| pl_toolbe.toolbarelement_list[sizeof(pl_toolbe.toolbarelement_list)].choice.separator := pl_xuls[i].separator;
|
| }
|
| }
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Treecols
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to Treecols
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| //
|
| // Return Value:
|
| // Treecols
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Treecols(
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treecols pl_cols)
|
| runs on EPTF_UIHandler_Private_CT{
|
| pl_cols:={
|
| /*treecolgroup_list :=*/ {{}}
|
| };
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].treecol)){
|
| pl_cols.treecolgroups.treecolgroup_list[sizeof(pl_cols.treecolgroups.treecolgroup_list)].treecol := pl_xuls[i].treecol;
|
| } else if (ischosen(pl_xuls[i].metaiterator)) {
|
| var integer vl_metaIteratorIdx := f_EPTF_UIHandler_widgetRecIndex(f_EPTF_UIHandler_unichar2charstring(pl_xuls[i].metaiterator.id));
|
| var EPTF_UIHandler_WidgetsList v_xuls_metaIteratorChildren;
|
| f_EPTF_UIHandler_buildchildrenXULs(vl_metaIteratorIdx, v_xuls_metaIteratorChildren);
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treecols vl_embedded;
|
| f_EPTF_UIHandler_Treecols(v_xuls_metaIteratorChildren,vl_embedded);
|
| pl_cols.treecolgroups.treecolgroup_list := pl_cols.treecolgroups.treecolgroup_list & vl_embedded.treecolgroups.treecolgroup_list;
|
|
|
|
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getTreeIdx
|
| //
|
| // Purpose:
|
| // Gives back the current tree's id from e.g. a treerowid
|
| //
|
| // Parameters:
|
| // pl_childIdx - *in* *integer* - widgetid, whose tree parent is to be found
|
| //
|
| // Return Value:
|
| // Tree widget id.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_getTreeIdx(in integer pl_childIdx)
|
| runs on EPTF_UIHandler_Private_CT return integer {
|
| var integer vl_nonMetaParentIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(pl_childIdx);
|
| if(v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetType != wtTree){
|
| return f_EPTF_UIHandler_getTreeIdx(v_UIHandler_guiItemList[vl_nonMetaParentIdx].parentIdx );
|
| // vl_data := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData;
|
| }
|
| return vl_nonMetaParentIdx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_treechildren
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to Treechildren
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| //
|
| // Return Value:
|
| // Treechildren
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_treechildren(
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| in integer pl_cols,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treechildren pl_children,
|
| in integer pl_parentWidgetIdx,
|
| inout integer pl_row)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| var integer vl_nonMetaParentIdx := f_EPTF_UIHandler_getTreeIdx(pl_parentWidgetIdx);
|
| var integer vl_columns := sizeof(v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.columns);
|
|
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list:={};
|
| var integer vl_cellCounter := 0;
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].treecell)) {
|
| var integer vl_row := 0;
|
| if (vl_columns != 0) {
|
| vl_row := vl_cellCounter / vl_columns;
|
| }
|
| var integer vl_cellIdxInRow := vl_cellCounter-vl_row*vl_columns;
|
| //sizeof(pl_children.treeitemgroups.treeitemgroup_list[sizeof(pl_children.treeitemgroups.treeitemgroup_list)].treeitem.treerowgroups.treerowgroup_list[vl_row].treerow.treecellgroups.treecellgroup_list);
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[vl_row].treerow.treecellgroups.treecellgroup_list[vl_cellIdxInRow].treecell := pl_xuls[i].treecell;
|
| vl_cellCounter := vl_cellCounter + 1;
|
| } else if(ischosen(pl_xuls[i].treechildren)) {
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list :=
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list & pl_xuls[i].treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list;
|
| pl_row := pl_row + sizeof(pl_xuls[i].treechildren.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)
|
| } else if (ischosen(pl_xuls[i].metaiterator)) {
|
| var integer vl_metaIteratorIdx := f_EPTF_UIHandler_widgetRecIndex(f_EPTF_UIHandler_unichar2charstring(pl_xuls[i].metaiterator.id));
|
| var EPTF_UIHandler_WidgetsList v_xuls_metaIteratorChildren;
|
| f_EPTF_UIHandler_buildchildrenXULs(vl_metaIteratorIdx, v_xuls_metaIteratorChildren);
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treechildren vl_embedded;
|
| f_EPTF_UIHandler_treechildren(v_xuls_metaIteratorChildren, pl_cols,vl_embedded,pl_parentWidgetIdx, pl_row);
|
|
|
| if (v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.iteratorUnionType == treecelliterator) {
|
| if (sizeof(vl_embedded.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)>0) {
|
| var integer vl_row := sizeof(pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)-1;
|
| if (vl_row<0) {
|
| vl_row := 0;
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[vl_row] := {treerow:={{{}}}}
|
| }
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[vl_row].treerow.treecellgroups.treecellgroup_list :=
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[vl_row].treerow.treecellgroups.treecellgroup_list
|
| & vl_embedded.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[0].treerow.treecellgroups.treecellgroup_list;
|
| }
|
| } else {
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list :=
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list
|
| & vl_embedded.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list;
|
| }
|
|
|
| var integer vl_nofNewCells := 0;
|
| if (sizeof(vl_embedded.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)>0) {
|
| vl_nofNewCells := sizeof(vl_embedded.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[0].treerow.treecellgroups.treecellgroup_list);
|
| }
|
| vl_cellCounter := vl_cellCounter + vl_nofNewCells;
|
| } else if (ischosen(pl_xuls[i].treerow)) {
|
| var integer vl_treeIdx := -1;
|
| var integer vl_parentIdx := pl_parentWidgetIdx;
|
|
|
| while(vl_treeIdx == -1 and vl_parentIdx != -1){
|
| if(v_UIHandler_guiItemList[vl_parentIdx].widgetType == wtTree){
|
| vl_treeIdx := vl_parentIdx;
|
| } else {
|
| vl_parentIdx := v_UIHandler_guiItemList[vl_parentIdx].parentIdx;
|
| }
|
| }
|
| var integer vl_treerowIdx := -1;
|
| if(vl_treeIdx == -1){
|
| f_EPTF_UIHandler_warning(%definitionId&": The tree of the treerow has not been found! " & log2str(pl_xuls[i]) );
|
| break;
|
| } else {
|
| var integer vl_dummy := -1;
|
| vl_treerowIdx := f_EPTF_UIHandler_TreeRowIdxInATree(pl_row, vl_treeIdx, vl_dummy );
|
| if(vl_treerowIdx == -1){
|
| f_EPTF_UIHandler_warning(%definitionId&": The treerow has not been found in the database for the tree: " & log2str(v_UIHandler_guiItemList[vl_treeIdx].id) );
|
| break;
|
| }
|
| }
|
| var EPTF_UIHandler_WidgetsList v_xuls_treerowChildren := {};
|
| pl_row := pl_row + 1;
|
| if(sizeof(v_UIHandler_guiItemList[vl_treerowIdx].children) > 0){
|
| for(var integer vl_treerowchildrenIdx := 0; vl_treerowchildrenIdx < sizeof(v_UIHandler_guiItemList[vl_treerowIdx].children); vl_treerowchildrenIdx := vl_treerowchildrenIdx + 1){
|
| if(v_UIHandler_guiItemList[v_UIHandler_guiItemList[vl_treerowIdx].children[vl_treerowchildrenIdx]].widgetType == wtTreecell){
|
| vl_cellCounter := vl_cellCounter + 1;
|
| v_xuls_treerowChildren := v_xuls_treerowChildren & { v_UIHandler_guiItemList[v_UIHandler_guiItemList[vl_treerowIdx].children[vl_treerowchildrenIdx]].XULformat };
|
| } else {
|
| var EPTF_UIHandler_WidgetsList v_xuls_treerowChildrenPlus := {};
|
| f_EPTF_UIHandler_buildchildrenXULs(v_UIHandler_guiItemList[vl_treerowIdx].children[vl_treerowchildrenIdx], v_xuls_treerowChildrenPlus);
|
|
|
| for(var integer vl_l := 0; vl_l < sizeof(v_xuls_treerowChildrenPlus); vl_l := vl_l + 1){
|
| v_xuls_treerowChildren[sizeof(v_xuls_treerowChildren)] := v_xuls_treerowChildrenPlus[vl_l];
|
| }
|
| }
|
|
|
| }
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Treechildren vl_embedded;
|
| f_EPTF_UIHandler_treechildren(v_xuls_treerowChildren, pl_cols,vl_embedded,vl_treerowIdx, pl_row);
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list :=
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list
|
| & vl_embedded.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list;
|
|
|
| var integer vl_nofNewCells := 0;
|
| if (sizeof(vl_embedded.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)>0) {
|
| vl_nofNewCells := sizeof(vl_embedded.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[0].treerow.treecellgroups.treecellgroup_list);
|
| }
|
| vl_cellCounter := vl_cellCounter + vl_nofNewCells;
|
| } else {
|
| //empty row
|
| pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list[sizeof(pl_children.treeitemgroups.treeitemgroup_list[0].treeitem.treerowgroups.treerowgroup_list)].treerow
|
| := pl_xuls[i].treerow;
|
| }
|
| } else if (ischosen(pl_xuls[i].treecol)) {
|
| //Nothing to do
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Not handled widgettype! " & log2str(pl_xuls[i]) );
|
| }
|
| }
|
| return;
|
| }
|
|
|
| private function f_EPTF_UIHandler_TreeRowIdxInATree(
|
| in integer pl_rowToFind,
|
| in integer pl_parentIdx,
|
| inout integer pl_countTreeRow
|
| )
|
| runs on EPTF_UIHandler_Private_CT return integer{
|
| var integer vl_treerowIdx := -1;
|
|
|
| for(var integer vl_i := 0; vl_i < sizeof(v_UIHandler_guiItemList[pl_parentIdx].children); vl_i := vl_i + 1){
|
| if(v_UIHandler_guiItemList[v_UIHandler_guiItemList[pl_parentIdx].children[vl_i]].widgetType == wtTreerow){
|
| pl_countTreeRow := pl_countTreeRow + 1;
|
| } else {
|
| vl_treerowIdx := f_EPTF_UIHandler_TreeRowIdxInATree(pl_rowToFind, v_UIHandler_guiItemList[pl_parentIdx].children[vl_i], pl_countTreeRow);
|
| }
|
| if(pl_countTreeRow >= pl_rowToFind){
|
| if(vl_treerowIdx == -1){
|
| vl_treerowIdx := v_UIHandler_guiItemList[pl_parentIdx].children[vl_i];
|
| }
|
| break;
|
| }
|
| }
|
|
|
| return vl_treerowIdx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Listitems
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to Listitems
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| // pl_tcs - *out* *Listbox.listitemgroups.listitemgroup_list* - Listitems
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Listitems(
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Listitemgroups pl_wl)
|
| runs on EPTF_UIHandler_Private_CT {
|
|
|
| pl_wl:={{}};
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].listitem)){
|
| pl_wl.listitemgroup_list[sizeof(pl_wl.listitemgroup_list)].listitem := pl_xuls[i].listitem;
|
| } else if (ischosen(pl_xuls[i].metaiterator)) {
|
| var integer vl_metaIteratorIdx := f_EPTF_UIHandler_widgetRecIndex(f_EPTF_UIHandler_unichar2charstring(pl_xuls[i].metaiterator.id));
|
| var EPTF_UIHandler_WidgetsList v_xuls_metaIteratorChildren;
|
| f_EPTF_UIHandler_buildchildrenXULs(vl_metaIteratorIdx, v_xuls_metaIteratorChildren);
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Listitemgroups vl_embedded;
|
| f_EPTF_UIHandler_Listitems(v_xuls_metaIteratorChildren,vl_embedded);
|
| pl_wl.listitemgroup_list := pl_wl.listitemgroup_list & vl_embedded.listitemgroup_list;
|
|
|
|
|
| }
|
| }
|
|
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Menuitems
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to Menuitems
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| // pl_tcs - *out* *ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menupopup* - Menuitems
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Menupopup(
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menupopup pl_tcs)
|
| runs on EPTF_UIHandler_Private_CT {
|
|
|
| pl_tcs:={
|
| ///*iteratordata :=*/ omit,
|
| /*menuitem_list :=*/ choice := {menuitemgroups:= {{}}}
|
| };
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].menuitem)){
|
| pl_tcs.choice.menuitemgroups.menuitemgroup_list[sizeof(pl_tcs.choice.menuitemgroups.menuitemgroup_list)].menuitem := pl_xuls[i].menuitem;
|
| } else if (ischosen(pl_xuls[i].metaiterator)) {
|
| var integer vl_metaIteratorIdx := f_EPTF_UIHandler_widgetRecIndex(f_EPTF_UIHandler_unichar2charstring(pl_xuls[i].metaiterator.id));
|
| var EPTF_UIHandler_WidgetsList v_xuls_metaIteratorChildren;
|
| f_EPTF_UIHandler_buildchildrenXULs(vl_metaIteratorIdx, v_xuls_metaIteratorChildren);
|
|
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Menupopup vl_embedded;
|
| f_EPTF_UIHandler_Menupopup(v_xuls_metaIteratorChildren,vl_embedded);
|
| pl_tcs.choice.menuitemgroups.menuitemgroup_list := pl_tcs.choice.menuitemgroups.menuitemgroup_list & vl_embedded.choice.menuitemgroups.menuitemgroup_list;
|
|
|
|
|
| }
|
| }
|
|
|
| }
|
|
|
| type record of Valuelist Value_list_list;
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Valuelists
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to ValueLists
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| // pl_tcs - *out* *Distributionchart.valuelist_list* - DistributionchartValuelists
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Valuelists(
|
| in EPTF_UIHandler_WidgetsList pl_xuls,
|
| out Value_list_list pl_tcs)
|
| runs on EPTF_UIHandler_Private_CT {
|
|
|
| pl_tcs:={};
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].valuelist)){
|
| pl_tcs[sizeof(pl_tcs)] := pl_xuls[i].valuelist;
|
| }
|
| }
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Intervallimits
|
| //
|
| // Purpose:
|
| // Creates an Intervallimits structure from a stored intervallimits GUI item
|
| //
|
| // Parameters:
|
| // pl_index - *in* *integer* - index of intervallimits in the GUI item list
|
| // pl_limits - *out* *Intervallimits* - Intervallimitslist
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Intervallimits(
|
| in integer pl_index,
|
| out ttcn_ericsson_se_protocolModules_xtdp_xtdl.Intervallimits pl_limits)
|
| runs on EPTF_UIHandler_Private_CT {
|
|
|
| f_EPTF_Base_assert(%definitionId & ": Invalid index: " & int2str(pl_index), pl_index > -1 and pl_index < sizeof(v_UIHandler_guiItemList));
|
| f_EPTF_Base_assert(%definitionId & ": Invalid widget type: ", v_UIHandler_guiItemList[pl_index].widgetType == wtIntervallimits);
|
|
|
|
|
| pl_limits:={
|
| //omit,
|
| v_UIHandler_guiItemList[pl_index].id,
|
| { value_list := {} }
|
| };
|
| for (var integer i:=0; i<sizeof(v_UIHandler_guiItemList[pl_index].widgetData.distChartData.intervallimits); i:=i+1) {
|
| pl_limits.choice.value_list[i] := v_UIHandler_guiItemList[pl_index].widgetData.distChartData.intervallimits[i];
|
| }
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Distributionchart
|
| //
|
| // Purpose:
|
| // Creates an Intervallimits structure from a stored intervallimits GUI item
|
| //
|
| // Parameters:
|
| // pl_index - *in* *integer* - index of intervallimits in the GUI item list
|
| // pl_limits - *out* *Intervallimits* - Intervallimitslist
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Distributionchart(
|
| in integer pl_index,
|
| inout ttcn_ericsson_se_protocolModules_xtdp_xtdl.Distributionchart pl_distributionchart)
|
| runs on EPTF_UIHandler_Private_CT {
|
| f_EPTF_Base_assert(%definitionId & ": Invalid index: " & int2str(pl_index), pl_index > -1 and pl_index < sizeof(v_UIHandler_guiItemList));
|
| //f_EPTF_Base_assert(%definitionId & ": Invalid widget type: ", v_UIHandler_guiItemList[pl_index].widgetType == wtDistributionchart);
|
|
|
| var Widgets vl_xul;
|
|
|
| if (sizeof(pl_distributionchart.externaldatagroups.externaldatagroup_list)==0) {
|
| pl_distributionchart.externaldatagroups.externaldatagroup_list[0].intervallimits := {"",{value_list:= {} }};
|
| pl_distributionchart.externaldatagroups.externaldatagroup_list[1].valuelist_list := {};
|
| }
|
|
|
| var integer vl_size := sizeof(v_UIHandler_guiItemList[pl_index].children);
|
|
|
| for(var integer i := 0; i<vl_size; i := i + 1){
|
| select(v_UIHandler_guiItemList[v_UIHandler_guiItemList[pl_index].children[i]].widgetType){
|
| case(wtIntervallimits){
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Intervallimits vl_intervallimits_new;
|
| f_EPTF_UIHandler_Intervallimits(v_UIHandler_guiItemList[pl_index].children[i], vl_intervallimits_new);
|
| pl_distributionchart.externaldatagroups.externaldatagroup_list[0].intervallimits.id := vl_intervallimits_new.id;
|
| pl_distributionchart.externaldatagroups.externaldatagroup_list[0].intervallimits.choice.value_list := pl_distributionchart.externaldatagroups.externaldatagroup_list[0].intervallimits.choice.value_list & vl_intervallimits_new.choice.value_list;
|
| }
|
| case(wtValuelist){
|
| vl_xul := v_UIHandler_guiItemList[v_UIHandler_guiItemList[pl_index].children[i]].XULformat;
|
| vl_xul.valuelist.externaldata := omit;
|
| pl_distributionchart.externaldatagroups.externaldatagroup_list[1].valuelist_list[sizeof(pl_distributionchart.externaldatagroups.externaldatagroup_list[1].valuelist_list)] := vl_xul.valuelist;
|
|
|
| }
|
| case(wtMetaIterator) {
|
| f_EPTF_UIHandler_Distributionchart(v_UIHandler_guiItemList[pl_index].children[i],pl_distributionchart);
|
| }
|
| case else {
|
| f_EPTF_Base_assert(%definitionId & ": Invalid widget type: " & log2str(v_UIHandler_guiItemList[v_UIHandler_guiItemList[pl_index].children[i]].widgetType), false);
|
| }
|
| }
|
| }
|
| }
|
|
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_ImageList
|
| //
|
| // Purpose:
|
| // Casting function from EPTF_UIHandler_XTDP_XML_TagList to ImageList
|
| //
|
| // Parameters:
|
| // pl_xul - *in* *EPTF_UIHandler_XTDP_XML_TagList* - union type of possible gui items
|
| //
|
| // Return Value:
|
| // DistributionchartValuelists
|
| ///////////////////////////////////////////////////////////
|
| /* private function f_EPTF_UIHandler_ImageList(in EPTF_UIHandler_XTDP_XML_TagList pl_xuls) runs on EPTF_UIHandler_Private_CT
|
| return ImageList {
|
| var ImageList tcs:={};
|
| for (var integer i:=0;i<sizeof(pl_xuls);i:=i+1){
|
| if (ischosen(pl_xuls[i].xtdp_image)){
|
| tcs[sizeof(tcs)] := pl_xuls[i].xtdp_image;
|
| }
|
| }
|
| return tcs;
|
| }*/
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_buildchildrenXUL
|
| //
|
| // Purpose:
|
| // Builds a tree, that is supposed to be the given widget's children.
|
| //
|
| // Parameters:
|
| // pl_index - *in* <integer> - index in GuiRecItem
|
| // pl_xul - *out* <Widgets> - XTDP_XML_Tag
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_buildchildrenXUL(
|
| in integer pl_index,
|
| out Widgets pl_xul,
|
| in boolean pl_processMetaIterator := false)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| //action("***f_EPTF_UIHandler_buildchildrenXUL: v_UIHandler_guiItemList[",pl_index,"]", v_UIHandler_guiItemList[pl_index]);
|
| // SJZ 2012.11.20 Kill all externaldata from the outgoing xul (if new parameter tells so),
|
| //CR_TR00019705 as the XULformat contains externaldatas and gui does not want to get it,
|
|
|
| // make a children recursively: produce the children and with typeselection, place it childrens
|
| pl_xul := {separator := { id := "This in an unknown widget!" } };
|
| var EPTF_UIHandler_WidgetsList v_xuls := {};
|
| if (not ispresent(v_UIHandler_guiItemList[pl_index].XULformat)) {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": XUL format ommitted, ignoring this subtree!");
|
| }
|
| } else {
|
| pl_xul := v_UIHandler_guiItemList[pl_index].XULformat;
|
| f_EPTF_UIHandler_buildchildrenXULs(pl_index, v_xuls, pl_processMetaIterator);
|
| }
|
|
|
| select(v_UIHandler_guiItemList[pl_index].widgetType){
|
| case(wtWindow){
|
| f_EPTF_UIHandler_warning(%definitionId&": Too many windows present in database!");
|
| }
|
| case (wtTabpages){
|
| f_EPTF_UIHandler_tabpagegroups(v_xuls,pl_xul.tabpages.tabpagegroups);
|
| }
|
| case (wtTabpage) {
|
| f_EPTF_UIHandler_embeddedwidgets(v_xuls, pl_xul.tabpage.embeddedwidgets);
|
| }
|
| case (wtHbox){
|
| f_EPTF_UIHandler_embeddedwidgets(v_xuls, pl_xul.hbox.embeddedwidgets);
|
| }
|
| case (wtChart){
|
| f_EPTF_UIHandler_TraceList(pl_index, v_xuls, pl_xul.chart.tracegroups);
|
| }
|
| case (wtToolbar) {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdl.Toolbarelements toolbarElements;
|
| f_EPTF_UIHandler_Toolbarelements(v_xuls, toolbarElements);
|
| // v_xul.toolbar.toolbarelements :=
|
| for (var integer i := 0; i < sizeof(toolbarElements.toolbarelement_list); i := i + 1) {
|
| if (ischosen(toolbarElements.toolbarelement_list[i].choice.toolbarbutton)) {
|
| pl_xul.toolbar.choice_list[i].toolbarbutton := toolbarElements.toolbarelement_list[i].choice.toolbarbutton;
|
| } else if (ischosen(toolbarElements.toolbarelement_list[i].choice.pushbutton)) {
|
| pl_xul.toolbar.choice_list[i].pushbutton := toolbarElements.toolbarelement_list[i].choice.pushbutton;
|
| } else if (ischosen(toolbarElements.toolbarelement_list[i].choice.togglebutton)) {
|
| pl_xul.toolbar.choice_list[i].togglebutton := toolbarElements.toolbarelement_list[i].choice.togglebutton;
|
| }else {
|
| pl_xul.toolbar.choice_list[i].separator := toolbarElements.toolbarelement_list[i].choice.separator;
|
| }
|
| }
|
| }
|
| case (wtTree){
|
| f_EPTF_UIHandler_Treecols(v_xuls, pl_xul.tree.treecols);
|
| var integer vl_dummy := 0;
|
| f_EPTF_UIHandler_treechildren(v_xuls, sizeof(pl_xul.tree.treecols.treecolgroups.treecolgroup_list),pl_xul.tree.treechildren, pl_index, vl_dummy);
|
| }
|
| case (wtListbox){
|
| f_EPTF_UIHandler_Listitems(v_xuls, pl_xul.listbox.listitemgroups);
|
| }
|
| case (wtMenulist){
|
| f_EPTF_UIHandler_Menupopup(v_xuls, pl_xul.menulist.menupopup);
|
| }
|
| case (wtDistributionchart){
|
| f_EPTF_UIHandler_Distributionchart(pl_index, pl_xul.distributionchart);
|
| }
|
| case (wtMetaIterator) {
|
| // if metaiterator is kept, it will be replaced inside f_EPTF_UIHandler_treechildren, f_EPTF_UIHandler_Listitems etc under the other cases
|
| }
|
| case else{
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": This widget has no children: "&log2str(v_UIHandler_guiItemList[pl_index]));
|
| }
|
| }
|
| }
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_buildchildrenXULs
|
| //
|
| // Purpose:
|
| // Builds a list of the given widget's childrens
|
| //
|
| // Parameters:
|
| // pl_index - *in* <integer> - index in GuiRecItem
|
| // pl_xuls - *out* <EPTF_UIHandler_WidgetsList>
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_buildchildrenXULs(
|
| in integer pl_index,
|
| out EPTF_UIHandler_WidgetsList pl_xuls,
|
| in boolean pl_processMetaIterator := false)
|
| runs on EPTF_UIHandler_Private_CT {
|
|
|
| pl_xuls := {};
|
|
|
| if(pl_processMetaIterator) {
|
| var EPTF_IntegerList vl_nonMetaChildren := f_EPTF_UIHandler_getNonMetaChildren(pl_index);
|
| for (var integer i:=0;i<sizeof(vl_nonMetaChildren);i:=i+1){
|
| f_EPTF_UIHandler_buildchildrenXUL(vl_nonMetaChildren[i], pl_xuls[i], true);
|
| }
|
| }
|
| else {
|
| for (var integer i:=0;i<sizeof(v_UIHandler_guiItemList[pl_index].children);i:=i+1){
|
| f_EPTF_UIHandler_buildchildrenXUL(v_UIHandler_guiItemList[pl_index].children[i], pl_xuls[i]);
|
| }
|
| }
|
|
|
| //action("***DONE processing children of v_UIHandler_guiItemList[",pl_index,"]: ", v_UIHandler_guiItemList[pl_index]);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_buildXUL
|
| //
|
| // Purpose:
|
| // Builds the whole XUL tree, that describes the layout of the GUI.
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_buildXUL(
|
| out Widgets pl_xul,
|
| in boolean pl_imageNeeded := true)
|
| runs on EPTF_UIHandler_Private_CT {
|
| // ONLY ONE WINDOW SUPPORTED, THAT CONAINS ALL THE WIDGETS.
|
| if (0 == sizeof(v_UIHandler_guiItemList))
|
| {
|
| f_EPTF_UIHandler_error("No window in GuiItemList!");
|
| }
|
| pl_xul := v_UIHandler_guiItemList[v_UIHandler_windowIndex].XULformat;
|
| var EPTF_UIHandler_WidgetsList xuls;
|
| f_EPTF_UIHandler_buildchildrenXULs(v_UIHandler_windowIndex, xuls);
|
| f_EPTF_UIHandler_embeddedwidgets(xuls, pl_xul.window.embeddedwidgets);
|
| if(pl_imageNeeded){
|
| for ( var integer i := 0; i < sizeof(xuls) ; i := i+1 )
|
| {
|
| if (ischosen(xuls[i].image)) {
|
| var boolean vl_idx := false;
|
| for ( var integer j := 0; j < sizeof(pl_xul.window.image_list) ; j := j+1 )
|
| {
|
| if(pl_xul.window.image_list[j].id == xuls[i].image.id){vl_idx := true;}
|
| }
|
| if(not vl_idx){
|
| pl_xul.window.image_list[sizeof(pl_xul.window.image_list)] := xuls[i].image;
|
| }
|
| }
|
| }
|
| } else {
|
| pl_xul.window.image_list := {}
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromWindow
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_window - *inout* *Windowtype* - possible window items (tabbox, hbox)
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromWindow(
|
| inout Windowtype pl_window,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| pl_widgetExists := false;
|
| if (pl_window.id == "") {
|
| return false;
|
| }
|
| pl_window.id := f_EPTF_UIHandler_setWidgetID(pl_window.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_window.id);
|
| v_UIHandler_windowIndex := f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtWindow,
|
| omit,
|
| -1,
|
| {},
|
| omit,
|
| {window := f_EPTF_UIHandler_deleteChildrenFromWindow(pl_window)}, false},pl_widgetExists);
|
| if(-1 == v_UIHandler_windowIndex){
|
| return false;
|
| }
|
| var boolean bool:=true;
|
| for ( var integer i := 0; i < sizeof(pl_window.image_list) ; i := i+1 ) {
|
| bool := f_EPTF_UIHandler_appendImage(pl_window.image_list[i], v_UIHandler_windowIndex, pl_widgetExists)
|
| }
|
| if (0 != sizeof(pl_window.embeddedwidgets.embeddedwidget_list) ) {
|
| bool := f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(pl_window.embeddedwidgets, v_UIHandler_windowIndex,pl_widgetExists);
|
| }
|
| return bool;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromWidgetList
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widgets and their children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_widgets - *in* *WidgetList* - possible widgetList items (tabbox, tree, hbox, textlabel, spacer, button, textbox)
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // Check when a new widget type has been added
|
| //
|
| ///////////////////////////////////////////////////////////
|
| /* private function f_EPTF_UIHandler_appendAllWidgetIdsFromWidgetList(
|
| in EPTF_UIHandler_WidgetList pl_widgets,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| var boolean vl_ret := true;
|
| var integer maxIndex := sizeof(pl_widgets);
|
| for (var integer vl_i:=0; (vl_i < maxIndex) and vl_ret; vl_i := vl_i+1 ) {
|
| select(pl_widgets[vl_i]){
|
| case ({tabbox := ?}){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromTabbox(pl_widgets[vl_i].tabbox, pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({tree := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromTree(pl_widgets[vl_i].tree, pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({hbox := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromHbox(pl_widgets[vl_i].hbox, pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({label_ := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendLabel(pl_widgets[vl_i].label_,pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({spacer := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendSpacer(pl_widgets[vl_i].spacer,pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({button := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendButton(pl_widgets[vl_i].button,pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({textbox := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendTextbox(pl_widgets[vl_i].textbox,pl_parentIdx, pl_widgetExists);
|
| }
|
| case( {chart := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendChart(pl_widgets[vl_i].chart,pl_parentIdx, pl_widgetExists);
|
| }
|
| case({toolbar := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendToolbar(pl_widgets[vl_i].toolbar,pl_parentIdx, pl_widgetExists);
|
| }
|
| case({toolbarbutton := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendToolbarbutton(pl_widgets[vl_i].toolbarbutton,pl_parentIdx, pl_widgetExists);
|
| }
|
| case({listbox := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendListbox(pl_widgets[vl_i].listbox,pl_parentIdx, pl_widgetExists);
|
| }
|
| case({numericalwidget := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendNumericalwidget(pl_widgets[vl_i].numericalwidget,pl_parentIdx, pl_widgetExists);
|
| }
|
| case({menulist := ?}) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendMenulist(pl_widgets[vl_i].menulist,pl_parentIdx, pl_widgetExists);
|
| }
|
| case ({distributionchart := ?}){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendDistributionchart(pl_widgets[vl_i].distributionchart,pl_parentIdx, pl_widgetExists);
|
| }
|
| case else {
|
| f_EPTF_UIHandler_warning("Unhandled widget type!");
|
| // f_EPTF_Base_stop();
|
| }
|
| }
|
| }
|
| return vl_ret;
|
| }*/
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widgets and their children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_widgets - *in* *WidgetList* - possible widgetList items (tabbox, tree, hbox, textlabel, spacer, button, textbox)
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // Check when a new widget type has been added
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(
|
| in Embeddedwidgets pl_widgets,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| var boolean vl_ret := true;
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": In widgets incoming: " & log2str(pl_widgets));
|
| }
|
| var integer vl_embeddedwidget_list_size := sizeof(pl_widgets.embeddedwidget_list);
|
| for(var integer vl_i:=0; vl_i < vl_embeddedwidget_list_size and vl_ret; vl_i := vl_i + 1){
|
| if(ischosen(pl_widgets.embeddedwidget_list[vl_i].iterator)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_Config_processIterator( pl_widgets.embeddedwidget_list[vl_i], pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].externalvalue)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_Config_processIterator( pl_widgets.embeddedwidget_list[vl_i], pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].tabpages)){
|
| //vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromTabbox(pl_widgets.embeddedwidget_list[vl_i].tabbox, pl_parentIdx, pl_widgetExists);
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromTabpages(pl_widgets.embeddedwidget_list[vl_i].tabpages, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].tree)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromTree(pl_widgets.embeddedwidget_list[vl_i].tree, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].hbox)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromHbox(pl_widgets.embeddedwidget_list[vl_i].hbox, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].label_)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendLabel(pl_widgets.embeddedwidget_list[vl_i].label_,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].spacer)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendSpacer(pl_widgets.embeddedwidget_list[vl_i].spacer,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].button)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendButton(pl_widgets.embeddedwidget_list[vl_i].button,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].textbox)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendTextbox(pl_widgets.embeddedwidget_list[vl_i].textbox,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].chart)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendChart(pl_widgets.embeddedwidget_list[vl_i].chart,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].toolbar)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendToolbar(pl_widgets.embeddedwidget_list[vl_i].toolbar,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].listbox)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendListbox(pl_widgets.embeddedwidget_list[vl_i].listbox,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].numericalwidget)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendNumericalwidget(pl_widgets.embeddedwidget_list[vl_i].numericalwidget,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].menulist)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendMenulist(pl_widgets.embeddedwidget_list[vl_i].menulist,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_widgets.embeddedwidget_list[vl_i].distributionchart)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendDistributionchart(pl_widgets.embeddedwidget_list[vl_i].distributionchart,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_widgets.embeddedwidget_list[vl_i].pushbutton)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendPushbutton(pl_widgets.embeddedwidget_list[vl_i].pushbutton,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_widgets.embeddedwidget_list[vl_i].togglebutton)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendTogglebutton(pl_widgets.embeddedwidget_list[vl_i].togglebutton,pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_widgets.embeddedwidget_list[vl_i].htmlcode)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendHtmlcode(pl_widgets.embeddedwidget_list[vl_i].htmlcode,pl_parentIdx, pl_widgetExists);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Unhandled widget type!");
|
| // f_EPTF_Base_stop();
|
| }
|
| }
|
| return vl_ret;
|
| }
|
|
|
| //To make WidgetId optional
|
| type record XULWidgetId{
|
| universal charstring widgetId optional
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_XULWidgetId2charstr
|
| //
|
| // Purpose:
|
| // Converts a widget ID to a charstring
|
| //
|
| // Detailed Comments:
|
| // In the XUL structures the widget ID is universal charstring. It must be changed to charstring.
|
| // There are cases when the ID of widgets is optional. In order to handle easier it
|
| // has to be changed to an empty string.
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_XULWidgetId2charstr(in XULWidgetId pl_id)
|
| return charstring{
|
| if(ispresent(pl_id.widgetId)){
|
| if (lengthof(pl_id.widgetId)==0) {return ""}
|
| return f_EPTF_UIHandler_unichar2charstring(pl_id.widgetId);
|
| }else{
|
| return "";
|
| }
|
| }
|
|
|
| friend function f_EPTF_UIHandler_unichar2charstring(in universal charstring pl_uni)
|
| return charstring{
|
| var charstring vl_char := "";
|
| for (var integer vl_i:= 0;vl_i<lengthof(pl_uni);vl_i:=vl_i+1)
|
| {
|
| vl_char := vl_char & int2char(unichar2int(pl_uni[vl_i]));
|
| }
|
| return vl_char
|
| }
|
|
|
| friend function f_EPTF_UIHandler_setWidgetID(in template universal charstring pl_id)
|
| runs on EPTF_UIHandler_Private_CT
|
| return universal charstring{
|
| if(not isvalue(pl_id) or 0 == lengthof(pl_id)){
|
| return f_EPTF_UIHandler_getrandomid();
|
| }
|
| var integer vl_idx;
|
| var boolean vl_isexisting := (valueof(pl_id) != "" and f_EPTF_str2int_HashMap_Find(v_UIHandler_widgetHashMapId, f_EPTF_UIHandler_unichar2charstring(valueof(pl_id)), vl_idx));
|
| if(vl_isexisting == true){ // old -1 != vl_prevIdx
|
| if(v_UIHandler_customGUIProcess){
|
| //: need to handle in XML process
|
| //if(v_UIHandler_iteratorChangeInProgress == true){
|
| var charstring vl_storeOrigId := f_EPTF_UIHandler_unichar2charstring(valueof(pl_id));
|
| //generaljunk idt.
|
| var universal charstring vl_unichar := f_EPTF_UIHandler_getrandomid();
|
| f_EPTF_UIHandler_warning(%definitionId&": Wrong widget ID: "& vl_storeOrigId & ". It is already in use. The new widget created by an iterator is renamed to: " & f_EPTF_UIHandler_unichar2charstring(vl_unichar) &". In order to avoid any problems please rename the widget in your customgui xml file.");
|
| return vl_unichar;
|
| // }
|
| }
|
| }
|
| return valueof(pl_id);
|
| }
|
|
|
| //Gets the widgetId
|
| friend function f_EPTF_UIHandler_getWidgetID(in Widgets pl_widget, out charstring pl_widgetId)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if(ischosen(pl_widget.window)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.window.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.iterator )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.iterator.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.externalvalue )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.externalvalue.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.treecol )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.treecol.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.treecell )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.treecell.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.trace )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.trace.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.toolbarbutton )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.toolbarbutton.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.tabpage )) {
|
| if(ispresent(pl_widget.tabpage.id)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.tabpage.id);
|
| } else {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(f_EPTF_UIHandler_getrandomid());
|
| }
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.listitem )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.listitem.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.menuitem )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.menuitem.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.distributionchart )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.distributionchart.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.valuelist )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.valuelist.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.image )) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.image.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.tabpages)){
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.tabpages.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.tree)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.tree.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.hbox)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.hbox.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.label_)) {
|
| if(ispresent(pl_widget.label_.id) and pl_widget.label_.id != omit) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.label_.id);
|
| } else {
|
| pl_widgetId := "";
|
| }
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.spacer)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.spacer.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.button)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.button.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.textbox)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.textbox.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.chart)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.chart.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.toolbar)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.toolbar.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.listbox)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.listbox.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.numericalwidget)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.numericalwidget.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.menulist)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.menulist.id);
|
| return true;
|
| }
|
| else if (ischosen(pl_widget.distributionchart)){
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.distributionchart.id);
|
| return true;
|
| }
|
| else if (ischosen(pl_widget.pushbutton)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.pushbutton.id);
|
| return true;
|
| }
|
| else if (ischosen(pl_widget.togglebutton)) {
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.togglebutton.id);
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.treerow )) {
|
| pl_widgetId := "";
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.toolbarelements )) {
|
| pl_widgetId := "";
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.tracelist )) {
|
| pl_widgetId := "";
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.treecols )) {
|
| pl_widgetId := "";
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.treechildren )) {
|
| pl_widgetId := "";
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.treeitem )) {
|
| pl_widgetId := "";
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.separator )) {
|
| if(ispresent(pl_widget.separator.id)){
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.separator.id);
|
| } else {
|
| pl_widgetId := "";
|
| }
|
| return true;
|
| }
|
| else if(ischosen(pl_widget.htmlcode )) {
|
| if(ispresent(pl_widget.htmlcode.id)){
|
| pl_widgetId := f_EPTF_UIHandler_unichar2charstring(pl_widget.htmlcode.id);
|
| } else {
|
| pl_widgetId := "";
|
| }
|
| return true;
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Unhandled widget type! : "&log2str(pl_widget));
|
| // f_EPTF_Base_stop();
|
| }
|
| return false;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getrandomid
|
| //
|
| // Purpose:
|
| // Returns a generated unique widget ID. See also <c_EPTF_UIHandler_widgetIdPrefix>
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_getrandomid(in boolean pl_notVisible := false)
|
| runs on EPTF_UIHandler_Private_CT
|
| return universal charstring {
|
| var charstring vl_id;
|
| if(pl_notVisible){
|
| vl_id := c_EPTF_UIHandler_notVisibleWidgetIdPrefix & int2str(v_EPTF_UIHandler_generatedNotVisibleIdCounter);
|
| v_EPTF_UIHandler_generatedNotVisibleIdCounter := v_EPTF_UIHandler_generatedNotVisibleIdCounter + 1;
|
| } else {
|
| vl_id := c_EPTF_UIHandler_widgetIdPrefix & int2str(v_EPTF_UIHandler_generatedIdCounter);
|
| v_EPTF_UIHandler_generatedIdCounter := v_EPTF_UIHandler_generatedIdCounter + 1;
|
| }
|
| return vl_id;
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromTabpages
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_tabpages - *in* *Tabpages* - possible tabpages items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromTabpages(
|
| inout Tabpages pl_tabpages,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_tabpages.id := f_EPTF_UIHandler_setWidgetID(pl_tabpages.id)
|
| var charstring tabpagesid := f_EPTF_UIHandler_unichar2charstring(pl_tabpages.id)
|
|
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec({
|
| tabpagesid,
|
| wtTabpages,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {tabpages := f_EPTF_UIHandler_deleteChildrenFromTabpages(pl_tabpages)}, false}, pl_widgetExists);
|
|
|
| if(-1 != vl_idx){
|
| // Call children...
|
| //******************************************************************
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromTabpagegroup_list(pl_tabpages.tabpagegroups.tabpagegroup_list, vl_idx, pl_widgetExists)
|
| }
|
| return false;
|
| }
|
|
|
|
|
|
|
| private type union EPTF_UIHandler_TabpanelsParentId{
|
| integer tabBoxIdx,
|
| //integer tabIdxInTabs,
|
| integer tabIdx
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromTabpages
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_tabpages - *in* <Tabpages> - possible tabpages items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromTabpagegroup_list(
|
| inout Tabpagegroups.tabpagegroup_list pl_tabpagegroup_list,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| pl_widgetExists := false;
|
| var boolean vl_ret := true;
|
|
|
| //var EPTF_UIHandler_HandledWidgetType vl_parentType := v_UIHandler_guiItemList[pl_parentIdx].widgetType;
|
| var integer i:=0;
|
| var integer vl_tabpagegroup_list_size := sizeof(pl_tabpagegroup_list);
|
| while ( isbound(pl_tabpagegroup_list) and (i < vl_tabpagegroup_list_size) and vl_ret )
|
| {
|
| if (ischosen(pl_tabpagegroup_list[i].tabpage)){
|
| //: GIKXLZ, vl_ret change
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTabpage(pl_tabpagegroup_list[i].tabpage, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_tabpagegroup_list[i].iterator)){
|
| f_EPTF_UIHandler_Config_processTabpageiterator(pl_tabpagegroup_list[i], pl_parentIdx, true, pl_widgetExists)
|
| }
|
| else if (ischosen(pl_tabpagegroup_list[i].externalvalue)){
|
| f_EPTF_UIHandler_Config_processTabpageiterator(pl_tabpagegroup_list[i], pl_parentIdx, true, pl_widgetExists)
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_tabpagegroup_list[i]));
|
| vl_ret := false;
|
| }
|
| i := i + 1;
|
| } //for
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromExternaldatagroup_list
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_tabpages - *in* <Tabpages> - possible tabpages items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromExternaldatagroup_list(
|
| in Externaldatagroups.externaldatagroup_list pl_externaldatagroup_list,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists,
|
| inout Distributionchart pl_xul)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| pl_widgetExists := false;
|
| var boolean vl_ret := true;
|
|
|
| var integer vl_treeitems_size := sizeof(pl_externaldatagroup_list);
|
| for(var integer i := 0; i < vl_treeitems_size and vl_ret; i := i + 1 ){
|
| if (ischosen(pl_externaldatagroup_list[i].valuelist_list)){
|
| for(var integer j := 0; j <sizeof(pl_externaldatagroup_list[i].valuelist_list); j := j + 1) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendValuelist(pl_externaldatagroup_list[i].valuelist_list[j], pl_parentIdx, pl_widgetExists);
|
| //pl_xul.valuelist_list[sizeof(pl_xul.valuelist_list)] := pl_externaldatagroup_list[i].valuelist_list[j];
|
| }
|
| }
|
| else if (ischosen(pl_externaldatagroup_list[i].iterator)){
|
| f_EPTF_UIHandler_Config_processValueListiterator(pl_externaldatagroup_list[i], pl_xul, pl_parentIdx, true, pl_widgetExists)
|
| }
|
| else if (ischosen(pl_externaldatagroup_list[i].externalvalue)){
|
| f_EPTF_UIHandler_Config_processValueListiterator(pl_externaldatagroup_list[i], pl_xul, pl_parentIdx, true, pl_widgetExists);
|
| } else {
|
| f_EPTF_Base_assert(%definitionId & ": Invalid element to be added: " & log2str(pl_externaldatagroup_list[i]), false);
|
| vl_ret := false;
|
| }
|
| } //for
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromTabpage
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_tabpage - *in* <Tabpage> - possible tabpage items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromTabpage(
|
| inout Tabpage pl_tabpage,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| pl_widgetExists := false;
|
| var boolean vl_ret := true;
|
| var integer vl_tabPage_id;
|
| if(v_UIHandler_guiItemList[pl_parentIdx].widgetType == wtTabpage) {
|
| v_UIHandler_guiItemList[pl_parentIdx].XULformat.tabpage.maxheight := pl_tabpage.maxheight;
|
| v_UIHandler_guiItemList[pl_parentIdx].XULformat.tabpage.orientation := pl_tabpage.orientation;
|
| var Embeddedwidgets e_widgets := pl_tabpage.embeddedwidgets;
|
| pl_tabpage := v_UIHandler_guiItemList[pl_parentIdx].XULformat.tabpage;
|
| pl_tabpage.embeddedwidgets := e_widgets;
|
| vl_tabPage_id := pl_parentIdx;
|
|
|
| if (0 != sizeof(pl_tabpage.embeddedwidgets.embeddedwidget_list )) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(pl_tabpage.embeddedwidgets, vl_tabPage_id, pl_widgetExists);
|
| }
|
| } else if( v_UIHandler_guiItemList[pl_parentIdx].widgetType == wtWindow){
|
| vl_tabPage_id := f_EPTF_UIHandler_appendTabPage(pl_tabpage, pl_parentIdx, pl_widgetExists);
|
| if (0 != sizeof(pl_tabpage.embeddedwidgets.embeddedwidget_list )) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(pl_tabpage.embeddedwidgets, pl_parentIdx, pl_widgetExists);
|
| }
|
| } else {
|
| vl_tabPage_id := f_EPTF_UIHandler_appendTabPage(pl_tabpage, pl_parentIdx, pl_widgetExists);
|
| if (0 != sizeof(pl_tabpage.embeddedwidgets.embeddedwidget_list )) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(pl_tabpage.embeddedwidgets, vl_tabPage_id, pl_widgetExists);
|
| }
|
| }
|
|
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromTree
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widgets and their children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_tree - *in* <Tree> - possible tree items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromTree(
|
| in Tree pl_tree,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": "&log2str(pl_tree));
|
| }
|
| pl_widgetExists := false;
|
| var boolean vl_ret := false;
|
| var Tree vl_xtdpTree := f_EPTF_UIHandler_deleteChildrenFromTree(pl_tree);
|
| vl_xtdpTree.rows := 0.0; // initially tree doesn't have rows in the counter. This counter is incremented in f_EPTF_UIHandler_appendAllWidgetIdsFromTreeRowGroups
|
| pl_tree.id := f_EPTF_UIHandler_setWidgetID(pl_tree.id);
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec(
|
| {
|
| /*id*/ f_EPTF_UIHandler_unichar2charstring(pl_tree.id),
|
| /*widgetType*/wtTree,
|
| /*widgetDataType*/omit,
|
| /*parentIdx*/pl_parentIdx,
|
| /*children*/{},
|
| /*widgetData*/{treeData := {{},0}},
|
| /*XULformat*/{tree := vl_xtdpTree},
|
| /*xuldisabled*/false
|
| },
|
| pl_widgetExists);
|
| if(-1 != vl_idx ){
|
| // Calling children...
|
| if(f_EPTF_UIHandler_appendAllWidgetIdsFromTreecols(pl_tree.treecols.treecolgroups.treecolgroup_list, vl_idx, pl_widgetExists)){
|
| //Treechildren
|
| vl_ret := f_EPTF_UIHandler_appendAllWidgetIdsFromTreeItemGroups(pl_tree.treechildren.treeitemgroups.treeitemgroup_list, vl_idx, pl_widgetExists);
|
| // if not enough row is defined, append empty rows to the tree
|
| var integer vl_rowNum := 0;
|
| if(ispresent(pl_tree.rows)) {
|
| vl_rowNum := float2int(pl_tree.rows);
|
| }
|
|
|
| for (var integer i:= float2int(v_UIHandler_guiItemList[vl_idx].XULformat.tree.rows); i<vl_rowNum; i := i+1) {
|
| var Treerow vl_UIHandler_XSD_emptyTreeRow := c_UIHandler_XSD_emptyTreeRow;
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromTreeCellGroups(vl_UIHandler_XSD_emptyTreeRow.treecellgroups.treecellgroup_list, vl_idx, pl_widgetExists);
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Empty row added to tree since not enough rows specified");
|
| }
|
| }
|
| //if(float2int(v_UIHandler_guiItemList[vl_idx].XULformat.tree.rows)<vl_rowNum){
|
| v_UIHandler_guiItemList[vl_idx].XULformat.tree.rows := int2float(vl_rowNum);
|
| //}
|
| }
|
| }
|
|
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendTreecol
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_col - *in* <Treecol> - tree column item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendTreecol(
|
| in Treecol pl_col,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| pl_widgetExists := false;
|
| pl_col.id := f_EPTF_UIHandler_setWidgetID(pl_col.id);
|
| pl_col.id := f_EPTF_UIHandler_setWidgetID(pl_col.id);
|
| var charstring tid := f_EPTF_UIHandler_unichar2charstring(pl_col.id);
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec(
|
| {
|
| tid,
|
| wtTreecol,
|
| pl_col.widgetType,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {treecol := pl_col},
|
| false
|
| },
|
| pl_widgetExists
|
| //It has no reason. The default value appends to the end.
|
| /*,
|
| sizeof(v_UIHandler_guiItemList[pl_parentIdx].widgetData.treeData.columns)*/
|
| );
|
| if(-1 != vl_idx){
|
| var integer vl_nonMetaParentIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(pl_parentIdx);
|
| f_EPTF_UIHandler_addIdx2IdxList(v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.columns, vl_idx);
|
| // add new empty cell to the end of every row
|
| var integer vl_rowNum := float2int(v_UIHandler_guiItemList[vl_nonMetaParentIdx].XULformat.tree.rows);
|
| //var integer vl_colNum := sizeof(v_UIHandler_guiItemList[pl_parentIdx].widgetData.treeData.columns);
|
| var EPTF_UIHandler_GuiItemRec vl_emptyCell := {
|
| "",
|
| wtTreecell,
|
| pl_col.widgetType,
|
| pl_parentIdx,
|
| {},
|
| {cellData := {vl_idx,omit}},
|
| {treecell := c_UIHandler_XSD_emptyTreeCell},
|
| false
|
| }
|
| var integer vl_cellIdx;
|
| var boolean vl_dummy;
|
| var integer vl_col := sizeof(v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.columns)-1;
|
| for ( var integer i := 0; i < vl_rowNum ; i := i+1 ) {
|
| // create emplty cell with proper id and insert to its own place
|
| vl_emptyCell.id := f_EPTF_UIHandler_unichar2charstring(f_EPTF_UIHandler_getrandomid());
|
| vl_emptyCell.XULformat.treecell.id := vl_emptyCell.id;
|
| vl_cellIdx := f_EPTF_UIHandler_addWidgetRec(vl_emptyCell, vl_dummy/*, i * vl_colNum + vl_colNum - 1 + vl_colNum*/);
|
| v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells + 1;
|
| }
|
| // FIXME
|
| // if(vl_col > 0){
|
| // //rearrange the childrenList in the tree
|
| // var EPTF_IntegerList vl_newChildrenList := {};
|
| // var integer vl_nofChildren := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells;
|
| // vl_col := vl_col +1;
|
| // var integer vl_ptr1 := -1; //it goes from the start
|
| // var integer vl_ptr2 := vl_nofChildren - vl_rowNum - 2; //it goes from the new column
|
| // var integer vl_ptr3 := vl_ptr1;
|
| // for ( var integer i := 0; i < vl_nofChildren ; i := i+1 )
|
| // {
|
| // if (i mod vl_col == vl_col-1) {
|
| // vl_ptr2 := vl_ptr2 + 1;
|
| // vl_ptr3 := vl_ptr2;
|
| // } else {
|
| // vl_ptr1:= vl_ptr1 +1;
|
| // vl_ptr3 := vl_ptr1;
|
| // }
|
| // vl_newChildrenList[i] := v_UIHandler_guiItemList[vl_nonMetaParentIdx].children[vl_ptr3];
|
| // }
|
| // v_UIHandler_guiItemList[vl_nonMetaParentIdx].children := vl_newChildrenList;
|
| // }
|
| }
|
| return vl_idx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromTreecols
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_cols - *in* <Treecols> - possible tree coloumn items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromTreecols(
|
| inout Treecolgroups.treecolgroup_list pl_cols,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| var boolean vl_ret := true;
|
|
|
| var integer vl_cols_size := sizeof(pl_cols);
|
| for (var integer i:=0; i < vl_cols_size and vl_ret; i := i+ 1 ){
|
| if (ischosen(pl_cols[i].treecol)){
|
| vl_ret := vl_ret and (-1 != f_EPTF_UIHandler_appendTreecol(pl_cols[i].treecol, pl_parentIdx, pl_widgetExists));
|
| }
|
| else if (ischosen(pl_cols[i].iterator)){
|
| f_EPTF_UIHandler_Config_processTreecoliterator(pl_cols[i], pl_parentIdx, true, pl_widgetExists);
|
| //The iterator processed and replaced with its represented data.
|
| //Let's process them. Therefore don't increment the position
|
| }
|
| else if (ischosen(pl_cols[i].externalvalue)){
|
| f_EPTF_UIHandler_Config_processTreecoliterator(pl_cols[i], pl_parentIdx, true, pl_widgetExists);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_cols[i]));
|
| vl_ret := false;
|
| }
|
| } //for
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromTreeItemGroups
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_list - *in* <Treechildren> - possible tree items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromTreeItemGroups(
|
| in Treeitemgroups.treeitemgroup_list pl_treeitems,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": "&log2str(pl_treeitems))
|
| }
|
| pl_widgetExists := false;
|
| var boolean vl_ret := true;
|
| var integer vl_treeitems_size := sizeof(pl_treeitems);
|
| for(var integer i := 0; i < vl_treeitems_size and vl_ret; i := i + 1 ){
|
| if (ischosen(pl_treeitems[i].treeitem)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromTreeRowGroups(pl_treeitems[i].treeitem.treerowgroups.treerowgroup_list, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_treeitems[i].iterator)){
|
| f_EPTF_UIHandler_Config_processTreeItemiterator(pl_treeitems[i], pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_treeitems[i].externalvalue)){
|
| f_EPTF_UIHandler_Config_processTreeItemiterator(pl_treeitems[i], pl_parentIdx, true, pl_widgetExists);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_treeitems[i]));
|
| vl_ret := false;
|
| }
|
| } //for
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromTreeRowGroups
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends Treeitem typed widgetIds
|
| // from request to string list of current runtime GUI widgetIds
|
| //
|
| // Parameters:
|
| // pl_treeitem - *in* <Treeitem> - possible tree items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromTreeRowGroups(
|
| inout Treerowgroups.treerowgroup_list pl_treerowgroups,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| var integer vl_nonMetaParentIdx := f_EPTF_UIHandler_getTreeIdx(pl_parentIdx);
|
| var integer vl_treedataColumns := sizeof(v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.columns);
|
|
|
| var boolean vl_ret := true;
|
| var integer pl_treerowgroups_size := sizeof(pl_treerowgroups);
|
| for(var integer i := 0; i < pl_treerowgroups_size and vl_ret; i := i + 1 ){
|
| if (ischosen(pl_treerowgroups[i].treerow)){
|
| var integer vl_treerowIdx := f_EPTF_UIHandler_appendTreeRow(pl_parentIdx, pl_widgetExists);
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendAllWidgetIdsFromTreeCellGroups(pl_treerowgroups[i].treerow.treecellgroups.treecellgroup_list, vl_treerowIdx, pl_widgetExists);
|
| // increment rowsize of tree
|
| if(ispresent(v_UIHandler_guiItemList[vl_nonMetaParentIdx].XULformat.tree.rows)) {
|
| v_UIHandler_guiItemList[vl_nonMetaParentIdx].XULformat.tree.rows := v_UIHandler_guiItemList[vl_nonMetaParentIdx].XULformat.tree.rows + 1.0;
|
| } else {
|
| v_UIHandler_guiItemList[vl_nonMetaParentIdx].XULformat.tree.rows := 1.0;
|
| }
|
| }
|
| else if (ischosen(pl_treerowgroups[i].iterator)){
|
| f_EPTF_UIHandler_Config_processTreerowiterator(pl_treerowgroups[i], pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_treerowgroups[i].externalvalue)){
|
| f_EPTF_UIHandler_Config_processTreerowiterator(pl_treerowgroups[i], pl_parentIdx, true, pl_widgetExists);
|
| } else {
|
| f_EPTF_Base_assert(%definitionId&": Invalid element to be added: "&log2str(pl_treerowgroups[i]),false);
|
| vl_ret := false;
|
| }
|
| } //for
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendCell
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_treecell - *in* <Treecell> - possible tree items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| // pl_columnsIdx - *in* *integer* the idx of the column in v_UIHandler_guiItemList[pl_parentIdx].widgetData.treeData.columns.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendCell(
|
| inout Treecell pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists,
|
| in integer pl_columnsIdx
|
| ) runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| //Check the column count
|
| var integer vl_nonMetaParentIdx := f_EPTF_UIHandler_getTreeIdx(pl_parentIdx);
|
| var integer vl_treedataColumns := sizeof(v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.columns);
|
| if(0 == vl_treedataColumns){
|
| f_EPTF_UIHandler_warning("There are no columns in the tree!");
|
| return false;
|
| }
|
| if(vl_treedataColumns<= pl_columnsIdx){
|
| f_EPTF_UIHandler_error("There are less columns ("&
|
| int2str(vl_treedataColumns)&
|
| ")in the tree '"&
|
| v_UIHandler_guiItemList[vl_nonMetaParentIdx].id&"' than cells.");
|
| return false;
|
| }
|
| //get the row idx from the tree xulformat
|
| //var integer vl_currentRow := float2int(v_UIHandler_guiItemList[pl_parentIdx].XULformat.tree.rows);
|
| var integer vl_colIdx := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.columns[pl_columnsIdx];
|
|
|
| var charstring tid;
|
| if(ispresent(pl_xul.id)){
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| tid := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| }else{
|
| tid := "";
|
| }
|
| if (tid == ""){
|
| var integer vl_row := 0;
|
| if (vl_treedataColumns != 0) {
|
| vl_row := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells / vl_treedataColumns;
|
| }
|
| tid := f_EPTF_UIHandler_unichar2charstring(f_EPTF_UIHandler_getrandomid());
|
| pl_xul.id := tid;
|
| }
|
| var boolean vl_ret := -1 != f_EPTF_UIHandler_addWidgetRec({
|
| tid,
|
| wtTreecell,
|
| v_UIHandler_guiItemList[vl_colIdx].widgetDataType,
|
| pl_parentIdx,
|
| {},
|
| {cellData := {vl_colIdx, omit}},
|
| {treecell := f_EPTF_UIHandler_deleteChildrenFromTreecell(pl_xul)}, false},
|
| pl_widgetExists);
|
|
|
| if (vl_ret) {
|
| v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells + 1;
|
| }
|
|
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, tid);
|
| pl_xul.externaldata := omit;
|
| }
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromTreeCellGroups
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_treerow - *in* <Treerow> - possible tree row items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromTreeCellGroups(
|
| in Treecellgroups.treecellgroup_list pl_treecellgroups,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists,
|
| in boolean pl_appendCells := true)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| var boolean vl_ret := true;
|
| var integer vl_nonMetaParentIdx := f_EPTF_UIHandler_getTreeIdx(pl_parentIdx);
|
|
|
| var EPTF_IntegerList vl_cols := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.columns;
|
| var integer vl_nofCells := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells;
|
|
|
| // return if too much cell is given in the row
|
|
|
| //vl_rowsize := sizeof(pl_treecellgroups.treecellgroup_list);
|
| // iterate through the treerow and add cells to internal database
|
|
|
| var integer vl_treecellgroups_size := sizeof(pl_treecellgroups);
|
| for(var integer i := 0; i < vl_treecellgroups_size and vl_ret; i := i + 1 ){
|
| if (ischosen(pl_treecellgroups[i].treecell)){
|
| //Cells
|
| var integer vl_sizeOfSibling := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells;
|
| var integer vl_columnsIdx := vl_sizeOfSibling mod sizeof(vl_cols);
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendCell(pl_treecellgroups[i].treecell, pl_parentIdx, pl_widgetExists, vl_columnsIdx)
|
| }
|
| else if (ischosen(pl_treecellgroups[i].iterator)){
|
| f_EPTF_UIHandler_Config_processTreecelliterator(pl_treecellgroups[i], pl_parentIdx, true, pl_widgetExists);
|
| //The iterator processed and replaced with its represented data.
|
| //Let's process them. Therefore don't increment the position
|
| }
|
| else if (ischosen(pl_treecellgroups[i].externalvalue)){
|
| f_EPTF_UIHandler_Config_processTreecelliterator(pl_treecellgroups[i], pl_parentIdx, true, pl_widgetExists);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_treecellgroups[i]));
|
| vl_ret := false;
|
| }
|
| } //while
|
|
|
| //Check the processed cellcount
|
| var integer vl_nofCellsNew := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells;
|
| var integer vl_rowsize := vl_nofCellsNew-vl_nofCells;
|
| if(vl_rowsize > sizeof(vl_cols)){
|
| f_EPTF_UIHandler_warning("There are more cells in the row than columns in the tree.");
|
| return false;
|
| }
|
| //FIXME: AUTOMATIC CELL APPEND REMOVED
|
| // if(pl_appendCells){
|
| // // add empty cells to the row if not enough is given
|
| // var integer vl_row := 0;
|
| // var integer vl_columns := sizeof(vl_cols);
|
| // if (vl_columns != 0) {
|
| // vl_row := v_UIHandler_guiItemList[vl_nonMetaParentIdx].widgetData.treeData.nofCells / vl_columns;
|
| // }
|
| // for (var integer i := vl_rowsize; i < vl_columns and vl_ret; i := i+1) {
|
| // var Treecell vl_emptyCell := c_UIHandler_XSD_emptyTreeCell;
|
| // vl_emptyCell.id := v_UIHandler_guiItemList[vl_nonMetaParentIdx].id&"."&int2str(vl_row)&"."&int2str(i);
|
| // vl_ret := vl_ret and f_EPTF_UIHandler_appendCell(vl_emptyCell, pl_parentIdx, pl_widgetExists, i);
|
| // //pl_list[i].treecell := c_UIHandler_XSD_emptyTreeCell;
|
| // }
|
| // // increment rowsize of tree
|
| // //v_UIHandler_guiItemList[pl_parentIdx].XULformat.tree.rows := v_UIHandler_guiItemList[pl_parentIdx].XULformat.tree.rows + 1.0;
|
| // }
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendAllWidgetIdsFromHbox
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_hbox - *in* <Hbox> - possible Hbox items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendAllWidgetIdsFromHbox(
|
| inout Hbox pl_hbox,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": pl_hbox"&log2str(pl_hbox)&
|
| "\npl_parentIdx: "&log2str(pl_parentIdx));
|
| }
|
| // log("DEBUG: ","--- f_EPTF_UIHandler_appendAllWidgetIdsFromHbox", pl_hbox);
|
| pl_widgetExists := false;
|
| pl_hbox.id := f_EPTF_UIHandler_setWidgetID(pl_hbox.id);
|
| var charstring hboxid := f_EPTF_UIHandler_unichar2charstring(pl_hbox.id);
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec({
|
| hboxid,
|
| wtHbox,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {hbox := f_EPTF_UIHandler_deleteChildrenFromHbox(pl_hbox)}, false}, pl_widgetExists);
|
|
|
| // Calling children...
|
| if (0 < sizeof(pl_hbox.embeddedwidgets.embeddedwidget_list) and (-1 != vl_idx)) {
|
| return f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(pl_hbox.embeddedwidgets, vl_idx, pl_widgetExists);
|
| }
|
| return -1 != vl_idx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendTabPage
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_tabpage - *in* <Tabpage> - possible Tabpage items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendTabPage(
|
| inout Tabpage pl_tabpage,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| pl_widgetExists := false;
|
| pl_tabpage.id := f_EPTF_UIHandler_setWidgetID(pl_tabpage.id)
|
| return f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(pl_tabpage.id),
|
| wtTabpage,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {tabpage := f_EPTF_UIHandler_deleteChildrenFromTabpage(pl_tabpage)}, false}, pl_widgetExists);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendLabel
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_label - *in* <Label> - possible Label items
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendLabel(
|
| in Label pl_label,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| if(not isbound(pl_label.id) or pl_label.id == omit or 0 == lengthof(pl_label.id)){
|
| pl_label.id := f_EPTF_UIHandler_getrandomid();
|
| }
|
| pl_label.id := f_EPTF_UIHandler_setWidgetID(pl_label.id);
|
| var charstring labelid := f_EPTF_UIHandler_unichar2charstring(pl_label.id);
|
| var boolean vl_ret := -1 != f_EPTF_UIHandler_addWidgetRec({
|
| labelid,
|
| wtLabel,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {label_ := f_EPTF_UIHandler_deleteChildrenFromLabel(pl_label)}, false}, pl_widgetExists);
|
| if(ispresent(pl_label.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_label.externaldata, labelid);
|
| pl_label.externaldata := omit;
|
| }
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendSpacer
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Spacer> - possible Spacer item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendSpacer(
|
| inout Spacer pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring spacerid := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| return -1 != f_EPTF_UIHandler_addWidgetRec({
|
| spacerid,
|
| wtSpacer,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {spacer := f_EPTF_UIHandler_deleteChildrenFromSpacer(pl_xul)}, false}, pl_widgetExists);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendButton
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Button> - possible Button item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendButton(
|
| inout Button pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| var boolean vl_ret := -1 != f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtButton,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {button := f_EPTF_UIHandler_deleteChildrenFromButton(pl_xul)}, false}, pl_widgetExists);
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendPushbutton
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Pushbutton> - possible Pushbutton item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendPushbutton(
|
| inout Pushbutton pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| if( -1 != f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtPushbutton,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {pushbutton := f_EPTF_UIHandler_deleteChildrenFromPushbutton(pl_xul)}, false}, pl_widgetExists)){
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return true;
|
| }else{
|
| return false;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendTogglebutton
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Togglebutton> - possible Togglebutton item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendTogglebutton(
|
| inout Togglebutton pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| if( -1 != f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtTogglebutton,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {togglebutton := f_EPTF_UIHandler_deleteChildrenFromTogglebutton(pl_xul)}, false}, pl_widgetExists)){
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return true;
|
| }else{
|
| return false;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendTextbox
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Textbox> - possible Textbox item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendTextbox(
|
| inout Textbox pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| if( -1 != f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtTextbox,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {textbox := f_EPTF_UIHandler_deleteChildrenFromTextbox(pl_xul)}, false}, pl_widgetExists)){
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return true;
|
| }else{
|
| return false;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendHtmlcode
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Htmlcode> - possible Htmlcode item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendHtmlcode(
|
| inout Htmlcode pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| if( -1 != f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtHtmlcode,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {htmlcode := f_EPTF_UIHandler_deleteChildrenFromHtmlcode(pl_xul)}, false}, pl_widgetExists)){
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return true;
|
| }else{
|
| return false;
|
| }
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendChart
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Chart> - possible Chart item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendChart(
|
| inout Chart pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| wtChart,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {chart := f_EPTF_UIHandler_deleteChildrenFromChart(pl_xul)}, false}, pl_widgetExists)
|
| if(-1 < vl_idx){
|
| return f_EPTF_UIHandler_Config_processTracegroups(pl_xul.tracegroups.tracegroup_list, vl_idx, pl_widgetExists);
|
| }
|
| return false;
|
| }
|
|
|
| private function f_EPTF_UIHandler_Config_processTracegroups(
|
| in Tracegroups.tracegroup_list pl_tracegroups,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var boolean vl_ret := true;
|
| var integer pl_tracegroups_size := sizeof(pl_tracegroups);
|
| for(var integer i := 0; i < pl_tracegroups_size and vl_ret; i := i + 1 ){
|
| if (ischosen(pl_tracegroups[i].trace)) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendTrace(pl_tracegroups[i].trace, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if ( ischosen(pl_tracegroups[i].iterator) ){
|
| f_EPTF_UIHandler_Config_processTraceiterator(pl_tracegroups[i], pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if ( ischosen(pl_tracegroups[i].externalvalue) ){
|
| f_EPTF_UIHandler_Config_processTraceiterator(pl_tracegroups[i], pl_parentIdx, true, pl_widgetExists);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_tracegroups[i]));
|
| vl_ret := false;
|
| }
|
| }
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Result : " & log2str(pl_tracegroups));
|
| }
|
| return vl_ret;
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendTrace
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Trace> - possible Trace item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendTrace(
|
| inout Trace pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| if( -1 != f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtTrace,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {trace := f_EPTF_UIHandler_deleteChildrenFromTrace(pl_xul)}, false}, pl_widgetExists)){
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return true;
|
| }else{
|
| return false;
|
| }
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendToolbar
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Toolbar> - possible Toolbar item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendToolbar(
|
| inout Toolbar pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| wtToolbar,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {toolbar := f_EPTF_UIHandler_deleteChildrenFromToolbar(pl_xul)}, false}, pl_widgetExists);
|
| if(-1 < vl_idx){
|
| var boolean vl_ret := true;
|
| for(var integer vl_i := 0; vl_i < sizeof(pl_xul.choice_list);vl_i := vl_i + 1){
|
| if(ischosen(pl_xul.choice_list[vl_i].toolbarbutton)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendToolbarbutton(pl_xul.choice_list[vl_i].toolbarbutton, vl_idx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_xul.choice_list[vl_i].pushbutton)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendPushbutton(pl_xul.choice_list[vl_i].pushbutton, vl_idx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_xul.choice_list[vl_i].togglebutton)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendTogglebutton(pl_xul.choice_list[vl_i].togglebutton, vl_idx, pl_widgetExists);
|
| } else {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendSeparator(pl_xul.choice_list[vl_i].separator, vl_idx, pl_widgetExists);
|
| }
|
| }
|
| return vl_ret;
|
| }
|
| return false;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendToolbarelements
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Toolbarelements> - possible Toolbar item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendToolbarelements(
|
| inout Toolbarelements pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var boolean vl_ret := true;
|
| for(var integer vl_i := 0; vl_i < sizeof(pl_xul.toolbarelement_list);vl_i := vl_i + 1){
|
| if (ischosen(pl_xul.toolbarelement_list[vl_i].choice.toolbarbutton)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendToolbarbutton(pl_xul.toolbarelement_list[vl_i].choice.toolbarbutton, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_xul.toolbarelement_list[vl_i].choice.togglebutton)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendTogglebutton(pl_xul.toolbarelement_list[vl_i].choice.togglebutton, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_xul.toolbarelement_list[vl_i].choice.separator)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendSeparator(pl_xul.toolbarelement_list[vl_i].choice.separator, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_xul.toolbarelement_list[vl_i].choice.pushbutton)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendPushbutton(pl_xul.toolbarelement_list[vl_i].choice.pushbutton, pl_parentIdx, pl_widgetExists);
|
| } else {
|
| f_EPTF_UIHandler_warning("Unhandled widgettype as a toolbarelement!");
|
| }
|
| }
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendToolbarbutton
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Toolbarbutton> - possible Toolbarbutton item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendToolbarbutton(
|
| inout Toolbarbutton pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| if( -1 != f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtToolbarbutton,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {toolbarbutton := f_EPTF_UIHandler_deleteChildrenFromToolbarbutton(pl_xul)}, false}, pl_widgetExists)){
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return true;
|
| }else{
|
| return false;
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendListbox(
|
| inout Listbox pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| wtListbox,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {listbox := f_EPTF_UIHandler_deleteChildrenFromListbox(pl_xul)}, false}, pl_widgetExists)
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, f_EPTF_UIHandler_unichar2charstring(pl_xul.id));
|
| pl_xul.externaldata := omit;
|
| }
|
| if(-1 < vl_idx){
|
| return f_EPTF_UIHandler_Config_processListitemgroups(pl_xul.listitemgroups.listitemgroup_list, vl_idx, pl_widgetExists)
|
| }
|
| return false;
|
| }
|
|
|
| private function f_EPTF_UIHandler_Config_processListitemgroups(
|
| inout Listitemgroups.listitemgroup_list pl_listitems,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var boolean vl_ret := true;
|
| var integer vl_listitems_size := sizeof(pl_listitems);
|
| for(var integer i := 0; i < vl_listitems_size and vl_ret; i := i + 1 ){
|
| if ( ischosen(pl_listitems[i].listitem) ){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendListitem(pl_listitems[i].listitem, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if ( ischosen(pl_listitems[i].iterator) ){
|
| f_EPTF_UIHandler_Config_processListitemiterator(pl_listitems[i], pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if ( ischosen(pl_listitems[i].externalvalue) ){
|
| f_EPTF_UIHandler_Config_processListitemiterator(pl_listitems[i], pl_parentIdx, true, pl_widgetExists);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_listitems[i]));
|
| vl_ret := false;
|
| }
|
| }
|
| return vl_ret;
|
| }
|
| private function f_EPTF_UIHandler_appendListitem(
|
| inout Listitem pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| return -1 != f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| wtListitem,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {listitem := f_EPTF_UIHandler_deleteChildrenFromListitem(pl_xul)}, false}, pl_widgetExists);
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendNumericalwidget(
|
| inout Numericalwidget pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| var template Widgettype vt_widgetType;
|
| select( pl_xul.widgetType )
|
| {
|
| case ( floatField )//Note: floatField of Numericalwidgettype
|
| {
|
| vt_widgetType := floatField //Note: floatField of Widgettype
|
| }
|
| case (integerField)
|
| {
|
| vt_widgetType := integerField //Note: integerField of Widgettype
|
| }
|
| case else
|
| {
|
| vt_widgetType := omit
|
| }
|
| }
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| if( -1 != f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtNumericalwidget,
|
| valueof(vt_widgetType),
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {numericalwidget := f_EPTF_UIHandler_deleteChildrenFromNumericalwidget(pl_xul)}, false}, pl_widgetExists)){
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return true;
|
| }else{
|
| return false;
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendMenulist(
|
| inout Menulist pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtMenulist,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {menulist := f_EPTF_UIHandler_deleteChildrenFromMenulist(pl_xul)}, false}, pl_widgetExists)
|
| if(-1 < vl_idx ){
|
| var boolean vl_ret;
|
| if(ispresent(pl_xul.menupopup.choice.menuitemgroups)){
|
| vl_ret := f_EPTF_UIHandler_appendMenuitemGroups(pl_xul.menupopup.choice.menuitemgroups.menuitemgroup_list, vl_idx, pl_widgetExists);
|
| } else {
|
| if(ispresent(pl_xul.menupopup.choice.externaldata_list)){
|
| if(sizeof(pl_xul.menupopup.choice.externaldata_list) == 1){
|
| var Menuitemgroups.menuitemgroup_list vl_menuitemgroupList;
|
| // : what is this: f_EPTF_UIHandler_appendMenuitemGroupsFromExternalData ?
|
| vl_ret := f_EPTF_UIHandler_appendMenuitemGroupsFromExternalData(vl_menuitemgroupList,vl_id, pl_xul.menupopup.choice.externaldata_list[0], vl_idx, pl_widgetExists);
|
| vl_ret := f_EPTF_UIHandler_appendMenuitemGroups(vl_menuitemgroupList, vl_idx, pl_widgetExists);
|
| pl_xul.menupopup.choice := { menuitemgroups := { vl_menuitemgroupList } }
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Only one externaldata is allowed: "&log2str(pl_xul.menupopup));
|
| vl_ret := false;
|
| }
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_xul.menupopup));
|
| vl_ret := false;
|
| }
|
| }
|
|
|
|
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, vl_id);
|
| pl_xul.externaldata := omit;
|
| }
|
| return vl_ret;
|
| }
|
| return false;
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendMenuitemGroups(
|
| inout Menuitemgroups.menuitemgroup_list pl_menuitems,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var boolean vl_ret := true;
|
| var integer vl_menuitems_size := sizeof(pl_menuitems);
|
| for(var integer i := 0; i < vl_menuitems_size and vl_ret; i := i + 1 ){
|
| if ( ischosen(pl_menuitems[i].menuitem) ){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendMenuitem(pl_menuitems[i].menuitem, pl_parentIdx, pl_widgetExists);
|
| }
|
| else if ( ischosen(pl_menuitems[i].iterator) ){
|
| f_EPTF_UIHandler_Config_processMenuitemiterator(pl_menuitems[i], pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if ( ischosen(pl_menuitems[i].externalvalue) ){
|
| f_EPTF_UIHandler_Config_processMenuitemiterator(pl_menuitems[i], pl_parentIdx, true, pl_widgetExists);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_menuitems[i]));
|
| vl_ret := false;
|
| }
|
| }
|
| return vl_ret;
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendMenuitemGroupsFromExternalData(
|
| out Menuitemgroups.menuitemgroup_list pl_xul,
|
| in charstring pl_widgetId, //menulist id
|
| inout Datadescription pl_datadescription,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_xul := {};
|
| var boolean vl_bool:=false;
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Started on : " & log2str(pl_datadescription));
|
| }
|
| // Ask the UIHandler about the datasource, then send him the question.
|
| var EPTF_DataSource_Params vl_dataparamList:= {};
|
| var charstring vl_varName := "";
|
| if(ispresent(pl_datadescription.params)){
|
| for(var integer i := 0; i < sizeof(pl_datadescription.params.dataparam_list); i := i + 1 ){
|
| var integer vl_dataParamsSize := sizeof(vl_dataparamList);
|
| vl_dataparamList[vl_dataParamsSize].paramName := f_unichar2charstr(pl_datadescription.params.dataparam_list[i].name); // FIXME
|
| vl_dataparamList[vl_dataParamsSize].paramValue := f_unichar2charstr(pl_datadescription.params.dataparam_list[i].value_);
|
| }
|
| }
|
| var charstring vl_source := f_unichar2charstr(pl_datadescription.source);
|
|
|
| var charstring vl_ptcname := "";
|
| if(ispresent(pl_datadescription.ptcname)){ vl_ptcname := f_unichar2charstr(pl_datadescription.ptcname)}
|
|
|
| var charstring vl_element := f_unichar2charstr(pl_datadescription.element);
|
|
|
| var EPTF_UIHandler_GuiItemRec vl_widgetRec;
|
| var EPTF_Var_DirectContent vl_defaultValue;
|
| f_EPTF_UIHandler_getWidgetRec(pl_widgetId, vl_widgetRec)
|
| f_EPTF_UIhandler_simulation_getDefaultValue(vl_widgetRec, vl_defaultValue);
|
|
|
| if(f_EPTF_UIHandler_simulation_getData( vl_varName,
|
| vl_source,
|
| vl_ptcname,
|
| vl_element,
|
| vl_dataparamList,
|
| -,
|
| -,
|
| vl_defaultValue ) == 0 ){
|
| var integer vl_varId := f_EPTF_Var_getId(vl_varName);
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": widgetId: " & log2str(pl_widgetId) & " varId: " & log2str(vl_varId));
|
| }
|
|
|
| var EPTF_Var_DirectContent vl_currentContent;
|
| f_EPTF_Var_getContent(vl_varId, vl_currentContent);
|
| for (var integer i:=0; i<sizeof(vl_currentContent.charstringlistVal); i:=i+1) {
|
| pl_xul[i].menuitem.id := pl_widgetId & "." & vl_currentContent.charstringlistVal[i];
|
| pl_xul[i].menuitem.label_ := vl_currentContent.charstringlistVal[i];
|
| pl_xul[i].menuitem.selected := false;
|
| pl_xul[i].menuitem.externaldata := omit;
|
| }
|
| var integer vl_idx := f_EPTF_UIHandler_widgetRecIndex(pl_widgetId);
|
| f_EPTF_Var_addPostProcFn(vl_varId, {refers(f_EPTF_UIHandler_updateMenulistItemsFromExternaldata), {vl_idx}});
|
|
|
| vl_bool := true;
|
| } else {
|
| f_EPTF_UIHandler_error(%definitionId&": Configuration error : Invalid dataSource parameters: \n"&
|
| "\nSource: "&vl_source&
|
| "\nPTC : "&vl_ptcname &
|
| "\nData Name : " &vl_element&
|
| "\nParams:" & log2str(vl_dataparamList)&
|
| "\nCheck the warnings above for more info.");
|
| }
|
| return vl_bool;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_updateMenulistItemsFromExternaldata
|
| //
|
| // Purpose:
|
| //
|
| //
|
| // Parameters:
|
| // pl_idx - *in* *integer* - EPTF Variable index
|
| // pl_argList - *in* <EPTF_IntegerList> - argument list - widgetRecIdx for the menulist
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_UIHandler_updateMenulistItemsFromExternaldata(in integer pl_idx, in EPTF_IntegerList pl_argList)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if(v_UIHandler_createGUIRunning){
|
| var integer vl_sizeof_postPonedPostProc := sizeof(v_UIHandler_postponedPostProcDB);
|
| var boolean vl_found := false;
|
| for (var integer i:=0; i< vl_sizeof_postPonedPostProc; i:=i+1) {
|
| if(v_UIHandler_postponedPostProcDB[i].idx == pl_idx and v_UIHandler_postponedPostProcDB[i].argList == pl_argList){
|
| vl_found := true;
|
| }
|
| }
|
|
|
| if(not vl_found){
|
| v_UIHandler_postponedPostProcDB[sizeof(v_UIHandler_postponedPostProcDB)] := {pl_idx, pl_argList};
|
| }
|
|
|
| return;
|
| }
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("Update menu items from variable : " & log2str(pl_idx) & " args: " & log2str(pl_argList));
|
| }
|
|
|
| var integer vl_size := sizeof(v_UIHandler_guiItemList[pl_argList[0]].children)
|
| var EPTF_CharstringList vl_list;
|
| for (var integer i:=0; i<vl_size; i:=i+1) {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("Remove menuitems from menulist: " & log2str(v_UIHandler_guiItemList[v_UIHandler_guiItemList[pl_argList[0]].children[i]].id));
|
| }
|
| vl_list[i] := v_UIHandler_guiItemList[v_UIHandler_guiItemList[pl_argList[0]].children[i]].id;
|
| }
|
| for (var integer i:=0; i<vl_size; i:=i+1) {
|
| f_EPTF_UIHandler_removeElementFromGui(vl_list[i]);
|
| }
|
|
|
| var integer vl_subsIdx := f_EPTF_UIHandler_getSubscriptionIdxByWidgetId(v_UIHandler_guiItemList[pl_argList[0]].id);
|
| if(-1 != vl_subsIdx){
|
| var EPTF_Var_DirectContent vl_content;
|
| f_EPTF_Var_getContent(v_UIHandler_openSubscriptions[vl_subsIdx].varIdx, vl_content);
|
| if(ischosen(vl_content.charstringVal)){
|
| vl_content := {charstringVal := ""};
|
| } else if(ischosen(vl_content.intVal)){
|
| vl_content := {intVal := 0};
|
| } else {
|
| vl_content := {charstringVal := ""};
|
| }
|
| f_EPTF_Var_adjustContent(v_UIHandler_openSubscriptions[vl_subsIdx].varIdx, vl_content);
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": No variable is added to the widget: "&log2str(v_UIHandler_guiItemList[pl_argList[0]].id));
|
| }
|
|
|
|
|
| var EPTF_Var_DirectContent vl_currentContent;
|
| f_EPTF_Var_getContent(pl_idx, vl_currentContent);
|
| var Menuitemgroups.menuitemgroup_list vl_menuitemgroupList := {};
|
| for (var integer i:=0; i<sizeof(vl_currentContent.charstringlistVal); i:=i+1) {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("Add menuitem to menulist: " & log2str(vl_currentContent.charstringlistVal[i]));
|
| }
|
| vl_menuitemgroupList[i].menuitem.id := v_UIHandler_guiItemList[pl_argList[0]].id & "." & vl_currentContent.charstringlistVal[i];
|
| vl_menuitemgroupList[i].menuitem.label_ := vl_currentContent.charstringlistVal[i];
|
| vl_menuitemgroupList[i].menuitem.selected := false;
|
| vl_menuitemgroupList[i].menuitem.externaldata := omit;
|
| }
|
| var boolean vl_widgetExists;
|
| var boolean vl_ret := f_EPTF_UIHandler_appendMenuitemGroups(vl_menuitemgroupList, pl_argList[0], vl_widgetExists);
|
|
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(v_UIHandler_guiItemList[pl_argList[0]].id);
|
| }
|
| for (var integer i:=0; i<sizeof(vl_currentContent.charstringlistVal); i:=i+1) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleAddElementToGUI(v_UIHandler_guiItemList[pl_argList[0]].id, { menuitem := vl_menuitemgroupList[i].menuitem}));
|
| }
|
|
|
| if(vl_ret == false){
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(vl_menuitemgroupList));
|
| }
|
|
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendMenuitem(
|
| inout Menuitem pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| return -1 != f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| wtMenuitem,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {menuitem := f_EPTF_UIHandler_deleteChildrenFromMenuitem(pl_xul)}, false}, pl_widgetExists);
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendDistributionchart(
|
| inout Distributionchart pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(pl_xul.id);
|
| var integer vl_idx := f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtDistributionchart,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {distributionchart := f_EPTF_UIHandler_deleteChildrenFromDistributionchart(pl_xul)}, false}, pl_widgetExists)
|
|
|
| if(-1 < vl_idx and not pl_widgetExists){
|
| var boolean vl_ret := true;
|
| var integer i:=0;
|
| while ( isbound(pl_xul.externaldatagroups.externaldatagroup_list) and (i < sizeof(pl_xul.externaldatagroups.externaldatagroup_list)) and vl_ret )
|
| {
|
| if (ischosen(pl_xul.externaldatagroups.externaldatagroup_list[i].intervallimits)){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendIntervallimits(pl_xul.externaldatagroups.externaldatagroup_list[i].intervallimits, vl_idx, pl_widgetExists);
|
| }
|
| else if (ischosen(pl_xul.externaldatagroups.externaldatagroup_list[i].valuelist_list)){
|
| for(var integer j := 0; j <sizeof(pl_xul.externaldatagroups.externaldatagroup_list[i].valuelist_list); j := j + 1) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendValuelist(pl_xul.externaldatagroups.externaldatagroup_list[i].valuelist_list[j], vl_idx, pl_widgetExists);
|
| }
|
| }
|
| else if (ischosen(pl_xul.externaldatagroups.externaldatagroup_list[i].iterator)){
|
| f_EPTF_UIHandler_Config_processValueListiterator(pl_xul.externaldatagroups.externaldatagroup_list[i], pl_xul, vl_idx, true, pl_widgetExists)
|
| }
|
| else if (ischosen(pl_xul.externaldatagroups.externaldatagroup_list[i].externalvalue)){
|
| f_EPTF_UIHandler_Config_processValueListiterator(pl_xul.externaldatagroups.externaldatagroup_list[i], pl_xul, vl_idx, true, pl_widgetExists)
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Invalid element to be added: "&log2str(pl_xul.externaldatagroups.externaldatagroup_list[i]));
|
| vl_ret := false;
|
| }
|
| i := i + 1;
|
| }
|
| var integer vl_size := sizeof(pl_xul.externaldatagroups.externaldatagroup_list);
|
| for(var integer j := 0; j < vl_size; j := j + 1){
|
| if(ischosen(pl_xul.externaldatagroups.externaldatagroup_list[j].intervallimits)){
|
| var Externaldatagroup temp:= pl_xul.externaldatagroups.externaldatagroup_list[0];
|
| pl_xul.externaldatagroups.externaldatagroup_list[0] := pl_xul.externaldatagroups.externaldatagroup_list[j];
|
| pl_xul.externaldatagroups.externaldatagroup_list[j] := temp;
|
| }
|
| }
|
| return vl_ret;
|
| }
|
| return false;
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendIntervallimits(
|
| inout Intervallimits pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var EPTF_FloatList vl_floatList := {};
|
| if(ispresent(pl_xul.choice.value_list)){
|
| for ( var integer i := 0; i < sizeof(pl_xul.choice.value_list) ; i := i+1 ) {
|
| vl_floatList[i] := pl_xul.choice.value_list[i];
|
| }
|
| }
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var integer vl_exit:= f_EPTF_UIHandler_addWidgetRec({
|
| /*id*/ f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| /*widgetType*/ wtIntervallimits,
|
| /*widgetDataType*/ omit,
|
| /*parentIdx*/ pl_parentIdx,
|
| /*children*/ {},
|
| /*widgetData*/ {distChartData := {intervallimits := vl_floatList}},
|
| /*XULformat*/ omit,
|
| /*xuldisabled*/ false}, pl_widgetExists);
|
|
|
| if(ispresent(pl_xul.choice.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.choice.externaldata, f_EPTF_UIHandler_unichar2charstring(pl_xul.id));
|
| pl_xul.choice.externaldata := {};
|
| }
|
| return -1 != vl_exit;
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendValuelist(
|
| inout Valuelist pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| var Valuelist vl_xul := pl_xul;
|
| vl_xul.externaldata := omit;
|
| var integer vl_exit:= f_EPTF_UIHandler_addWidgetRec({
|
| /*id*/ f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| /*widgetType*/ wtValuelist,
|
| /*widgetDataType*/ omit,
|
| /*parentIdx*/ pl_parentIdx,
|
| /*children*/ {},
|
| /*widgetData*/ omit,
|
| /*XULformat*/ {valuelist := vl_xul}, // external data removed from vl_xul
|
| /*xuldisabled*/ false}, pl_widgetExists);
|
|
|
| if(ispresent(pl_xul.externaldata)){
|
| f_EPTF_UIHandler_Config_processExternalData(pl_xul.externaldata, f_EPTF_UIHandler_unichar2charstring(pl_xul.id));
|
| pl_xul.externaldata := omit;
|
| }
|
| return -1 != vl_exit;
|
| }
|
|
|
| private function f_EPTF_UIHandler_appendImage(
|
| inout Image pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| return -1 != f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| wtImage,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {image := pl_xul}, false}, pl_widgetExists);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendSeparator
|
| //
|
| // Purpose:
|
| // before sending XTDP_AddRequests out this function appends the described widget and its children to the GUI item list
|
| //
|
| // Parameters:
|
| // pl_xul - *in* <Separator> - possible Separator item
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendSeparator(
|
| in ttcn_ericsson_se_protocolModules_xtdp_xtdl.Separator pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| pl_xul.id := f_EPTF_UIHandler_setWidgetID(pl_xul.id);
|
| return -1 != f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(pl_xul.id),
|
| wtSeparator,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {separator := f_EPTF_UIHandler_deleteChildrenFromSeparator(pl_xul)}, false}, pl_widgetExists);
|
| }
|
| } //EPTF_WidgetAddInternalFunctions group
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_requestLayout
|
| //
|
| // Purpose:
|
| // Sends a layoutRequest message to the RuntimeGUI and
|
| // builds the database of the widgets by the response
|
| //
|
| // Detailed Comments:
|
| // It should be called only once, after connecting to a GUI
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_requestLayout()
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if (not v_UIHandler_initialized){ return false }
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_layoutRequest);
|
|
|
| var boolean vl_widgetExists := false;
|
|
|
| if(f_EPTF_Semaphore_waitForUnlock(v_UIHandler_layoutResponseReceivedSemaphore, tsp_EPTF_UIHandler_maxWaitTimer))
|
| {
|
| f_EPTF_UIHandler_warning("Timer timeout! No layout response received!");
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| v_UIHandler_layoutResponseReceivedSemaphore := f_EPTF_Semaphore_new();
|
| return false;
|
| }
|
| v_UIHandler_layoutResponseReceivedSemaphore := f_EPTF_Semaphore_new();
|
| //f_EPTF_Semaphore_lock(v_UIHandler_layoutResponseReceivedSemaphore);
|
|
|
| if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_LayoutResponse.widgets.window))
|
| {
|
| if(not f_EPTF_UIHandler_appendAllWidgetIdsFromXul(v_UIHandler_receivedMessage.choice.xTDP_LayoutResponse.widgets, v_UIHandler_windowIndex, vl_widgetExists))
|
| {
|
| f_EPTF_UIHandler_warning("There was an error during processing the layout response.");
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| return false;
|
| }
|
| }
|
| else
|
| {
|
| f_EPTF_UIHandler_warning("Unexpected XTDP LayoutResponse (not xtdp_window)!");
|
| }
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| return true;
|
| }
|
|
|
| type enumerated EPTF_UIHandler_connectionResult
|
| {
|
| connected(0),
|
| connectFailed,
|
| temporarilyUnavailable
|
| };
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_connectAndInitGui
|
| //
|
| // Purpose:
|
| // function to connect to GUI
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // boolean
|
| //
|
| // Errors:
|
| // Common error possibilities
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_connectAndInitGui(out ConnectionId pl_clientId)
|
| runs on EPTF_UIHandler_Private_CT
|
| return EPTF_UIHandler_connectionResult
|
| {
|
| pl_clientId := -1;
|
| if(v_EPTF_UIHandler_servermode){
|
| return connected;
|
| }
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("****ConnectGUI****");
|
| }
|
| if (v_UIHandler_guiConnected) {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("****ConnectGUI: already connected****");
|
| }
|
| return connected;
|
| }
|
| var Result vl_result
|
| f_EPTF_Transport_connect(
|
| IPL4, {tcp := {}}, c_ipv4AnyAddr, c_anyPort, v_UIHandler_GUI_Host, v_UIHandler_GUI_Port, c_EPTF_UIHandler_XTDPType, vl_result, true)
|
| if(ispresent(vl_result.connId))
|
| {
|
| pl_clientId := vl_result.connId;
|
| if(-1 == vl_result.connId)
|
| {
|
| f_EPTF_UIHandler_warning("----- CLL_UIHandler connecting to GUI failed ----");
|
| //f_EPTF_Base_stopAll();
|
| f_EPTF_UIHandler_headlessmode();
|
| return connectFailed;
|
| } else if (ispresent(vl_result.errorCode) and vl_result.errorCode==ERROR_TEMPORARILY_UNAVAILABLE) {
|
| f_EPTF_UIHandler_headlessmode();
|
| return temporarilyUnavailable;
|
| }
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&log2str("***Connected on socket: ", vl_result.connId));
|
| }
|
| // I am XTDP-session server => nothing to do here:
|
| // var charstring vl_handshakeError:=f_EPTF_UIHandler_handshake(vl_result.connId);
|
| // if (vl_handshakeError!="") {
|
| // // handshake unsuccessful
|
| // return false;
|
| // }
|
| // if (not f_EPTF_UIHandler_authclient(vl_result.connId))
|
| // {
|
| // f_EPTF_UIHandler_closeXTDPSession(vl_result.connId);
|
| // return false;
|
| // }
|
| f_EPTF_UIHandler_addclientid(vl_result.connId);
|
| // v_UIHandler_guiConnected := true;
|
| return connected;
|
| }
|
| else
|
| {
|
| f_EPTF_UIHandler_warning(log2str("----- CLL_UIHandler Unsuccessful attempt to connect. You can set the IP address and port with the module pars. tsp_xtdp_listen_addr:tsp_xtdp_listen_port Client address:",v_UIHandler_GUI_Host,":", v_UIHandler_GUI_Port," with answer: ", vl_result));
|
| f_EPTF_UIHandler_headlessmode();
|
| //f_EPTF_Base_stopAll();
|
| return connectFailed;
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_closeXTDPSession(in integer pl_clientId) runs on EPTF_UIHandler_Private_CT {
|
| var Result vl_result
|
| if (f_EPTF_UIHandler_getClientHandshakeSuccessful(pl_clientId)) {
|
| // only close session if handshake was successful
|
| v_UIHandler_lastRequest := v_UIHandler_lastRequest +1;
|
| v_UIHandler_byeTimer := f_EPTF_Semaphore_new();
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message vl_messageToSend :=
|
| {
|
| v_UIHandler_byeTimer+1000*v_UIHandler_lastRequest,
|
| {xTDP_Bye := ""}
|
| }
|
|
|
| f_EPTF_Transport_send(IPL4, pl_clientId, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false)
|
| //f_EPTF_Transport_send(IPL4, pl_clientId, char2oct("bye\r\n"), vl_result, false);
|
|
|
| if (f_EPTF_Semaphore_waitForUnlock(v_UIHandler_byeTimer,v_byeMaxTime)) {
|
| // max wait time expired before response received:
|
| //v_byeErrorMsg := "Error: UIHandler: Communication error: No response received for Handshake request"
|
| f_EPTF_UIHandler_warning("Communication error: No response received for Bye message");
|
| }
|
| v_UIHandler_byeTimer := -1;
|
| }
|
| f_EPTF_UIHandler_delclientid(pl_clientId);
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": XTDP session is closed for client: "&log2str(pl_clientId));
|
| }
|
| if (sizeof(v_UIHandler_GUIClientId) == 0)
|
| {
|
| f_EPTF_UIHandler_headlessmode();
|
| }
|
| f_EPTF_Transport_close(IPL4, pl_clientId, vl_result)
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getGUIAddrPorts
|
| //
|
| // Purpose:
|
| // function to get address, port and reconnect port of the GUI to connect.
|
| //
|
| // Parameters:
|
| // pl_host - *out* *charstring* - the hostname of the GUI
|
| // pl_port - *out* *integer* - the port number of then GUI
|
| // pl_reconnectPort - *out* *integer* - the reconnect port number of then GUI
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_getGUIAddrPorts(out charstring pl_host, out integer pl_port, out integer pl_reconnectPort)
|
| runs on EPTF_UIHandler_Private_CT {
|
| pl_host := v_UIHandler_GUI_Host;
|
| pl_port := v_UIHandler_GUI_Port;
|
| pl_reconnectPort := v_UIHandler_udp_port;
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_setGUIAddrPorts
|
| //
|
| // Purpose:
|
| // function to set address , port and reconnect port of the GUI to connect.
|
| //
|
| // Parameters:
|
| // pl_host - *in* *charstring* - optional - the hostname of the GUI
|
| // pl_port - *in* *integer* - optional - the port number of then GUI
|
| // pl_reconnectPort - *in* *integer* - optional - the reconnect port number of then GUI
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Gives an opportunity to set the address of the GUI from code
|
| // beside the tsp way. It must be called after the f_EPTF_UIhandler_init_CT.
|
| // It will close the connections and make way to have new connections.
|
| // If neither of the pl_host and the pl_port parameters are given, all connection are closed and no GUI
|
| // connection is allowed until this function is called again.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_setGUIAddrPorts(in charstring pl_host := "", in integer pl_port := -1, in integer pl_reconnectPort := -1)
|
| runs on EPTF_UIHandler_Private_CT {
|
| if (not v_UIHandler_initialized){ return }
|
| var ConnectionId vl_connId := -1;
|
| var boolean vl_UIHandler_transportConnectionFailed := false;
|
| var boolean v_UIHandler_guiConnectedWasTrue := false;
|
|
|
| if(v_UIHandler_guiConnected == true){
|
| for (var integer i := 0; i<sizeof(v_UIHandler_GUIClientId); i:= i+1)
|
| {
|
| f_EPTF_UIHandler_closeXTDPSession(v_UIHandler_GUIClientId[i].clientId);
|
| //var Result vl_result
|
| //f_EPTF_Transport_send(IPL4, v_UIHandler_GUIClientId[i], char2oct("bye\r\n"), vl_result, false)
|
| }
|
| v_UIHandler_guiConnectedWasTrue := true;
|
| }
|
| if(pl_reconnectPort > -1){
|
| f_EPTF_UIHandler_setGuiReconnectPort( pl_reconnectPort );
|
| }
|
|
|
| if(pl_host == "" and pl_port == -1){
|
| v_UIHandler_GUI_Host := pl_host;
|
| v_UIHandler_GUI_Port := pl_port;
|
| f_EPTF_UIHandler_warning(%definitionId&": Neither of the pl_host and the pl_port parameters is used! Please specify at least one. Until this, all connections are closed and the GUI is not able to connect to the application! ");
|
| return;
|
| }
|
|
|
| if(pl_host != ""){
|
| v_UIHandler_GUI_Host := pl_host;
|
| }
|
| if(pl_port > -1){
|
| v_UIHandler_GUI_Port := pl_port;
|
| }
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": The following values are set: " & pl_host &":" & log2str(pl_port));
|
| }
|
|
|
| if(v_UIHandler_guiConnectedWasTrue == true){
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Trying to make the connection. ");
|
| }
|
|
|
| var EPTF_UIHandler_connectionResult vl_res := f_EPTF_UIHandler_connectAndInitGui(vl_connId);
|
| if(connected != vl_res){
|
| if (v_EPTF_UIHandler_headlessmode) {
|
| // connect to GUI failed -> switch to headless mode
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("initGUI failed, switch to headless mode");
|
| }
|
| f_EPTF_UIHandler_headlessmode();
|
| vl_UIHandler_transportConnectionFailed := vl_res != temporarilyUnavailable;
|
| } else {
|
| // connecting to GUI failed and headless mode not enabled -> stop running
|
| f_EPTF_UIHandler_error("initGUI failed!");
|
| }
|
| }
|
| } else if (v_EPTF_UIHandler_headlessmode) {
|
| // headless mode enabled -> switch to headless mode
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug("UIHandler started in headless mode");
|
| }
|
| f_EPTF_UIHandler_headlessmode();
|
| } else {
|
| // uncorrect starrtup configuration: client mode, not to connect to GUI, headless mode disabled -> stop running
|
| f_EPTF_UIHandler_error("Uncorrect UIHandler configuration for startup: client mode, not to connect to GUI, headless mode disabled");
|
| }
|
| if ((v_UIHandler_guiConnected and not v_EPTF_UIHandler_servermode) and not vl_UIHandler_transportConnectionFailed) {
|
| timer t_wait_for_connectGUI := 0.0;
|
| timer t_max_wait_for_connectGUI := tsp_EPTF_UIHandler_maxGUIWaitTime;
|
| t_max_wait_for_connectGUI.start;
|
| t_wait_for_connectGUI.start;
|
| alt {
|
| [v_UIHandler_guiConnected or (vl_connId != -1 and not f_EPTF_UIHandler_isConnectedClientid(vl_connId))] t_wait_for_connectGUI.timeout {
|
| // connection established, or lost
|
| }
|
| [] t_max_wait_for_connectGUI.timeout {
|
| f_EPTF_UIHandler_error("In client mode connecting to GUI on " & v_UIHandler_GUI_Host & ":" & log2str(v_UIHandler_GUI_Port) & " failed: Timeout during handshake&authentication. Please correct the tsp_xtdp_listen_addr / tsp_xtdp_listen_port parameter(s) in order to be able to connect to the RuntimeGUI! ");
|
| }
|
| }
|
| }
|
|
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_setGuiReconnectPort
|
| //
|
| // Purpose:
|
| // function to set the port of the GUI to reconnect.
|
| //
|
| // Parameters:
|
| // pl_reconnectPort - *in* *integer* - the reconnect port number of then GUI
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Gives an opportunity to set the reconnect port of the GUI from code
|
| // beside the tsp way. It must be called after the f_EPTF_UIhandler_init_CT.
|
| // If no parameter is given or the port is negative, reconnection of the GUI is disabled
|
| // until the f_EPTF_UIHandler_setPingerPort() function is called again.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_setGuiReconnectPort( in integer pl_reconnectPort := -1)
|
| runs on EPTF_UIHandler_Private_CT {
|
| if(pl_reconnectPort < 0){
|
| f_EPTF_UIHandler_warning(%definitionId&": Pinger port is deactivated, reconnection of the GUI is disabled!");
|
| }
|
| v_UIHandler_udp_port := pl_reconnectPort;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_setGuiHostPort
|
| //
|
| // Purpose:
|
| // function to set address of the GUI to connect.
|
| //
|
| // Parameters:
|
| // pl_host - *in* *charstring* the hostname of the GUI
|
| // pl_port - *in* *integer* the port number of then GUI
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Gives an opportunity to set the address of the GUI from code
|
| // beside the tsp way. It must be called before the f_EPTF_UIhandler_init_CT
|
| // to take effect.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_setGuiHostPort(in charstring pl_host, in integer pl_port)
|
| runs on EPTF_UIHandler_Private_CT {
|
| v_UIHandler_GUI_Host := pl_host;
|
| v_UIHandler_GUI_Port := pl_port;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_startserverxtdp
|
| //
|
| // Purpose:
|
| // function to start the XTDP port as server.
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_startserverxtdp() runs on EPTF_UIHandler_Private_CT
|
| {
|
| var Result vl_result
|
| f_EPTF_Transport_listen(
|
| IPL4, {tcp := {}}, c_ipv4AnyAddr, v_UIHandler_GUI_Port, c_EPTF_UIHandler_XTDPType, vl_result, true)
|
|
|
| if(ispresent(vl_result.connId))
|
| {
|
| // v_connectionDB.connList[sizeof(v_connectionDB.connList)] := {vl_result.connId};
|
| }
|
| else
|
| {
|
| f_EPTF_UIHandler_warning(log2str("Unsuccessful attempt to listen with answer: ", vl_result)); // kell f_EPTF_Base_stop();?
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_initguitoclient(in integer pl_clientid, in boolean pl_shadowedGui := false) runs on EPTF_UIHandler_Private_CT{
|
| if(v_UIHandler_createGUIRunning){
|
| //If createGUI is happening right now, we postpone the runtimegui init until creategui is done
|
| v_UIHandler_initToGUIClient := true;
|
| v_UIHandler_initGUIToClientList[sizeof(v_UIHandler_initGUIToClientList)] := {pl_clientid, pl_shadowedGui}
|
| } else {
|
| //No createGUI is happening right now, we do our job
|
| f_EPTF_UIHandler_initGuiToClientInner(pl_clientid, pl_shadowedGui);
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleInitGUIToClient
|
| //
|
| // Purpose:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleInitGUIToClient() runs on EPTF_UIHandler_Private_CT {
|
| []t_UIHandler_initGUIToClientTimer.timeout{
|
| for(var integer vl_i := 0; vl_i < sizeof(v_UIHandler_initGUIToClientList); vl_i:=vl_i+1){
|
| f_EPTF_UIHandler_initGuiToClientInner( v_UIHandler_initGUIToClientList[vl_i].pl_clientid, v_UIHandler_initGUIToClientList[vl_i].pl_shadowedGui)
|
| }
|
| v_UIHandler_initGUIToClientList := {};
|
| t_UIHandler_initGUIToClientTimer.start;
|
| v_UIHandler_initToGUIClient := false;
|
| repeat;
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_initGuiToClientInner(in integer pl_clientid, in boolean pl_shadowedGui := false) runs on EPTF_UIHandler_Private_CT{
|
| //This piece of code can run only in case of v_UIHandler_createGUIRunning == false and v_UIHandler_initToGUIClient == true with a 0.0 timer
|
| v_UIHandler_lastRequest := v_UIHandler_lastRequest +1;
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message vl_messageToSend :=
|
| {
|
| transactionID := v_UIHandler_lastRequest,
|
| choice :=
|
| {
|
| xTDP_RemoveRequests:=
|
| {
|
| xTDP_RemoveRequest_list := {
|
| {
|
| requestId := 1,
|
| widgetId := omit
|
| }
|
| }
|
| }
|
| }
|
| }
|
|
|
| var Result vl_result
|
| f_EPTF_Transport_send(IPL4, pl_clientid, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false)
|
|
|
| if (0 < sizeof(v_UIHandler_guiItemList))
|
| {
|
| var Widgets layout;
|
| f_EPTF_UIHandler_buildXUL(layout);
|
| if (pl_shadowedGui) {
|
| layout.window.title := layout.window.title & " - Shadowed GUI -";
|
| }
|
| v_UIHandler_lastRequest := v_UIHandler_lastRequest +1;
|
| vl_messageToSend :=
|
| {
|
| transactionID := v_UIHandler_lastRequest,
|
| choice :=
|
| {
|
| xTDP_AddRequests :=
|
| {
|
| xTDP_AddRequest_list := {
|
| {
|
| requestId := 2,
|
| parentWidgetId := omit,
|
| widgets := layout
|
| }
|
| }
|
| }
|
| }
|
| }
|
| f_EPTF_Transport_send(IPL4, pl_clientid, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false)
|
| }
|
| v_UIHandler_guiLayoutReady := true;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_updateguilist_refreshwidget
|
| //
|
| // Purpose:
|
| // At a widgetrefresh, it refreshes the inner database too.
|
| //
|
| // Parameters:
|
| // pl_widgetid - *in* <charstring> - Id of the widget
|
| // pl_arg - *in* <charstring> - the new value
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_updateguilist_refreshwidget(
|
| in charstring pl_widgetid,
|
| in EPTF_Var_DirectContent pl_dcontent)
|
| runs on EPTF_UIHandler_Private_CT{
|
| // if headless mode is not enabled don't refresh internal database
|
| if (not v_EPTF_UIHandler_headlessmode) {
|
| return;
|
| }
|
|
|
| var integer vl_index := f_EPTF_UIHandler_widgetRecIndex(pl_widgetid);
|
| if (vl_index==-1) {
|
| return;
|
| }
|
| select (v_UIHandler_guiItemList[vl_index].widgetType) {
|
| case(wtTextbox){
|
| var charstring pl_arg := f_EPTF_Var_directContent2str(pl_dcontent);
|
| v_UIHandler_guiItemList[vl_index].XULformat.textbox.value_ := pl_arg;
|
| }
|
| case(wtHtmlcode){
|
| var charstring pl_arg := f_EPTF_Var_directContent2str(pl_dcontent);
|
| v_UIHandler_guiItemList[vl_index].XULformat.htmlcode.value_ := pl_arg;
|
| }
|
| case (wtTreecell){
|
| var charstring pl_arg := f_EPTF_Var_directContent2str(pl_dcontent);
|
| select( v_UIHandler_guiItemList[vl_index].widgetDataType )
|
| {
|
| case ( statusLED )
|
| {
|
| // Cut the text part if statusLED requested
|
| var integer vl_i:=f_strstr(pl_arg,"]");
|
| if(0<vl_i) {
|
| pl_arg := substr(pl_arg,0,vl_i+1);
|
| }
|
| v_UIHandler_guiItemList[vl_index].XULformat.treecell.label_ := pl_arg;
|
| }
|
| case ( pushButton ){
|
| //nothing to refresh
|
| }
|
| case else
|
| {
|
| v_UIHandler_guiItemList[vl_index].XULformat.treecell.label_ := pl_arg;
|
| }
|
| }
|
| }
|
| case (wtLabel){
|
| var charstring pl_arg := f_EPTF_Var_directContent2str(pl_dcontent);
|
| v_UIHandler_guiItemList[vl_index].XULformat.label_.value_ := pl_arg;
|
| }
|
| case (wtListbox){
|
| var charstring pl_arg := f_EPTF_Var_directContent2str(pl_dcontent);
|
| var EPTF_IntegerList vl_children := f_EPTF_UIHandler_getNonMetaChildren(vl_index);
|
| for (var integer i:=0;i<sizeof(vl_children);i:=i+1){
|
| if (v_UIHandler_guiItemList[vl_children[i]].XULformat.listitem.label_ == pl_arg){
|
| v_UIHandler_guiItemList[vl_children[i]].XULformat.listitem.selected := true;
|
| } else {
|
| v_UIHandler_guiItemList[vl_children[i]].XULformat.listitem.selected := false;
|
| }
|
| }
|
| }
|
| case (wtMenulist){
|
| var charstring pl_arg := f_EPTF_Var_directContent2str(pl_dcontent);
|
| var EPTF_IntegerList vl_children := f_EPTF_UIHandler_getNonMetaChildren(vl_index);
|
| if (v_UIHandler_guiItemList[vl_index].XULformat.menulist.label_ == pl_arg or pl_arg==""){ // menulabel selected
|
| for (var integer i:=0;i<sizeof(vl_children);i:=i+1){
|
| v_UIHandler_guiItemList[vl_children[i]].XULformat.menuitem.selected := false;
|
| }
|
| return;
|
| }
|
| var boolean menuselected := false;
|
| for (var integer i:=0;i<sizeof(vl_children);i:=i+1){ // test if menuitem selected
|
| if (v_UIHandler_guiItemList[vl_children[i]].XULformat.menuitem.label_ == pl_arg){
|
| v_UIHandler_guiItemList[vl_children[i]].XULformat.menuitem.selected := true;
|
| menuselected := true;
|
| } else {
|
| v_UIHandler_guiItemList[vl_children[i]].XULformat.menuitem.selected := false;
|
| }
|
| }
|
|
|
| if (not menuselected and v_UIHandler_guiItemList[vl_index].XULformat.menulist.editable == true){// if not menuitem nor menulabel,than its a menulabel change
|
| v_UIHandler_guiItemList[vl_index].XULformat.menulist.label_ := pl_arg;
|
| }
|
| }
|
| case (wtNumericalwidget){
|
| var float pl_arg := 0.0;
|
| if(ischosen(pl_dcontent.intVal)){ // integerField
|
| pl_arg := int2float(pl_dcontent.intVal);
|
| } else if(ischosen(pl_dcontent.floatVal)) { //floatField
|
| pl_arg := pl_dcontent.floatVal;
|
| } else {return;}
|
| v_UIHandler_guiItemList[vl_index].XULformat.numericalwidget.value_ := pl_arg;
|
| }
|
| case (wtValuelist){
|
| if (ischosen(pl_dcontent.integerlistVal)){
|
| v_UIHandler_guiItemList[vl_index].XULformat.valuelist.value_list := {};
|
| for (var integer i := 0;i<sizeof(pl_dcontent.integerlistVal);i:=i+1){
|
| v_UIHandler_guiItemList[vl_index].XULformat.valuelist.value_list[i] := pl_dcontent.integerlistVal[i];
|
| }
|
| }
|
| }
|
| case (wtIntervallimits){
|
| if (ischosen(pl_dcontent.floatlistVal)){
|
| v_UIHandler_guiItemList[vl_index].widgetData.distChartData.intervallimits := {};
|
| for (var integer i := 0;i<sizeof(pl_dcontent.floatlistVal);i:=i+1){
|
| v_UIHandler_guiItemList[vl_index].widgetData.distChartData.intervallimits[i] := pl_dcontent.floatlistVal[i];
|
| }
|
| }
|
| }
|
| case else { }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_refreshWidget
|
| //
|
| // Purpose:
|
| // Refreshes the content specified by the subscription
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_refreshWidget(in EPTF_UIHandler_OpenSubscription pl_subs, in boolean pl_init := false,
|
| in EPTF_Var_DirectContent pl_currentContent := {unknownVal:={omit}})
|
| runs on EPTF_UIHandler_Private_CT {
|
| if (pl_subs.widgetId == "") {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Widget with empty ID cannot be refreshed!");
|
| }
|
| return;
|
| }
|
| var EPTF_Var_TimeLine vl_timeLine;
|
| f_EPTF_Var_getTimeLine(pl_subs.varIdx,vl_timeLine);
|
| if(0 == vl_timeLine.size and not
|
| (pl_init or f_EPTF_Var_checkSubscriptionMode(pl_subs.varIdx,realtime))){
|
| return;
|
| }
|
| var EPTF_Var_DirectContent vl_currentContent;
|
| if(pl_init or f_EPTF_Var_checkSubscriptionMode(pl_subs.varIdx,realtime)){
|
| if (ischosen(pl_currentContent.unknownVal)) {
|
| f_EPTF_Var_getContent(pl_subs.varIdx,vl_currentContent);
|
| } else {
|
| vl_currentContent := pl_currentContent;
|
| }
|
| }else{
|
| vl_currentContent := vl_timeLine.timeLineData[vl_timeLine.size-1].content;
|
| }
|
|
|
| select(pl_subs.widgetType){
|
| case(wtTrace){
|
|
|
| // create timeLine from current content (if timeLine is not available because of realTime subscription)
|
| var integer vl_iCount := vl_timeLine.size;
|
| if (vl_iCount == 0) {
|
| vl_iCount := 1;
|
| vl_timeLine.size := 1;
|
| vl_timeLine.timeLineData := {
|
| {
|
| timestamp := f_EPTF_Base_getAbsTimeInSecs(),
|
| content := vl_currentContent
|
| }
|
| };
|
| }
|
|
|
| if(0 < vl_iCount){ //Because of init
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Requests vl_requests := {omit, {c_UIHandler_XSD_emptyXTDPRequest}};
|
| var integer vl_size := 0;
|
| for(var integer vl_iTl := 0; vl_iTl < vl_iCount; vl_iTl := vl_iTl + 1){
|
| var charstring vl_stringVal;
|
| if (ischosen(vl_timeLine.timeLineData[vl_iTl].content.floatVal)) {
|
| vl_stringVal := float2str(vl_timeLine.timeLineData[vl_iTl].content.floatVal);
|
| } else if (ischosen(vl_timeLine.timeLineData[vl_iTl].content.intVal)) {
|
| vl_stringVal:= int2str(vl_timeLine.timeLineData[vl_iTl].content.intVal);
|
| }
|
| // ekovist 2012.03.09. - HO88979: EPTF CLL UIHandler: dynamic tc error in case of wrong datasource type used in xml
|
| if(isbound(vl_stringVal)) {
|
| var charstring vl_timelinepoint:= float2str(vl_timeLine.timeLineData[vl_iTl].timestamp) & "/"& vl_stringVal;
|
| v_UIHandler_lastRequest := v_UIHandler_lastRequest + 1;
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Request vl_request := valueof(ts_ASP_XTDP_traceItem(
|
| v_UIHandler_lastRequest,
|
| pl_subs.widgetId,
|
| vl_timelinepoint
|
| ));
|
| vl_requests.xTDP_Request_list[vl_size] := vl_request;
|
| vl_size := vl_size + 1;
|
| }
|
| else {
|
| f_EPTF_UIHandler_error("The specified "&pl_subs.widgetId&" widget can not be connected to variable (invalid type: required FLOAT or INT)!" );
|
| }
|
| }
|
| if (vl_iCount > 0 and vl_size>0){
|
| var integer vl_tracePointer;
|
| var integer vl_widgetIdx := f_EPTF_UIHandler_widgetRecIndex(pl_subs.widgetId);
|
| if(-1 < vl_widgetIdx) {
|
| if (not f_EPTF_int2int_HashMap_Find(v_UIHandler_tracePointerHashMapId, vl_widgetIdx, vl_tracePointer)){
|
| vl_tracePointer := sizeof(v_UIHandler_tracePointers);
|
| f_EPTF_int2int_HashMap_Insert(v_UIHandler_tracePointerHashMapId, vl_widgetIdx, vl_tracePointer);
|
| v_UIHandler_tracePointers[vl_tracePointer] := 0;
|
| }
|
|
|
| var integer vl_currTraceID := v_UIHandler_tracePointers[vl_tracePointer];
|
| v_UIHandler_guiItemList[vl_widgetIdx].XULformat.trace.choice_list[vl_currTraceID].xy_value.x :=
|
| vl_timeLine.timeLineData[vl_iCount-1].timestamp;
|
| if (ischosen(vl_timeLine.timeLineData[vl_iCount-1].content.floatVal)) {
|
| v_UIHandler_guiItemList[vl_widgetIdx].XULformat.trace.choice_list[vl_currTraceID].xy_value.y :=
|
| vl_timeLine.timeLineData[vl_iCount-1].content.floatVal;
|
| } else if (ischosen(vl_timeLine.timeLineData[vl_iCount-1].content.intVal)) {
|
| v_UIHandler_guiItemList[vl_widgetIdx].XULformat.trace.choice_list[vl_currTraceID].xy_value.y :=
|
| int2float(vl_timeLine.timeLineData[vl_iCount-1].content.intVal);
|
| } else {
|
| v_UIHandler_guiItemList[vl_widgetIdx].XULformat.trace.choice_list[vl_currTraceID].xy_value.y := 0.0;
|
| }
|
| vl_currTraceID := vl_currTraceID + 1;
|
| if (vl_currTraceID == v_UIHandler_guiItemList[vl_widgetIdx].XULformat.trace.maxPoints) {
|
| vl_currTraceID := 0;
|
| }
|
| v_UIHandler_tracePointers[vl_tracePointer] := vl_currTraceID;
|
| }
|
| else {
|
| f_EPTF_UIHandler_warning("There is no widget with name "&pl_subs.widgetId&" to refresh!");
|
| }
|
| }
|
| if (vl_size>0){
|
| for(var integer clientindex:=0;clientindex<sizeof(v_UIHandler_GUIClientId);clientindex := clientindex+1){
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_sendTimeline(v_UIHandler_GUIClientId[clientindex].clientId,vl_requests));
|
| }
|
| }
|
| }
|
| }
|
| case(wtTreecell){
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| vl_currentContent);
|
| if(ispresent(pl_subs.widgetDataType)) { // HN57133: case omit moved to else-branch
|
| select(pl_subs.widgetDataType){
|
| case(checkBox){
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToChkBox(pl_subs.widgetId,
|
| f_EPTF_Var_directContent2str(vl_currentContent)));
|
| }
|
| case(toggleButton){
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToTgglButton(pl_subs.widgetId,
|
| f_EPTF_Var_directContent2str(vl_currentContent)));
|
| }
|
| case(floatField){
|
| if (ischosen(vl_currentContent.floatVal)) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToFlt(pl_subs.widgetId, vl_currentContent.floatVal));
|
| } else {
|
| f_EPTF_UIHandler_error("The specified "&pl_subs.widgetId&" TREECELL widget can not be connected to variable (invalid type: required FLOAT)!" );
|
| }
|
| }
|
| case(integerField){
|
| if (ischosen(vl_currentContent.intVal)) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToInt(pl_subs.widgetId, vl_currentContent.intVal));
|
| } else {
|
| f_EPTF_UIHandler_error("The specified "&pl_subs.widgetId&" TREECELL widget can not be connected to variable (invalid type: required INT)!" );
|
| }
|
| }
|
| case(pushButton){
|
| //EGBOZIE: Pushbutton is not update-able!
|
| //f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToStr(pl_subs.widgetId,
|
| //f_EPTF_Var_directContent2str(vl_currentContent)));
|
| }
|
| case(statusLED){
|
| if (ischosen(vl_currentContent.statusLEDVal)) {
|
| var charstring vl_statusLedTxt := f_EPTF_Var_directContent2str(vl_currentContent);
|
| // Cut the text part if statusLED requested
|
| var integer vl_i:=f_strstr(vl_statusLedTxt,"]");
|
| if(0<vl_i) {
|
| vl_statusLedTxt := substr(vl_statusLedTxt,0,vl_i+1);
|
| }
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToLed(pl_subs.widgetId, vl_statusLedTxt ));
|
| } else {
|
| f_EPTF_UIHandler_error("The specified "&pl_subs.widgetId&" TREECELL widget can not be connected to variable (invalid type: required STATUSLED)!" );
|
| }
|
| }
|
| case(statusLEDWithText){
|
| if (ischosen(vl_currentContent.statusLEDVal)) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToLedWithText(pl_subs.widgetId,
|
| f_EPTF_Var_directContent2str(vl_currentContent)));
|
| } else {
|
| f_EPTF_UIHandler_error("The specified "&pl_subs.widgetId&" TREECELL widget can not be connected to variable (invalid type: required STATUSLED)!" );
|
| }
|
| }
|
| case(string){ // case omit -> else
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToStr(pl_subs.widgetId,
|
| f_EPTF_Var_directContent2str(vl_currentContent)));
|
| }
|
| case else { }
|
| }
|
| } else {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToStr(pl_subs.widgetId,
|
| f_EPTF_Var_directContent2str(vl_currentContent)));
|
| }
|
| }
|
| case (wtValuelist){
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| vl_currentContent);
|
| if (ischosen(vl_currentContent.integerlistVal)){
|
| var XTDP_Actions.choice.put.argument_list csl := {""};
|
| for (var integer i:=0; i<sizeof(vl_currentContent.integerlistVal);i:=i+1){
|
| csl[i] := int2str(vl_currentContent.integerlistVal[i])
|
| }
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueTovalueList(pl_subs.widgetId,
|
| csl));
|
| }
|
| }
|
| case (wtListbox){
|
| var integer index := f_EPTF_UIHandler_widgetRecIndex(pl_subs.widgetId);
|
| if (index != -1 and v_UIHandler_guiItemList[index].XULformat.listbox.seltype == multiple){
|
| var XTDP_Actions.choice.put.argument_list csl := {""};
|
| if (ischosen(vl_currentContent.integerlistVal)){
|
| var EPTF_IntegerList vl_children := f_EPTF_UIHandler_getNonMetaChildren(index);
|
| for (var integer i:=0;i<sizeof(vl_currentContent.integerlistVal);i:=i+1){
|
| //Here the f_EPTF_UIHandler_XULWidgetId2charstr is used simply to convert ustr to charstring
|
| csl[i]:= f_EPTF_UIHandler_XULWidgetId2charstr({v_UIHandler_guiItemList[vl_children[vl_currentContent.integerlistVal[i]]].XULformat.listitem.label_})
|
|
|
| }
|
| for (var integer i:=0; i<sizeof(csl);i:=i+1){
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| {charstringVal := unichar2char(csl[i])});
|
| }
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueTovalueList(pl_subs.widgetId,
|
| csl));
|
| }
|
|
|
| } else{
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| vl_currentContent);
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToStr(pl_subs.widgetId,
|
| f_EPTF_Var_directContent2str(vl_currentContent)));
|
| }
|
| }
|
| case (wtNumericalwidget){
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| vl_currentContent);
|
| select( pl_subs.widgetDataType )
|
| {
|
| case ( integerField)
|
| {
|
| if (ischosen(vl_currentContent.intVal)) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToNumericalwidget(pl_subs.widgetId,
|
| int2str(vl_currentContent.intVal)));
|
| } else {
|
| f_EPTF_UIHandler_error("The specified "&pl_subs.widgetId&" NUMERICAL widget can not be connected to variable (invalid type: required INT)!" );
|
| }
|
| }
|
| case ( floatField)
|
| {
|
| if (ischosen(vl_currentContent.floatVal)) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToNumericalwidget(pl_subs.widgetId,
|
| float2str(vl_currentContent.floatVal)));
|
| } else {
|
| f_EPTF_UIHandler_error("The specified "&pl_subs.widgetId&" NUMERICAL widget can not be connected to variable (invalid type: required FLOAT)!" );
|
| }
|
| }
|
| case else
|
| {//impossible, just in case
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToNumericalwidget(pl_subs.widgetId,
|
| f_EPTF_Var_directContent2str(vl_currentContent)));
|
| }
|
| }
|
| }
|
| case (wtButton){
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| vl_currentContent);
|
| //eistfal: Pushbutton is not update-able!
|
| //f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToStr(pl_subs.widgetId,
|
| //f_EPTF_Var_directContent2str(vl_currentContent)));
|
| // #eistfal: toggleButton is update-able, how to perform it?
|
| }
|
| case (wtPushbutton){
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| vl_currentContent);
|
| }
|
| case (wtTogglebutton){
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| vl_currentContent);
|
| }
|
| case else{ // connectd to single string variable
|
| //Default data handling
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(pl_subs.widgetId,
|
| vl_currentContent);
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleRqPutValueToStr(pl_subs.widgetId,
|
| f_EPTF_Var_directContent2str(vl_currentContent)));
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_parseGuiParam
|
| //
|
| // Purpose:
|
| // Parses a value as it is set by user on the GUI,
|
| // stores it in the connected variable
|
| //
|
| // Parameters:
|
| // pl_widgetID - *in* *EPTF_UIHandler_WidgetIdString* - widgetID to identify param
|
| // pl_arglist - *in* <EPTF_CharstringList> - new value to set
|
| //
|
| // Detailed Comments:
|
| // Uses <f_EPTF_UIHandler_parseParamValue> function
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_parseGuiParam(in EPTF_UIHandler_WidgetIdString pl_widgetID, in EPTF_CharstringList pl_arglist)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| var charstring vl_argument := "";
|
| if (sizeof(pl_arglist)!=0) {
|
| vl_argument := pl_arglist[0];
|
| }
|
|
|
| // look up param based on widgetID
|
| var integer vl_paramIdx := f_EPTF_UIHandler_getSubscriptionIdxByWidgetId(pl_widgetID);
|
|
|
| if (-1 == vl_paramIdx) {
|
| f_EPTF_UIHandler_warning(%definitionId&" Warning : there's no subscription to widgetID ("& pl_widgetID & ") referred by GUI");
|
| //f_EPTF_Base_stop();
|
| return;
|
| }
|
| if(wtButton == v_UIHandler_openSubscriptions[vl_paramIdx].widgetType
|
| or wtPushbutton == v_UIHandler_openSubscriptions[vl_paramIdx].widgetType
|
| or (wtTreecell == v_UIHandler_openSubscriptions[vl_paramIdx].widgetType
|
| and ispresent(v_UIHandler_openSubscriptions[vl_paramIdx].widgetDataType)
|
| and v_UIHandler_openSubscriptions[vl_paramIdx].widgetDataType == pushButton)
|
| ){
|
| var EPTF_Var_DirectContent vl_content;
|
| f_EPTF_Var_getContent(v_UIHandler_openSubscriptions[vl_paramIdx].varIdx, vl_content);
|
| if(ischosen(vl_content.intVal)){
|
| vl_content.intVal := vl_content.intVal + 1;
|
| f_EPTF_Var_adjustContent(v_UIHandler_openSubscriptions[vl_paramIdx].varIdx, vl_content);
|
| } else {
|
| f_EPTF_Var_refreshContent(v_UIHandler_openSubscriptions[vl_paramIdx].varIdx);
|
| }
|
| } else if(wtListbox == v_UIHandler_openSubscriptions[vl_paramIdx].widgetType){
|
| var integer recindex := f_EPTF_UIHandler_widgetRecIndex(v_UIHandler_openSubscriptions[vl_paramIdx].widgetId);
|
| if (recindex != -1 and v_UIHandler_guiItemList[recindex].XULformat.listbox.seltype == multiple){
|
| //var EPTF_UIHandler_XTDP_XML_TagList listitems := {};
|
| var integer k :=0
|
| var EPTF_IntegerList intlist := {};
|
| var EPTF_IntegerList vl_children := f_EPTF_UIHandler_getNonMetaChildren(recindex);
|
| for (var integer i:=0;i<sizeof(vl_children);i:=i+1){
|
| if (k<sizeof(pl_arglist) and v_UIHandler_guiItemList[vl_children[i]].XULformat.listitem.label_ ==
|
| pl_arglist[k]){
|
| k:=k+1;
|
| intlist[sizeof(intlist)] := i;
|
| }
|
| }
|
| f_EPTF_Var_adjustContent(v_UIHandler_openSubscriptions[vl_paramIdx].varIdx, {integerlistVal := intlist});
|
| }
|
|
|
| }else{
|
| if(not f_EPTF_UIHandler_parseParamValue(v_UIHandler_openSubscriptions[vl_paramIdx].varIdx,vl_argument)){
|
| f_EPTF_UIHandler_refreshWidget(v_UIHandler_openSubscriptions[vl_paramIdx]);
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleErrorResp(9999, vl_argument, requestor, illegalArgument, "ERROR: illegal input value at " & f_EPTF_Var_getName(v_UIHandler_openSubscriptions[vl_paramIdx].varIdx)));
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_updatesubscriptionsguilist
|
| //
|
| // Purpose:
|
| // Refreshes the content of the widgets connected to the specified variable.
|
| //
|
| // Parameters:
|
| // pl_varIdx - *in* *integer - The index of the variable.
|
| // pl_dcontent - *in* *EPTF_Var_DirectContent* - The new content.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_updatesubscriptionsguilist(
|
| in integer pl_varIdx,
|
| in EPTF_Var_DirectContent pl_dcontent)
|
| runs on EPTF_UIHandler_Private_CT {
|
| var EPTF_UIHandler_OpenSubscriptions vl_subs;
|
| if(f_EPTF_UIHandler_getSubscriptionsByVarIdx(pl_varIdx, vl_subs)){
|
| for(var integer vl_i := 0; vl_i < sizeof(vl_subs); vl_i := vl_i + 1){
|
| f_EPTF_UIHandler_updateguilist_refreshwidget(vl_subs[vl_i].widgetId,
|
| pl_dcontent);
|
| // f_EPTF_Var_directContent2str(pl_dcontent));
|
|
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_adjustContentResponseHandler
|
| //
|
| // Purpose:
|
| // Response handler callback function for Variable adjustContent.
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_adjustContentResponseHandler(
|
| in integer pl_idx,
|
| in EPTF_Var_DirectContent pl_content,
|
| in boolean pl_result,
|
| in EPTF_IntegerList pl_argList) runs on EPTF_UIHandler_Private_CT
|
| {
|
| if(not pl_result) { // guard function returned false
|
| var EPTF_UIHandler_OpenSubscriptions vl_subs;
|
| if(f_EPTF_UIHandler_getSubscriptionsByVarIdx(pl_idx, vl_subs)){
|
| for(var integer i := 0; i < sizeof(vl_subs); i := i + 1) {
|
| f_EPTF_UIHandler_refreshWidget(vl_subs[i],-,pl_content);
|
| }
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_parseParamValue
|
| //
|
| // Purpose:
|
| // Parses a charstring value and
|
| // stores it in the specified variable
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_parseParamValue(
|
| in integer pl_varIdx,
|
| in charstring pl_argument)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var EPTF_Var vl_parsedArgument;
|
| var EPTF_Var_DirectContent vl_content;
|
| f_EPTF_Var_getContent(pl_varIdx, vl_content);
|
| var boolean vl_ret := false;
|
| if (ischosen(vl_content.intVal)){
|
| var charstring vl_arg := f_EPTF_UIHandler_str2Integer(pl_argument);
|
| if(vl_arg != "") {
|
| vl_parsedArgument.content.direct.intVal := str2int(vl_arg);
|
| // detect user typos
|
| //if ((vl_parsedArgument.content.direct.intVal != 0) or (vl_arg == "0"))
|
| { // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| }
|
| }
|
| else if (ischosen(vl_content.integerlistVal))
|
| {
|
| // parse it
|
| vl_parsedArgument.content.direct.integerlistVal := f_EPTF_UIHandler_str2IntegerList(pl_argument);
|
| // detect user typos
|
| if ((sizeof(vl_parsedArgument.content.direct.integerlistVal) != 0) or (regexp(pl_argument, "\\s#(,)([0-9]+)\\s#(,)", 0) == ""))
|
| {
|
| // no typo, argument ok
|
| // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| }
|
| else if (ischosen(vl_content.floatlistVal))
|
| {
|
| // parse it
|
| vl_parsedArgument.content.direct.floatlistVal := f_EPTF_UIHandler_str2FloatList(pl_argument);
|
| // detect user typos
|
| if (sizeof(vl_parsedArgument.content.direct.floatlistVal) != 0) //: a regexp should be here??
|
| {
|
| // no typo, argument ok
|
| // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| }
|
| else if (ischosen(vl_content.octetstringVal))
|
| {
|
| // detect user typos
|
| if (regexp(pl_argument, "\\s#(,)([0-9a-fA-F]+)\\s#(,)", 0) != "")
|
| {
|
| // check if the length of pl_argument is odd
|
| var charstring vl_convertedOS := regexp(pl_argument, "\\s#(,)([0-9a-fA-F]+)\\s#(,)", 0);
|
| if ((lengthof(vl_convertedOS) mod 2) != 0) { vl_convertedOS := "0" & vl_convertedOS };
|
|
|
| vl_parsedArgument.content.direct.octetstringVal := str2oct(vl_convertedOS);
|
| // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| }
|
| else if (ischosen(vl_content.floatVal))
|
| {
|
| // detect user typos
|
| if (regexp(pl_argument, c_EPTF_CLI_floatNumber, 0) != "")
|
| {
|
| vl_parsedArgument.content.direct.floatVal := str2float(pl_argument);
|
| // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| }
|
| else if (ischosen(vl_content.boolVal))
|
| {
|
| vl_parsedArgument.content.direct.boolVal := f_EPTF_UIHandler_str2bool(pl_argument);
|
| // store
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| else if (ischosen(vl_content.bitstringVal))
|
| {
|
| // detect user typos
|
| if (regexp(pl_argument, "\\s#(,)([01]+)\\s#(,)", 0) != "")
|
| {
|
| vl_parsedArgument.content.direct.bitstringVal := str2bit(pl_argument);
|
| // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| }
|
| else if (ischosen(vl_content.hexstringVal))
|
| {
|
| // detect user typos
|
| if (regexp(pl_argument, "\\s#(,)([0-9a-fA-F]+)\\s#(,)", 0) != "")
|
| {
|
| vl_parsedArgument.content.direct.hexstringVal := str2hex(pl_argument);
|
| // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| }
|
| else if (ischosen(vl_content.charstringVal))
|
| {
|
| vl_parsedArgument.content.direct.charstringVal := pl_argument;
|
| // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct,
|
| {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| else if (ischosen(vl_content.statusLEDVal))
|
| {
|
| // parse statusled string
|
| const charstring cl_ledStart := "[led:";
|
| const charstring cl_ledEnd := "]";
|
| var charstring vl_ledColor := f_substr_token(pl_argument,cl_ledStart,cl_ledEnd);
|
| var charstring vl_withText := "";
|
| var EPTF_LEDColors vl_color;
|
| if(vl_ledColor != "") {
|
| var charstring vl_ledStr := cl_ledStart&vl_ledColor&cl_ledEnd;
|
| var integer vl_i:=f_strstr(pl_argument,vl_ledStr);
|
| if(vl_i==0) {
|
| vl_withText := substr(pl_argument, lengthof(vl_ledStr), (lengthof(pl_argument)-lengthof(vl_ledStr)));
|
| select(vl_ledColor) {
|
| case ("blue"){ vl_color := led_blue;}
|
| case ("black"){ vl_color := led_black;}
|
| case ("yellow"){ vl_color := led_yellow;}
|
| case ("green"){ vl_color := led_green;}
|
| case ("red"){ vl_color := led_red;}
|
| }
|
| if(isbound(vl_color)==true) {
|
| if(vl_withText == "") {
|
| vl_parsedArgument.content.direct.statusLEDVal := {color:=vl_color, text:= omit };
|
| }
|
| else {
|
| vl_parsedArgument.content.direct.statusLEDVal := {color:=vl_color, text:= vl_withText };
|
| }
|
| // store
|
| f_EPTF_UIHandler_updatesubscriptionsguilist(pl_varIdx, vl_parsedArgument.content.direct);
|
| f_EPTF_Var_adjustContent(pl_varIdx, vl_parsedArgument.content.direct, {refers(f_EPTF_UIHandler_adjustContentResponseHandler), {}});
|
| vl_ret := true;
|
| }
|
| }
|
| }
|
| }
|
| else{
|
| f_EPTF_UIHandler_warning("Invalid value type!");
|
| //f_EPTF_Base_stop();
|
| }
|
| return vl_ret;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_setWidgetOriginalDisabled
|
| //
|
| // Purpose:
|
| // Set oroginal enabled state of the widget in the list of GUI items
|
| //
|
| // Parameters:
|
| // pl_i - *in* *integer* the idx of the widget in the gui items' list
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_setWidgetOriginalDisabled(in integer pl_i)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean
|
| {
|
| if (pl_i == -1){return false;}
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := false; // always setup
|
| if (v_UIHandler_guiItemList[pl_i].widgetType == wtTabpages){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.tabpages.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.tabpages.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTabpage){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.tabpage.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.tabpage.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHbox){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.hbox.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.hbox.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTree){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.tree.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.tree.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecol){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.treecol.disabledongui)){
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.treecol.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecell){
|
| // cell editable info not present in XUL -> after headless mode enabled cell could become disabled
|
| // workaround: enabling a cell enables the whole column
|
| // get treecol's widgetIdx
|
| var integer vl_colIdx := v_UIHandler_guiItemList[pl_i].widgetData.cellData.colIdx;
|
| // set treecol editable
|
| if(ispresent(v_UIHandler_guiItemList[vl_colIdx].XULformat.treecol.disabledongui)){
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[vl_colIdx].XULformat.treecol.disabledongui;
|
| } else {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := false;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtLabel){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.label_.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.label_.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtButton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.button.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.button.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTextbox){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.textbox.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.textbox.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtNumericalwidget){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtChart){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.chart.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.chart.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtDistributionchart){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.distributionchart.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.distributionchart.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtToolbar){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.toolbar.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.toolbar.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtToolbarbutton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.toolbarbutton.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.toolbarbutton.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtListbox){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.listbox.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.listbox.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtMenulist){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.menulist.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.menulist.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtPushbutton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.pushbutton.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.pushbutton.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTogglebutton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.togglebutton.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.togglebutton.disabledongui;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHtmlcode){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.htmlcode.disabledongui)) {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[pl_i].XULformat.htmlcode.disabledongui;
|
| }
|
| }
|
| return(v_UIHandler_guiItemList[pl_i].xuldisabled);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_updateguilist_enablewidget
|
| //
|
| // Purpose:
|
| // Sets the enabled state of the widget in the list of GUI items to enabled
|
| //
|
| // Parameters:
|
| // pl_i - *in* *integer* the idx of the widget in the gui items' list
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_updateguilist_enablewidget(in integer pl_i) runs on EPTF_UIHandler_Private_CT {
|
| if (pl_i == -1){return;}
|
| // If disabled in xul -> just return
|
| if(not ispresent(v_UIHandler_guiItemList[pl_i].xuldisabled)){
|
| var boolean vl_enabled := f_EPTF_UIHandler_setWidgetOriginalDisabled(pl_i);
|
| }
|
| // If disabled on XML ->
|
| if(v_UIHandler_guiItemList[pl_i].xuldisabled == true){
|
| return;
|
| }
|
| if (v_UIHandler_guiItemList[pl_i].widgetType == wtButton){
|
| v_UIHandler_guiItemList[pl_i].XULformat.button.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTabpages){
|
| v_UIHandler_guiItemList[pl_i].XULformat.tabpages.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTree){
|
| v_UIHandler_guiItemList[pl_i].XULformat.tree.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecol){
|
| v_UIHandler_guiItemList[pl_i].XULformat.treecol.editable := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecell){
|
| // cell editable info not present in XUL -> after headless mode enabled cell could become disabled
|
| // workaround: enabling a cell enables the whole column
|
| // get treecol's widgetIdx
|
| // var integer vl_colIdx := v_UIHandler_guiItemList[pl_i].widgetData.cellData.colIdx;
|
| // set treecol editable
|
| // v_UIHandler_guiItemList[vl_colIdx].XULformat.treecol.editable := true;
|
| var integer vl_colIdx := v_UIHandler_guiItemList[pl_i].widgetData.cellData.colIdx;
|
| // set treecol editable
|
| if(0<= vl_colIdx and ispresent(v_UIHandler_guiItemList[vl_colIdx].xuldisabled)) {
|
| // If disabled on XML
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := v_UIHandler_guiItemList[vl_colIdx].xuldisabled;
|
| } else {
|
| v_UIHandler_guiItemList[pl_i].xuldisabled := false;
|
| }
|
| v_UIHandler_guiItemList[pl_i].widgetData.cellData.editable := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHbox){
|
| v_UIHandler_guiItemList[pl_i].XULformat.hbox.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtLabel){
|
| v_UIHandler_guiItemList[pl_i].XULformat.label_.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTextbox){
|
| v_UIHandler_guiItemList[pl_i].XULformat.textbox.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtChart){
|
| v_UIHandler_guiItemList[pl_i].XULformat.chart.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtListbox){
|
| v_UIHandler_guiItemList[pl_i].XULformat.listbox.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtNumericalwidget){
|
| v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtMenulist){
|
| v_UIHandler_guiItemList[pl_i].XULformat.menulist.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtDistributionchart){
|
| v_UIHandler_guiItemList[pl_i].XULformat.distributionchart.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtPushbutton){
|
| v_UIHandler_guiItemList[pl_i].XULformat.pushbutton.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTogglebutton){
|
| v_UIHandler_guiItemList[pl_i].XULformat.togglebutton.disabled := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHtmlcode){
|
| v_UIHandler_guiItemList[pl_i].XULformat.htmlcode.disabled := false;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_updateguilist_disablewidget
|
| //
|
| // Purpose:
|
| // Sets the enabled state of the widget in the list of GUI items to disabled
|
| //
|
| // Parameters:
|
| // pl_i - *in* *integer* the idx of the widget in the gui items' list
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_updateguilist_disablewidget(in integer pl_i) runs on EPTF_UIHandler_Private_CT {
|
| if (pl_i == -1) {return;}
|
| if (v_UIHandler_guiItemList[pl_i].widgetType == wtButton){
|
| v_UIHandler_guiItemList[pl_i].XULformat.button.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTabpages){
|
| v_UIHandler_guiItemList[pl_i].XULformat.tabpages.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTree){
|
| v_UIHandler_guiItemList[pl_i].XULformat.tree.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecol){
|
| v_UIHandler_guiItemList[pl_i].XULformat.treecol.editable := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecell){
|
| v_UIHandler_guiItemList[pl_i].widgetData.cellData.editable := false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHbox){
|
| v_UIHandler_guiItemList[pl_i].XULformat.hbox.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtLabel){
|
| v_UIHandler_guiItemList[pl_i].XULformat.label_.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTextbox){
|
| v_UIHandler_guiItemList[pl_i].XULformat.textbox.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtChart){
|
| v_UIHandler_guiItemList[pl_i].XULformat.chart.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtListbox){
|
| v_UIHandler_guiItemList[pl_i].XULformat.listbox.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtNumericalwidget){
|
| v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtMenulist){
|
| v_UIHandler_guiItemList[pl_i].XULformat.menulist.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtDistributionchart){
|
| v_UIHandler_guiItemList[pl_i].XULformat.distributionchart.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtPushbutton){
|
| v_UIHandler_guiItemList[pl_i].XULformat.pushbutton.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTogglebutton){
|
| v_UIHandler_guiItemList[pl_i].XULformat.togglebutton.disabled := true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHtmlcode){
|
| v_UIHandler_guiItemList[pl_i].XULformat.htmlcode.disabled := true;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_isWidgetEnabled
|
| //
|
| // Purpose:
|
| // Gets the enabled state of the widget in the list of GUI items
|
| //
|
| // Parameters:
|
| // pl_i - *in* *integer* the idx of the widget in the gui items' list
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_isWidgetEnabled(in integer pl_i)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean
|
| {
|
| if (pl_i == -1){return false;}
|
| // If disabled on XML
|
| if(v_UIHandler_guiItemList[pl_i].xuldisabled == true){ return false; }
|
| if (v_UIHandler_guiItemList[pl_i].widgetType == wtButton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.button.disabled)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.button.disabled;
|
| } else {
|
| return true;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecol){
|
| if(v_UIHandler_guiItemList[pl_i].XULformat.treecol.widgetType == statusLED or
|
| v_UIHandler_guiItemList[pl_i].XULformat.treecol.widgetType == statusLEDWithText) {
|
| return false;
|
| }
|
| return v_UIHandler_guiItemList[pl_i].XULformat.treecol.editable;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecell){
|
| // cell editable info not present in XUL -> after headless mode enabled cell could become disabled
|
| // workaround: enabling a cell enables the whole column
|
| // get treecol's widgetIdx
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].widgetData.cellData.editable)) {
|
| return v_UIHandler_guiItemList[pl_i].widgetData.cellData.editable;
|
| }
|
| var integer vl_colIdx := v_UIHandler_guiItemList[pl_i].widgetData.cellData.colIdx;
|
| // set treecol editable
|
| if(v_UIHandler_guiItemList[vl_colIdx].XULformat.treecol.widgetType == statusLED or
|
| v_UIHandler_guiItemList[vl_colIdx].XULformat.treecol.widgetType == statusLEDWithText) {
|
| return false;
|
| }
|
| return (not ispresent(v_UIHandler_guiItemList[vl_colIdx].XULformat.treecol.editable)) or
|
| v_UIHandler_guiItemList[vl_colIdx].XULformat.treecol.editable;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTextbox){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.textbox.readonly)
|
| and v_UIHandler_guiItemList[pl_i].XULformat.textbox.readonly) { return false; }
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.textbox.disabled)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.textbox.disabled;
|
| } else {
|
| return true;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtListbox){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.listbox.disabled)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.listbox.disabled;
|
| } else {
|
| return true;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtNumericalwidget){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.readonly)
|
| and v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.readonly) { return false; }
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.disabled)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.disabled;
|
| } else {
|
| return true;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtMenulist){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.menulist.disabled)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.menulist.disabled;
|
| } else {
|
| return true;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtPushbutton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.pushbutton.disabled)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.pushbutton.disabled;
|
| } else {
|
| return true;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTogglebutton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.togglebutton.disabled)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.togglebutton.disabled;
|
| } else {
|
| return true;
|
| }
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHtmlcode){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.htmlcode.disabled)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.htmlcode.disabled;
|
| } else {
|
| return true;
|
| }
|
| }
|
| /* else if (v_UIHandler_guiItemList[pl_i].widgetType == wtDistributionchart){
|
| return false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTabbox){
|
| return false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTree){
|
| return false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHbox){
|
| return false;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtLabel){
|
| return false; // text labels are never editable on the GUI
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtChart){
|
| return false;
|
| }*/else { return false; }
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_isWidgetUninitialisedOrDisabled
|
| //
|
| // Purpose:
|
| // Gets the unitialised or disabled state of the widget in the list of GUI items
|
| //
|
| // Parameters:
|
| // pl_i - *in* *integer* the idx of the widget in the gui items' list
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_isWidgetUninitialisedOrDisabled(in integer pl_i)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean
|
| {
|
| if (pl_i == -1){return false;}
|
| if (v_UIHandler_guiItemList[pl_i].widgetType == wtButton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.button.disabled)) {
|
| return v_UIHandler_guiItemList[pl_i].XULformat.button.disabled;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecol){
|
| if(v_UIHandler_guiItemList[pl_i].XULformat.treecol.widgetType == statusLED or
|
| v_UIHandler_guiItemList[pl_i].XULformat.treecol.widgetType == statusLEDWithText) {
|
| return true;
|
| }
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.treecol.editable)) {
|
| return not v_UIHandler_guiItemList[pl_i].XULformat.treecol.editable;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTreecell){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].widgetData.cellData.editable)) {
|
| return not v_UIHandler_guiItemList[pl_i].widgetData.cellData.editable;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTextbox){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.textbox.readonly)
|
| and v_UIHandler_guiItemList[pl_i].XULformat.textbox.readonly) {
|
| return true;
|
| }
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.textbox.disabled)) {
|
| return v_UIHandler_guiItemList[pl_i].XULformat.textbox.disabled;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtListbox){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.listbox.disabled)) {
|
| return v_UIHandler_guiItemList[pl_i].XULformat.listbox.disabled;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtNumericalwidget){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.readonly)
|
| and v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.readonly) {
|
| return true;
|
| }
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.disabled)) {
|
| return v_UIHandler_guiItemList[pl_i].XULformat.numericalwidget.disabled;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtMenulist){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.menulist.disabled)) {
|
| return v_UIHandler_guiItemList[pl_i].XULformat.menulist.disabled;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtPushbutton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.pushbutton.disabled)) {
|
| return v_UIHandler_guiItemList[pl_i].XULformat.pushbutton.disabled;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtTogglebutton){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.togglebutton.disabled)) {
|
| return v_UIHandler_guiItemList[pl_i].XULformat.togglebutton.disabled;
|
| }
|
| return true;
|
| } else if (v_UIHandler_guiItemList[pl_i].widgetType == wtHtmlcode){
|
| if(ispresent(v_UIHandler_guiItemList[pl_i].XULformat.htmlcode.disabled)) {
|
| return v_UIHandler_guiItemList[pl_i].XULformat.htmlcode.disabled;
|
| }
|
| return true;
|
| }
|
| else { return true; }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_isGuiVarEditable
|
| //
|
| // Purpose:
|
| // Gets the enabled state of a GUI variable
|
| //
|
| // Parameters:
|
| // pl_varIdx - *in* *integer* the idx of the GUI variable
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_isGuiVarEditable(in integer pl_varIdx)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean
|
| {
|
| var EPTF_UIHandler_OpenSubscriptions vl_subs := {};
|
| if(f_EPTF_UIHandler_getSubscriptionsByVarIdx(pl_varIdx, vl_subs)) {
|
| for(var integer i:=0;i<sizeof(vl_subs);i:=i+1) {
|
| var integer vl_widgetIdx := f_EPTF_UIHandler_widgetRecIndex(vl_subs[i].widgetId);
|
| if(vl_widgetIdx != -1 and f_EPTF_UIHandler_isWidgetEnabled(vl_widgetIdx)) { return true; }
|
| }
|
| return false;
|
| } else {
|
| return false;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_handleEnableWidgetByIdx
|
| //
|
| // Purpose:
|
| // Handles the EnableWidgetByIdx and DisableWidgetByIdx messages
|
| //
|
| // Parameters:
|
| // pl_msg - *in* *EPTF_UIHandler_AdminEnableWidgetByIdx* - the message that specifies the widget
|
| // pl_enable - *in* *boolean* - Describes what to do. Enable or disable.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_handleEnableWidgetByIdx(
|
| in EPTF_UIHandler_AdminEnableWidgetByIdx pl_msg,
|
| in boolean pl_enable)
|
| runs on EPTF_UIHandler_Private_CT {
|
| var EPTF_UIHandler_OpenSubscriptions vl_subs;
|
| if(f_EPTF_UIHandler_getSubscriptionsByVarIdx(pl_msg.index, vl_subs)){
|
| for(var integer vl_i := 0; vl_i < sizeof(vl_subs); vl_i := vl_i + 1){
|
| var integer vl_widgetIdx := f_EPTF_UIHandler_widgetRecIndex(vl_subs[vl_i].widgetId);
|
| if(-1 == vl_widgetIdx){
|
| f_EPTF_UIHandler_warning("The variable index is invalid!");
|
| EPTF_adminPort_CP.send(
|
| t_UIHandler_AdminEnableWidgetNAck(pl_msg.messageID)) to vl_subs[vl_i].provider;
|
| return;
|
| }
|
| if(pl_enable){
|
| f_EPTF_Base_assert(%definitionId&": Invalid widget id: "&vl_subs[vl_i].widgetId, vl_widgetIdx > -1);
|
| f_EPTF_UIHandler_updateguilist_enablewidget(vl_widgetIdx);
|
| }else{
|
| f_EPTF_Base_assert(%definitionId&": Invalid widget id: "&vl_subs[vl_i].widgetId, vl_widgetIdx > -1);
|
| f_EPTF_UIHandler_updateguilist_disablewidget(vl_widgetIdx);
|
| }
|
| // check here
|
| if(f_EPTF_UIHandler_isWidgetEnabled(vl_widgetIdx) == true){
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_enableWidget(vl_subs[vl_i].widgetId));
|
| }else{
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_disableWidget(vl_subs[vl_i].widgetId));
|
| }
|
| EPTF_adminPort_CP.send(
|
| t_UIHandler_AdminEnableWidgetAck(pl_msg.messageID))to vl_subs[vl_i].provider;
|
| }
|
| }
|
| }
|
|
|
| //=========================================================================
|
| // Altsteps
|
| //=========================================================================
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_pingGUI
|
| //
|
| // Purpose:
|
| // In headless mode, it transmits UDP pings and
|
| // receives, validates the answers
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_pingGUI() runs on EPTF_UIHandler_Private_CT {
|
| []t_UIHandler_pingtimer.timeout{
|
| var Result vl_result
|
| f_EPTF_Transport_sendTo(
|
| IPL4,
|
| v_UIHandler_pingerConnectionId,
|
| v_UIHandler_GUI_Host,
|
| v_UIHandler_udp_port,
|
| char2oct("This is UIHandler: " & int2str(v_UIHandler_pingcounter)),
|
| vl_result,
|
| false)
|
| v_UIHandler_pingcounter := v_UIHandler_pingcounter + 1;
|
| if (v_UIHandler_pingcounter == 2147483646) {v_UIHandler_pingcounter := 2;v_UIHandler_prevpingcounter := 0;v_UIHandler_succpingcounter:=0;}
|
| t_UIHandler_pingtimer.start;
|
| repeat;
|
| }
|
| }
|
|
|
| //FIXME Use new API
|
| function f_EPTF_UIHandler_pingerReceive(
|
| in EPTF_Transport_TransportType pl_transportType,
|
| in ConnectionId pl_connId,
|
| in HostName pl_remHost,
|
| in PortNumber pl_remPort,
|
| in HostName pl_locHost,
|
| in PortNumber pl_locPort,
|
| in ProtoTuple pl_proto,
|
| in integer pl_userData,
|
| in octetstring pl_msg)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if (not v_UIHandler_initialized) {
|
| return;
|
| }
|
| if(not match(pl_msg, '47554920726573706F6E73653A*'O)) {
|
| return;
|
| }
|
| if (v_UIHandler_prevpingcounter == v_UIHandler_pingcounter - 2) {
|
| v_UIHandler_succpingcounter := v_UIHandler_succpingcounter + 1;
|
| } else {v_UIHandler_succpingcounter := 0;}
|
| v_UIHandler_prevpingcounter := v_UIHandler_pingcounter - 1;
|
| if (v_UIHandler_succpingcounter == 3) {
|
| f_EPTF_UIHandler_headlessmodeover();
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_UIHandler_setHandshakeMaxTime
|
| //
|
| // Purpose:
|
| // Sets the XTDP handshake timeout
|
| //
|
| // Parameters:
|
| // pl_maxTime - *in* *float* - the time of the XTDP handshake timeout in seconds. Default: 1.0
|
| ///////////////////////////////////////////////////////////
|
| public function f_UIHandler_setHandshakeMaxTime(in float pl_maxTime := 1.0) runs on EPTF_UIHandler_Private_CT {
|
| v_handshakeMaxTime := pl_maxTime;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_UIHandler_setByeMaxTime
|
| //
|
| // Purpose:
|
| // Sets the XTDP bye timeout
|
| //
|
| // Parameters:
|
| // pl_maxTime - *in* *float* - the time of the XTDP bye timeout in seconds. Default: 1.0
|
| ///////////////////////////////////////////////////////////
|
| public function f_UIHandler_setByeMaxTime(in float pl_maxTime := 1.0) runs on EPTF_UIHandler_Private_CT {
|
| v_byeMaxTime := pl_maxTime;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_UIHandler_setAuthMaxTime
|
| //
|
| // Purpose:
|
| // Sets the XTDP authentication timeout
|
| //
|
| // Parameters:
|
| // pl_maxTime - *in* *float* - the time of the XTDP authentication timeout in seconds. Default: 1.0
|
| ///////////////////////////////////////////////////////////
|
| public function f_UIHandler_setAuthMaxTime(in float pl_maxTime := 1.0) runs on EPTF_UIHandler_Private_CT {
|
| v_authMaxTime := pl_maxTime;
|
| }
|
|
|
|
|
| /////////////////////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_WidgetFunctions_setXTDP_XSDFilepath
|
| //
|
| // Purpose:
|
| // This function sets the the UIHandler XTDP XSD file path.
|
| // If its not empty string the CreateGUI validate the XML with it.
|
| //
|
| // Parameters:
|
| // pl_filepath - *in* <charstring> - the file path
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| /////////////////////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_WidgetFunctions_setXTDP_XSDFilepath(in charstring pl_filepath)
|
| runs on EPTF_UIHandler_Private_CT{
|
| v_EPTF_UIHandler_WidgetFunctions_XTDP_XSD_filepath := pl_filepath;
|
| }
|
|
|
| /////////////////////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_WidgetFunctions_getXTDP_XSDFilepath
|
| //
|
| // Purpose:
|
| // This function returns with the UIHandler XTDP XSD file path.
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // *charstring* - the filepath
|
| //
|
| /////////////////////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_WidgetFunctions_getXTDP_XSDFilepath()
|
| runs on EPTF_UIHandler_Private_CT return charstring{
|
| return v_EPTF_UIHandler_WidgetFunctions_XTDP_XSD_filepath;
|
| }
|
|
|
|
|
| const float c_EPTF_UIHandler_xtdpMyVersion := 1.0;
|
| const float c_EPTF_UIHandler_xtdlMyVersion := 1.0;
|
|
|
| // returns the error message ("" if success)
|
| private function f_EPTF_UIHandler_handshake(in integer pl_guiClientId) runs on EPTF_UIHandler_Private_CT return charstring {
|
| v_UIHandler_lastRequest := v_UIHandler_lastRequest + 1;
|
| var integer vl_handshakeTimer := f_EPTF_Semaphore_new();
|
| var Result vl_result
|
| f_EPTF_Transport_send(
|
| IPL4,
|
| pl_guiClientId,//v_UIHandler_GUIClientId[i],
|
| f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message:{
|
| transactionID := vl_handshakeTimer+1000*v_UIHandler_lastRequest,
|
| choice := { xTDP_HandshakeRequest := {
|
| xtdpRequiredVersion := c_EPTF_UIHandler_xtdpMyVersion,
|
| xtdlRequiredVersion := c_EPTF_UIHandler_xtdlMyVersion,
|
| xtdpMyVersion := c_EPTF_UIHandler_xtdpMyVersion,
|
| xtdlMyVersion := c_EPTF_UIHandler_xtdlMyVersion
|
| ,elem_list := {}
|
| }}
|
| })),
|
| vl_result,
|
| false
|
| );
|
| v_handshakeErrorMsg := "";
|
| if (f_EPTF_Semaphore_waitForUnlock(vl_handshakeTimer,v_handshakeMaxTime)) {
|
| // max wait time expired before response received:
|
| v_handshakeErrorMsg := "Error: UIHandler: Communication error: No response received for Handshake request"
|
| }
|
| if (v_handshakeErrorMsg!="") {
|
| f_EPTF_UIHandler_warning("XTDP Handshake failed for client "&log2str(pl_guiClientId)&". Closing XTDP session. Handshake result: "&v_handshakeErrorMsg);
|
| f_EPTF_UIHandler_closeXTDPSession(pl_guiClientId);
|
| // handshake unsuccessful
|
| }
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| return v_handshakeErrorMsg;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleSubscriptNote
|
| //
|
| // Purpose:
|
| // Calls the f_EPTF_UIHandler_handleSubscriptNote
|
| // when receives a subscription note
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleSubscriptNote() runs on EPTF_UIHandler_Private_CT {
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_CLL_UISubscMgmtMsg;
|
| var EPTF_Var_CT vl_EPTF_CLL_UISubscMgmtMsg_sender;
|
| [] EPTF_adminPort_CP.receive({subscribeNoteMsg := ?}) -> value vl_EPTF_CLL_UISubscMgmtMsg sender vl_EPTF_CLL_UISubscMgmtMsg_sender {
|
| f_EPTF_UIHandler_handleSubscriptNote(vl_EPTF_CLL_UISubscMgmtMsg.subscribeNoteMsg,vl_EPTF_CLL_UISubscMgmtMsg_sender);
|
| }
|
| }
|
|
|
| private altstep as_UIHandler_bufferedXTDP() runs on EPTF_UIHandler_Private_CT
|
| {
|
| []t_UIHandler_bufferedXTDP.timeout
|
| {
|
| // if (sizeof(v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.xTDP_Request_list) != 0)
|
| if (f_EPTF_UIHandler_requestBuffer_size() != 0)
|
| {
|
| for (var integer i:=0;i<sizeof(v_UIHandler_GUIClientId);i:=i+1)
|
| {
|
| // v_UIHandler_Requestbuffer.client_id := v_UIHandler_GUIClientId[i];
|
| if (v_UIHandler_guiConnected)
|
| {
|
| var Result vl_result
|
| f_EPTF_Transport_send(IPL4, v_UIHandler_GUIClientId[i].clientId, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(v_UIHandler_Requestbuffer.data)), vl_result, false)
|
| }
|
| }
|
| // v_UIHandler_Requestbuffer.data.choice.xTDP_Requests.xTDP_Request_list := {};
|
| f_EPTF_UIHandler_requestBuffer_clear();
|
| }
|
| t_UIHandler_bufferedXTDP.start(tsp_EPTF_UIHandler_bufferedXTDP);
|
| }
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleSubscriptNote
|
| //
|
| // Purpose:
|
| // The main altstep of the component
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_handle_main_EPTF_UIHandler_MgmtIf() runs on EPTF_UIHandler_Private_CT {
|
| [/*not v_UIHandler_subscriptInProcess*/] as_UIHandler_handleSubscriptNote(){repeat;};
|
| [not v_UIHandler_guiConnected and not v_EPTF_UIHandler_servermode] as_UIHandler_pingGUI(){repeat;}
|
| [f_EPTF_UIHandler_layoutReady()] as_UIHandler_handleEnableWidget(){repeat;};
|
| [f_EPTF_UIHandler_layoutReady()] as_UIHandler_handleDisableWidget(){repeat;};
|
| [f_EPTF_UIHandler_layoutReady()] as_UIHandler_handleSetFocusToWidget(){repeat;};
|
| [f_EPTF_UIHandler_layoutReady()] as_UIHandler_handleaddElementToGUI(){repeat;};
|
| [f_EPTF_UIHandler_layoutReady()] as_UIHandler_handleCreateGUI(){repeat;};
|
| [f_EPTF_UIHandler_layoutReady()] as_UIHandler_handleremoveElementFromGUI(){repeat;};
|
| [f_EPTF_UIHandler_layoutReady()] as_UIHandler_handleWidgetExists(){repeat;};
|
| [tsp_EPTF_UIHandler_bufferedXTDP != 0.0] as_UIHandler_bufferedXTDP(){repeat;};
|
| [not v_UIHandler_createGUIRunning and v_UIHandler_initToGUIClient] as_UIHandler_handleInitGUIToClient(){repeat;}
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleEnableWidget
|
| //
|
| // Purpose:
|
| // Altstep that handles enableWidget messages at CLL_UIHandler interface.
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // As altstep receives enableWidget requests, sends XTDP-enable-widget
|
| // message to GUI if connected
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleEnableWidget() runs on EPTF_UIHandler_Private_CT {
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_msg_tmp;
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminEnableWidgetByIdx(?,?))
|
| -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp {
|
| f_EPTF_UIHandler_handleEnableWidgetByIdx(vl_EPTF_msg_tmp.enableWidgetByIdx, true);
|
| repeat;
|
| }
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminEnableWidgetByWidgetName(?,?)) -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp {
|
| var EPTF_UIHandler_WidgetIdString vl_widgetName := vl_EPTF_msg_tmp.enableWidgetByWidgetName.widgetName;
|
| var integer vl_widgetIdx := f_EPTF_UIHandler_widgetRecIndex(vl_widgetName);
|
| if(-1 < vl_widgetIdx) {
|
| f_EPTF_UIHandler_updateguilist_enablewidget(vl_widgetIdx);
|
| if (vl_widgetName == "") {
|
| f_EPTF_UIHandler_warning("CLL_UIHandler: the widget name is empty in as_UIHandler_handleEnableWidget()");
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminEnableWidgetNAck(vl_EPTF_msg_tmp.enableWidgetByWidgetName.messageID)) to v_UIHandler_address_tmp;
|
| }
|
| }
|
| else {
|
| f_EPTF_UIHandler_warning("CLL_UIHandler: here is no widget with name "&vl_widgetName&" in as_UIHandler_handleEnableWidget()");
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminEnableWidgetNAck(vl_EPTF_msg_tmp.enableWidgetByWidgetName.messageID)) to v_UIHandler_address_tmp;
|
| }
|
| if (v_UIHandler_guiConnected) {
|
| // check here
|
| if(f_EPTF_UIHandler_isWidgetEnabled(vl_widgetIdx) == true){
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_enableWidget(vl_widgetName));
|
| } else {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_disableWidget(vl_widgetName));
|
| }
|
| }
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminEnableWidgetAck(vl_EPTF_msg_tmp.enableWidgetByWidgetName.messageID)) to v_UIHandler_address_tmp;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleDisableWidget
|
| //
|
| // Purpose:
|
| // Altstep that handles disableWidget messages at CLL_UIHandler interface.
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // As altstep receives disableWidget requests, sends XTDP-disable-widget
|
| // message to GUI if connected
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleDisableWidget() runs on EPTF_UIHandler_Private_CT {
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_msg_tmp;
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminDisableWidgetByIdx(?,?)) -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp {
|
| f_EPTF_UIHandler_handleEnableWidgetByIdx(vl_EPTF_msg_tmp.enableWidgetByIdx, false);
|
| repeat;
|
| }
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminDisableWidgetByWidgetName(?,?)) -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp {
|
| var EPTF_UIHandler_WidgetIdString vl_widgetName := vl_EPTF_msg_tmp.disableWidgetByWidgetName.widgetName;
|
| var integer vl_widgetIdx := f_EPTF_UIHandler_widgetRecIndex(vl_widgetName);
|
| f_EPTF_UIHandler_updateguilist_disablewidget(vl_widgetIdx);
|
| if(-1 < vl_widgetIdx) {
|
| if (vl_widgetName == "") {
|
| f_EPTF_UIHandler_warning("CLL_UIHandler: the widget name is empty in as_UIHandler_handleDisableWidget()");
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminDisableWidgetNAck(vl_EPTF_msg_tmp.disableWidgetByWidgetName.messageID)) to v_UIHandler_address_tmp;
|
| }
|
| } else {
|
| f_EPTF_UIHandler_warning("CLL_UIHandler: here is no widget with name "&vl_widgetName&" in as_UIHandler_handleDisableWidget()");
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminDisableWidgetNAck(vl_EPTF_msg_tmp.disableWidgetByWidgetName.messageID)) to v_UIHandler_address_tmp;
|
| }
|
| if (v_UIHandler_guiConnected) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_disableWidget(vl_widgetName));
|
| }
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminDisableWidgetAck(vl_EPTF_msg_tmp.disableWidgetByWidgetName.messageID)) to v_UIHandler_address_tmp;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleSetFocusToWidget
|
| //
|
| // Purpose:
|
| // Altstep that handles setFocusToWidget messages at CLL_UIHandler interface.
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // As altstep receives setFocusToWidget requests, sends XTDP-setfocus-widget
|
| // message to GUI if connected
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleSetFocusToWidget() runs on EPTF_UIHandler_Private_CT {
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_msg_tmp;
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminSetFocusToWidget(?,?,*)) -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp {
|
| var EPTF_UIHandler_WidgetIdString vl_widgetName := vl_EPTF_msg_tmp.setFocusToWidget.widgetName;
|
| if (vl_widgetName == "") {
|
| f_EPTF_UIHandler_warning("CLL_UIHandler: the widget name is empty in as_UIHandler_handleSetFocusToWidget()");
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminSetFocusToWidgetNAck(vl_EPTF_msg_tmp.setFocusToWidget.messageID)) to v_UIHandler_address_tmp;
|
| }
|
| if (v_UIHandler_guiConnected) {
|
| if (not(ispresent(vl_EPTF_msg_tmp.setFocusToWidget.tabIndex))) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_setFocusToWidget(vl_widgetName));
|
| }
|
| else {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_setFocusToTab(vl_widgetName, vl_EPTF_msg_tmp.setFocusToWidget.tabIndex));
|
| }
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminSetFocusToWidgetAck(vl_EPTF_msg_tmp.setFocusToWidget.messageID)) to v_UIHandler_address_tmp;
|
| }
|
|
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI){
|
| if(v_EPTF_UIHandler_Browser_activateWidgetIds != ""){
|
| v_EPTF_UIHandler_Browser_activateWidgetIds := v_EPTF_UIHandler_Browser_activateWidgetIds & "," & vl_widgetName;
|
| } else {
|
| v_EPTF_UIHandler_Browser_activateWidgetIds := vl_widgetName;
|
| }
|
| }
|
|
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleaddElementToGUI
|
| //
|
| // Purpose:
|
| // Altstep that handles addElementToGUI messages at CLL_UIHandler interface.
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // As altstep receives addElementToGUI requests, sends XTDP-AddRequests
|
| // message to GUI if connected
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleaddElementToGUI() runs on EPTF_UIHandler_Private_CT
|
| {
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_msg_tmp;
|
| var boolean vl_widgetExists := false;
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminAddElementToGUI(*, ?, ?/*, ?*/)) -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp
|
| {
|
| if (f_EPTF_UIHandler_XSD_addElementToGui(vl_EPTF_msg_tmp.addElementToGUI.xul, vl_EPTF_msg_tmp.addElementToGUI.parentWidgetId, vl_widgetExists))
|
| { //send ack
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminAddElementToGUIAck(
|
| vl_EPTF_msg_tmp.addElementToGUI.messageID,
|
| vl_widgetExists)) to v_UIHandler_address_tmp;
|
| } else
|
| { //send nack
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminAddElementToGUINAck(vl_EPTF_msg_tmp.addElementToGUI.messageID/*,
|
| vl_EPTF_msg_tmp.addElementToGUI.replyRoutingIds*/)) to v_UIHandler_address_tmp;
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleCreateGUI
|
| //
|
| // Purpose:
|
| // Altstep that handles CreateGUI messages at CLL_UIHandler interface.
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // As altstep receives createGUI requests, and calls createGui
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleCreateGUI() runs on EPTF_UIHandler_Private_CT
|
| {
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_msg_tmp;
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminCreateGUI(*, ?, ?/*, ?*/)) -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp
|
| {
|
| if (f_EPTF_UIHandler_createGUI(vl_EPTF_msg_tmp.createGUI.xul, vl_EPTF_msg_tmp.createGUI.parentWidgetId))
|
| { //send ack
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminCreateGUIAck(vl_EPTF_msg_tmp.createGUI.messageID)) to v_UIHandler_address_tmp;
|
| } else
|
| { //send nack
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminCreateGUINAck(vl_EPTF_msg_tmp.createGUI.messageID)) to v_UIHandler_address_tmp;
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleremoveElementFromGUI
|
| //
|
| // Purpose:
|
| // Altstep that handles removeElementFromGUI messages at CLL_UIHandler interface.
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // As altstep receives removeElementFromGUI requests, sends XTDP-RemoveRequests
|
| // message to GUI if connected
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleremoveElementFromGUI() runs on EPTF_UIHandler_Private_CT
|
| {
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_msg_tmp;
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminRemoveElementFromGUI(?,?)) -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp
|
| {
|
| if (f_EPTF_UIHandler_removeElementFromGui(vl_EPTF_msg_tmp.removeElementFromGUI.widgetId))
|
| {//send ack
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminRemoveElementFromGUIAck(vl_EPTF_msg_tmp.removeElementFromGUI.widgetId/*,
|
| vl_EPTF_msg_tmp.removeElementFromGUI.replyRoutingIds*/)) to v_UIHandler_address_tmp;
|
| } else
|
| {//send nack
|
| EPTF_adminPort_CP.send(t_UIHandler_AdminRemoveElementFromGUINAck(vl_EPTF_msg_tmp.removeElementFromGUI.widgetId/*,
|
| vl_EPTF_msg_tmp.removeElementFromGUI.replyRoutingIds*/)) to v_UIHandler_address_tmp;
|
| }
|
| }
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_handleWidgetExists
|
| //
|
| // Purpose:
|
| // Altstep that handles widgetExists messages at CLL_UIHandler interface.
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| // As altstep receives widgetExists requests it checks the given widget
|
| // in UI handler's internal database
|
| ///////////////////////////////////////////////////////////
|
| private altstep as_UIHandler_handleWidgetExists() runs on EPTF_UIHandler_Private_CT
|
| {
|
| var EPTF_UIHandler_WidgetMsg vl_EPTF_msg_tmp;
|
| [] EPTF_adminPort_CP.receive(t_UIHandler_AdminWidgetExists(*,*)) -> value vl_EPTF_msg_tmp sender v_UIHandler_address_tmp
|
| {
|
| var EPTF_UIHandler_GuiItemRec vl_rec;
|
| if(not f_EPTF_UIHandler_getWidgetRec(vl_EPTF_msg_tmp.widgetExists.widgetName, vl_rec)){
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": f_EPTF_UIHandler_getwidgetrec failed!");
|
| }
|
| }
|
| EPTF_adminPort_CP.send(
|
| t_UIHandler_AdminWidgetExistsResp(
|
| vl_EPTF_msg_tmp.widgetExists.widgetName,
|
| vl_EPTF_msg_tmp.widgetExists.messageID,
|
| vl_rec.widgetType)) to v_UIHandler_address_tmp;
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_addclientid(in integer pl_clientid) runs on EPTF_UIHandler_Private_CT{
|
| if (f_EPTF_UIHandler_isConnectedClientid(pl_clientid)) {
|
| return;
|
| }
|
| var integer vl_clientIdx := sizeof(v_UIHandler_GUIClientId);
|
| v_UIHandler_GUIClientId[vl_clientIdx] := c_EPTF_UIHandler_GUIClientData;
|
| v_UIHandler_GUIClientId[vl_clientIdx].clientId := pl_clientid;
|
| }
|
|
|
| private function f_EPTF_UIHandler_setClientHandshakeSuccessful(in integer pl_clientid) runs on EPTF_UIHandler_Private_CT{
|
| for (var integer i:=0;i<sizeof(v_UIHandler_GUIClientId);i:=i+1){
|
| if (v_UIHandler_GUIClientId[i].clientId == pl_clientid){
|
| v_UIHandler_GUIClientId[i].handshakeSuccessful := true;
|
| return;
|
| }
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_getClientHandshakeSuccessful(in integer pl_clientid) runs on EPTF_UIHandler_Private_CT return boolean {
|
| for (var integer i:=0;i<sizeof(v_UIHandler_GUIClientId);i:=i+1){
|
| if (v_UIHandler_GUIClientId[i].clientId == pl_clientid){
|
| return v_UIHandler_GUIClientId[i].handshakeSuccessful;
|
| }
|
| }
|
| return false;
|
| }
|
|
|
| private function f_EPTF_UIHandler_setClientAuthenticationSuccessful(in integer pl_clientid) runs on EPTF_UIHandler_Private_CT{
|
| for (var integer i:=0;i<sizeof(v_UIHandler_GUIClientId);i:=i+1){
|
| if (v_UIHandler_GUIClientId[i].clientId == pl_clientid){
|
| v_UIHandler_GUIClientId[i].authenticationSuccessful := true;
|
| return;
|
| }
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_getClientAuthenticationSuccessful(in integer pl_clientid) runs on EPTF_UIHandler_Private_CT return boolean {
|
| for (var integer i:=0;i<sizeof(v_UIHandler_GUIClientId);i:=i+1){
|
| if (v_UIHandler_GUIClientId[i].clientId == pl_clientid){
|
| return v_UIHandler_GUIClientId[i].authenticationSuccessful;
|
| }
|
| }
|
| return false;
|
| }
|
|
|
| private function f_EPTF_UIHandler_delclientid(in integer pl_clientid) runs on EPTF_UIHandler_Private_CT{
|
| var EPTF_UIHandler_GUIClientDataList list := {};
|
| for (var integer i:=0;i<sizeof(v_UIHandler_GUIClientId);i:=i+1){
|
| if (v_UIHandler_GUIClientId[i].clientId != pl_clientid){
|
| list[sizeof(list)] := v_UIHandler_GUIClientId[i];
|
| }
|
| }
|
| v_UIHandler_GUIClientId := list;
|
| }
|
|
|
| private function f_EPTF_UIHandler_isConnectedClientid(in integer pl_clientid) runs on EPTF_UIHandler_Private_CT return boolean {
|
| for (var integer i:=0;i<sizeof(v_UIHandler_GUIClientId);i:=i+1){
|
| if (v_UIHandler_GUIClientId[i].clientId == pl_clientid){
|
| return true;
|
| }
|
| }
|
| return false;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_clearTracePointersDB
|
| //
|
| // Purpose:
|
| // Clear trace pointer database
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_clearTracePointersDB() runs on EPTF_UIHandler_Private_CT {
|
| //Empty the pointer list
|
| v_UIHandler_tracePointers := {};
|
| f_EPTF_int2int_HashMap_Clear(v_UIHandler_tracePointerHashMapId);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_clearInternalWidgetDB
|
| //
|
| // Purpose:
|
| // Clear internal widget database
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_clearInternalWidgetDB() runs on EPTF_UIHandler_Private_CT {
|
| //Empty the widget list
|
| //FIXME: v_EPTF_UIHandler_Config_ConnectVarToWidgets:={} : unsubscribe?
|
| var integer vl_i, vl_subsIdx:=-1, vl_size:=sizeof(v_UIHandler_guiItemList);
|
| for(vl_i:=0; vl_i < vl_size; vl_i:=vl_i+1)
|
| {
|
| vl_subsIdx := f_EPTF_UIHandler_getSubscriptionIdxByWidgetId(v_UIHandler_guiItemList[vl_i].id);
|
| if(vl_subsIdx > -1){
|
| f_EPTF_Var_unsubscribe(v_UIHandler_openSubscriptions[vl_subsIdx].varIdx);
|
| }
|
| }
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets := {};
|
| v_UIHandler_guiItemList := {};
|
| f_EPTF_str2int_HashMap_Clear(v_UIHandler_widgetHashMapId);
|
| //There is no window
|
| v_UIHandler_windowIndex := -1;
|
| // we must not close variable connections because of headless mode
|
| f_EPTF_UIHandler_clearTracePointersDB();
|
| }
|
|
|
| group Logging {
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_error
|
| //
|
| // Purpose:
|
| // Function to log an error from UIHandler feature.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_error(in charstring pl_message)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_Logging_error(true, tsp_EPTF_UIHandler_loggingComponentMask&": "&pl_message);
|
| f_EPTF_Base_stopAll();
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_warning
|
| //
|
| // Purpose:
|
| // Function to log a warning from UIHandler feature.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_warning(in @lazy charstring pl_message)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_Logging_warningV2(pl_message, v_UIHandler_loggingMaskId, {c_EPTF_UIHandler_loggingClassIdx_Warning});
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_debug
|
| //
|
| // Purpose:
|
| // Function to log a debug message from UIHandler feature.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_debug(in @lazy charstring pl_message)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_Logging_debugV2(pl_message, v_UIHandler_loggingMaskId, {c_EPTF_UIHandler_loggingClassIdx_Debug});
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_debugEnabled
|
| //
|
| // Purpose:
|
| // Function to check if debug is enabled for UIHandler
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // *boolean* - true if debug enalbed
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_debugEnabled()
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean
|
| {
|
| return f_EPTF_Logging_isEnabled(v_UIHandler_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
|
| }
|
|
|
| } // group Logging
|
|
|
| group Transport
|
| {
|
|
|
| private function f_EPTF_UIHandler_getWidgetFromXTDPAction(
|
| in XTDP_Actions pl_action,
|
| out template XTDP_Widget pl_retWidget){
|
| if (ischosen(pl_action.choice.get)) {
|
| pl_retWidget := pl_action.choice.get.widget;
|
| }
|
| else if (ischosen(pl_action.choice.put)) {
|
| pl_retWidget := pl_action.choice.put.widget;
|
| }
|
| else if (ischosen(pl_action.choice.increase)) {
|
| pl_retWidget := pl_action.choice.increase.widget;
|
| }
|
| else if (ischosen(pl_action.choice.decrease)) {
|
| pl_retWidget := pl_action.choice.decrease.widget;
|
| }
|
| else if (ischosen(pl_action.choice.enable)) {
|
| pl_retWidget := pl_action.choice.enable.widget;
|
| }
|
| else if (ischosen(pl_action.choice.disable)) {
|
| pl_retWidget := pl_action.choice.disable.widget;
|
| }
|
| else if (ischosen(pl_action.choice.setfocus)) {
|
| pl_retWidget := pl_action.choice.setfocus.widget;
|
| }
|
| else if (ischosen(pl_action.choice.gettooltip)) {
|
| pl_retWidget := pl_action.choice.gettooltip.widget;
|
| }
|
| else if (ischosen(pl_action.choice.settooltip)) {
|
| pl_retWidget := pl_action.choice.settooltip.widget;
|
| }
|
| else if (ischosen(pl_action.choice.replaceimage)) {
|
| pl_retWidget := pl_action.choice.replaceimage.widget;
|
| } else {
|
| pl_retWidget := omit;
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_getArgumentListFromXTDPAction(in XTDP_Actions pl_action) return EPTF_CharstringList {
|
| var EPTF_CharstringList vl_result := {};
|
| if (ischosen(pl_action.choice.put)) {
|
| for (var integer i:=0; i<sizeof(pl_action.choice.put.argument_list); i:=i+1) {
|
| vl_result[i] := unichar2char(pl_action.choice.put.argument_list[i]);
|
| }
|
| return vl_result;
|
| }
|
| if (ischosen(pl_action.choice.increase)) {
|
| for (var integer i:=0; i<sizeof(pl_action.choice.increase.argument_list); i:=i+1) {
|
| vl_result[i] := unichar2char(pl_action.choice.increase.argument_list[i]);
|
| }
|
| return vl_result;
|
| }
|
| if (ischosen(pl_action.choice.decrease)) {
|
| for (var integer i:=0; i<sizeof(pl_action.choice.decrease.argument_list); i:=i+1) {
|
| vl_result[i] := unichar2char(pl_action.choice.decrease.argument_list[i]);
|
| }
|
| return vl_result;
|
| }
|
| if (ischosen(pl_action.choice.settooltip)) {
|
| for (var integer i:=0; i<sizeof(pl_action.choice.settooltip.argument_list); i:=i+1) {
|
| vl_result[i] := unichar2char(pl_action.choice.settooltip.argument_list[i]);
|
| }
|
| return vl_result;
|
| }
|
| if (ischosen(pl_action.choice.replaceimage)) {
|
| for (var integer i:=0; i<sizeof(pl_action.choice.replaceimage.argument_list); i:=i+1) {
|
| vl_result[i] := unichar2char(pl_action.choice.replaceimage.argument_list[i]);
|
| }
|
| return vl_result;
|
| }
|
| return vl_result;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_HandleMsgs_XTDP
|
| //
|
| // Purpose:
|
| // Handles incoming XTDP messages.
|
| //
|
| // Detailed comments:
|
| // Calls the registered call-back function.
|
| ///////////////////////////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_HandleMsgs_XTDP(
|
| in EPTF_Transport_TransportType pl_transportType,
|
| in ConnectionId pl_connId,
|
| in HostName pl_remHost,
|
| in PortNumber pl_remPort,
|
| in HostName pl_locHost,
|
| in PortNumber pl_locPort,
|
| in ProtoTuple pl_proto,
|
| in integer pl_userData,
|
| in octetstring pl_msg)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if (not v_UIHandler_initialized) {
|
| return;
|
| }
|
|
|
| if (v_UIHandler_cleanupCalled) {
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| } else {
|
| // threadsafe:
|
| f_EPTF_Semaphore_waitForUnlock(v_UIHandler_xtdpReceivedMessageSemaphore_r,pl_autoDeleteSemaphore:=false);
|
| f_EPTF_Semaphore_lock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| }
|
| var integer vl_connId := pl_connId;
|
| var integer vl_succ := XTDP_EncDecFunctions.dec_XTDP_Message(f_EPTF_UIHandler_getRawMsg_XTDP(pl_msg), v_UIHandler_receivedMessage);
|
| //action(%definitionId&":v_UIHandler_receivedMessage: ", v_UIHandler_receivedMessage);
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Message arrived for client "&log2str(vl_connId)&": "&log2str(v_UIHandler_receivedMessage));
|
| }
|
|
|
| if (v_UIHandler_cleanupCalled) {
|
| if(not ischosen(v_UIHandler_receivedMessage.choice.xTDP_Bye)) {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Message arrived during cleanup: Message dropped");
|
| }
|
| return;
|
| }
|
| }
|
|
|
| // drop messages that come before handshake or authentication:
|
| if(not ischosen(v_UIHandler_receivedMessage.choice.xTDP_HandshakeRequest)) {
|
| // handshake is required:
|
| if (not f_EPTF_UIHandler_getClientHandshakeSuccessful(vl_connId)) {
|
| // there was no successful handshake
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Message arrived for client "&log2str(vl_connId)&" before successful handshake. Message dropped: "&log2str(v_UIHandler_receivedMessage));
|
| }
|
| return;
|
| }
|
| }
|
| if(not ischosen(v_UIHandler_receivedMessage.choice.xTDP_AuthResponse)
|
| and not ischosen(v_UIHandler_receivedMessage.choice.xTDP_HandshakeRequest)
|
| and not ischosen(v_UIHandler_receivedMessage.choice.xTDP_Bye)) {
|
| // authentication is required:
|
| if (not f_EPTF_UIHandler_getClientAuthenticationSuccessful(vl_connId)) {
|
| // there was no successful authentication
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Message arrived for client "&log2str(vl_connId)&" before successful authentication. Message dropped: "&log2str(v_UIHandler_receivedMessage));
|
| }
|
| return;
|
| }
|
| }
|
|
|
| if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_Requests))
|
| {
|
| if(match(v_UIHandler_receivedMessage.choice.xTDP_Requests, tr_XTDP_Requests_exitTTCNButtonPressed))
|
| {
|
| f_EPTF_Semaphore_unlock(v_UIHandler_exitButtonPressedSemaphore);
|
| }
|
| if(match(v_UIHandler_receivedMessage.choice.xTDP_Requests, tr_XTDP_Requests_widgetModification(?, ?)))
|
| {
|
| const ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message vl_messageToSend :=
|
| {
|
| // noNamespaceSchemaLocation := "XTDP-Message.xsd",
|
| transactionID := omit,
|
| choice :=
|
| {
|
| xTDP_Responses :=
|
| {
|
| xTDP_Response_list := {
|
| {
|
| requestId := 1,
|
| responseCode := error_,
|
| argument := omit,
|
| errorSource := omit,
|
| errorCode := omit,
|
| errorMessage := "Modification is not possible on a shadowed GUI!"
|
| }
|
| }
|
| }
|
| }
|
| }
|
|
|
| if (v_UIHandler_GUIClientId[0].clientId != vl_connId)
|
| {
|
| var Result vl_result
|
| f_EPTF_Transport_send(IPL4, vl_connId, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false)
|
| }
|
| else
|
| {
|
| var template XTDP_Widget vl_widget
|
| f_EPTF_UIHandler_getWidgetFromXTDPAction(v_UIHandler_receivedMessage.choice.xTDP_Requests.xTDP_Request_list[0].action_, vl_widget);
|
| var EPTF_UIHandler_WidgetIdString vl_wID := "";
|
| if (isvalue(vl_widget)) {
|
| vl_wID := f_EPTF_UIHandler_XULWidgetId2charstr({valueof(vl_widget.widgetId)});
|
| }
|
| var EPTF_CharstringList vl_template_XTDP_Actions_choice_put_argument_list := f_EPTF_UIHandler_getArgumentListFromXTDPAction(v_UIHandler_receivedMessage.choice.xTDP_Requests.xTDP_Request_list[0].action_);
|
| f_EPTF_UIHandler_parseGuiParam(vl_wID, vl_template_XTDP_Actions_choice_put_argument_list);
|
| }
|
| }
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| }
|
| else if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_Responses))
|
| {
|
| if(match(v_UIHandler_receivedMessage.choice.xTDP_Responses, tr_XTDP_Responses_singleSuccessResp))
|
| {
|
| // no response needed
|
| }
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| }
|
| else if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_LayoutResponse))
|
| {
|
| f_EPTF_Semaphore_unlock(v_UIHandler_layoutResponseReceivedSemaphore);
|
| }
|
| else if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_Outcome))
|
| {
|
| if (v_UIHandler_receivedMessage.transactionID!=omit) {
|
| var integer vl_semaphoreId := v_UIHandler_receivedMessage.transactionID rem 1000;
|
| if (f_EPTF_Semaphore_isLocked(vl_semaphoreId)) {
|
| f_EPTF_Semaphore_unlock(vl_semaphoreId);
|
| if (v_UIHandler_receivedMessage.choice.xTDP_Outcome.responseCode == error_) {
|
| v_handshakeErrorMsg := "Error: UIHandler: Version compatibility check failure during handshake procedure: "&log2str(v_UIHandler_receivedMessage.choice.xTDP_Outcome);
|
| }
|
| }
|
| }
|
| }
|
| else if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_HandshakeRequest))
|
| {
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message vl_messageToSend := {
|
| transactionID := v_UIHandler_receivedMessage.transactionID,
|
| choice := {
|
| xTDP_Outcome := {
|
| responseCode := success,
|
| errorCode_list := {
|
| },
|
| errorMessage := omit
|
| ,elem_list := {}
|
| }
|
| }
|
| }
|
| if (
|
| v_UIHandler_receivedMessage.choice.xTDP_HandshakeRequest.xtdpRequiredVersion != c_EPTF_UIHandler_xtdpMyVersion
|
| or v_UIHandler_receivedMessage.choice.xTDP_HandshakeRequest.xtdlRequiredVersion != c_EPTF_UIHandler_xtdlMyVersion
|
| ) {
|
| // version mismatch
|
| vl_messageToSend := {
|
| transactionID := v_UIHandler_receivedMessage.transactionID,
|
| choice := {
|
| xTDP_Outcome := {
|
| responseCode := error_,
|
| errorCode_list := {
|
| },
|
| errorMessage := "Version mismatch detected during handshake. Suppored XTDP/XDTL versions: "
|
| &log2str(c_EPTF_UIHandler_xtdpMyVersion)&"/"&log2str(c_EPTF_UIHandler_xtdlMyVersion)
|
| ,elem_list := {}
|
| }
|
| }
|
| }
|
| // add error codes:
|
| if (v_UIHandler_receivedMessage.choice.xTDP_HandshakeRequest.xtdpRequiredVersion != c_EPTF_UIHandler_xtdpMyVersion) {
|
| vl_messageToSend.choice.xTDP_Outcome.errorCode_list := vl_messageToSend.choice.xTDP_Outcome.errorCode_list & {xtdpIncompatibleVersion};
|
| }
|
| if (v_UIHandler_receivedMessage.choice.xTDP_HandshakeRequest.xtdlRequiredVersion != c_EPTF_UIHandler_xtdlMyVersion) {
|
| vl_messageToSend.choice.xTDP_Outcome.errorCode_list := vl_messageToSend.choice.xTDP_Outcome.errorCode_list & {xtdlIncompatibleVersion};
|
| }
|
| } else {
|
| // successful handshake
|
| f_EPTF_UIHandler_setClientHandshakeSuccessful(vl_connId);
|
| }
|
| //send response:
|
| var Result vl_result;
|
| f_EPTF_Transport_send(IPL4, vl_connId, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false);
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
|
|
| // start authentication if handshake successful:
|
| if (vl_messageToSend.choice.xTDP_Outcome.responseCode != success
|
| or not f_EPTF_UIHandler_authclient(vl_connId))
|
| {
|
| f_EPTF_UIHandler_closeXTDPSession(vl_connId);
|
| } else {
|
| // successful handshake and authentication
|
| v_UIHandler_guiConnected := true;
|
| if(sizeof(v_UIHandler_GUIClientId)==1 and sizeof(v_UIHandler_guiItemList) == 0)
|
| {
|
| // master GUI is up (first time)
|
| if("" != v_UIHandler_windowLayout or "" != tsp_EPTF_GUI_DefaultWindow or v_EPTF_UIHandler_headlessmode){
|
| // send my layout to GUI
|
| if (v_EPTF_UIHandler_headlessmode == false and not v_UIHandler_guiLayoutReady) {
|
| // reset layout to initial
|
| f_EPTF_UIHandler_clearGUI();
|
| //f_EPTF_UIHandler_createInitialLayout(v_UIHandler_windowLayout);
|
| if(null != v_EPTF_UIHandler_createLayoutCallback){
|
| v_EPTF_UIHandler_createLayoutCallback.apply( );
|
| }
|
| v_UIHandler_guiLayoutReady := true;
|
| } else {
|
| // use current layout
|
| f_EPTF_UIHandler_initguitoclient(vl_connId);
|
| }
|
| } else {
|
| //get layout from GUI
|
| if (not v_UIHandler_guiLayoutReady) {
|
| // init layout from GUI
|
| f_EPTF_UIHandler_clearInternalWidgetDB();
|
| if(not f_EPTF_UIHandler_requestLayout()){
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": f_EPTF_UIHandler_requestlayout failed!");
|
| }
|
| }
|
| v_UIHandler_guiLayoutReady := true;
|
| } else {
|
| // use current layout (Original Master GUI was closed and then restarted)
|
| f_EPTF_UIHandler_initguitoclient(vl_connId);
|
| }
|
| }
|
| }
|
| else
|
| {
|
| // slave GUI-s will contain the copy of master
|
| // restarted master GUI will contain current layout
|
| if (sizeof(v_UIHandler_GUIClientId)==1 and sizeof(v_UIHandler_guiItemList) != 0){
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Master GUI restarted. Sending current layout...");
|
| }
|
| f_EPTF_UIHandler_initguitoclient(vl_connId);
|
| } else {
|
| f_EPTF_UIHandler_initguitoclient(vl_connId,true); // Shadowed GUI
|
| }
|
| }
|
| }
|
|
|
| }
|
| else if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_AuthChallenge))
|
| {
|
| // send response
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message vl_messageToSend :=
|
| {
|
| // noNamespaceSchemaLocation := "XTDP-Message.xsd",
|
| transactionID := v_UIHandler_receivedMessage.transactionID,
|
| choice := {
|
| xTDP_AuthResponse := v_EPTF_UIHandler_Authresp
|
| }
|
| }
|
| var Result vl_result;
|
| f_EPTF_Transport_send(IPL4, vl_connId, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false)
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| }
|
| else if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_AuthResponse))
|
| {
|
| if (v_UIHandler_receivedMessage.transactionID!=omit) {
|
| var integer vl_semaphoreId := v_UIHandler_receivedMessage.transactionID rem 1000;
|
| if (f_EPTF_Semaphore_isLocked(vl_semaphoreId)) {
|
| f_EPTF_Semaphore_unlock(vl_semaphoreId);
|
| }
|
| }
|
| }
|
| else if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_Bye))
|
| {
|
| if (v_UIHandler_receivedMessage.transactionID!=omit) {
|
| var integer vl_semaphoreId := v_UIHandler_receivedMessage.transactionID rem 1000;
|
| if (v_UIHandler_byeTimer == vl_semaphoreId) {
|
| // response to my bye msg
|
| f_EPTF_Semaphore_unlock(vl_semaphoreId);
|
| return;
|
| }
|
| }
|
| //send bye response:
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message vl_messageToSend :=
|
| {
|
| // noNamespaceSchemaLocation := "XTDP-Message.xsd",
|
| transactionID := v_UIHandler_receivedMessage.transactionID,
|
| choice := {
|
| xTDP_Bye := ""
|
| }
|
| }
|
| var Result vl_result;
|
| f_EPTF_Transport_send(IPL4, vl_connId, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false)
|
|
|
| // restart semaphore timer if it is running:
|
| if (f_EPTF_Semaphore_isLocked(v_UIHandler_byeTimer)) {
|
| // semaphore is locked => timer is running
|
| // increase semaphore lock until restarted timer expires:
|
| timer t_semaphoreWait := v_byeMaxTime;
|
| t_semaphoreWait.start;
|
| f_EPTF_Semaphore_increaseLock(v_UIHandler_byeTimer);
|
| t_semaphoreWait.timeout;
|
| f_EPTF_Semaphore_decreaseLock(v_UIHandler_byeTimer);
|
| }
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| }
|
| else if(ischosen(v_UIHandler_receivedMessage.choice.xTDP_ARResponses))
|
| {
|
| //FIXME:
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| }
|
| else
|
| {
|
| f_EPTF_UIHandler_warning("Unexpected XTDP message received: "&log2str(v_UIHandler_receivedMessage));
|
| // send unsupported procedure response:
|
| var ttcn_ericsson_se_protocolModules_xtdp_xtdp.XTDP_Message vl_messageToSend := {
|
| transactionID := v_UIHandler_receivedMessage.transactionID,
|
| choice := {
|
| xTDP_Outcome := {
|
| responseCode := error_,
|
| errorCode_list := {
|
| procedureUnsupported
|
| },
|
| errorMessage := omit
|
| ,elem_list := {}
|
| }
|
| }
|
| }
|
| var Result vl_result;
|
| f_EPTF_Transport_send(IPL4, vl_connId, f_EPTF_UIHandler_appendLength_XTDP(XTDP_EncDecFunctions.enc_XTDP_Message(vl_messageToSend)), vl_result, false)
|
|
|
| f_EPTF_Semaphore_unlock(v_UIHandler_xtdpReceivedMessageSemaphore_r);
|
| }
|
| }
|
|
|
| friend function f_EPTF_UIHandler_layoutReady() runs on EPTF_UIHandler_Private_CT return boolean {
|
| if (v_UIHandler_windowLayout != "" or v_EPTF_UIHandler_headlessmode == true) {
|
| return true;
|
| } else {
|
| return v_UIHandler_guiLayoutReady;
|
| }
|
| }
|
|
|
| friend function f_EPTF_UIHandler_waitForLayoutReady() runs on EPTF_UIHandler_Private_CT {
|
| if (f_EPTF_UIHandler_layoutReady()) {
|
| return;
|
| }
|
| timer t_waitForLayoutReady := 0.0;
|
| t_waitForLayoutReady.start;
|
| alt {
|
| [f_EPTF_UIHandler_layoutReady()] t_waitForLayoutReady.timeout {
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_HandleEvent_XTDP
|
| //
|
| // Purpose:
|
| // The event handler function.
|
| //
|
| // Detailed Comments:
|
| // Calls the registered call-back function.
|
| ///////////////////////////////////////////////////////////////////////////////
|
| function f_EPTF_UIHandler_HandleEvent_XTDP(
|
| in EPTF_Transport_TransportType pl_transportType,
|
| in ConnectionId pl_connId,
|
| in PortEvent pl_event)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if (not v_UIHandler_initialized) {
|
| return;
|
| }
|
| //action(%definitionId&": XTDP event received: ",pl_event);
|
| if(ischosen(pl_event.connOpened))
|
| {
|
| // I am XTDP-session server. Always!!! => wait for handshake request => nothing to do here
|
| // var charstring vl_handshakeError:=f_EPTF_UIHandler_handshake(v_EPTF_CommPort_IPL4_incomingMessage.asp_Event.connOpened.connId);
|
| // if (vl_handshakeError!="") {
|
| // // handshake unsuccessful
|
| // return;
|
| // }
|
| //
|
| // if (not f_EPTF_UIHandler_authclient(v_EPTF_CommPort_IPL4_incomingMessage.asp_Event.connOpened.connId))
|
| // {
|
| // f_EPTF_UIHandler_closeXTDPSession(v_EPTF_CommPort_IPL4_incomingMessage.asp_Event.connOpened.connId);
|
| // return;
|
| // }
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&log2str(": GUI connected: ", pl_event.connOpened.connId));
|
| }
|
| f_EPTF_UIHandler_addclientid(pl_event.connOpened.connId);
|
| // v_UIHandler_guiConnected := true;
|
| // if(sizeof(v_UIHandler_GUIClientId)==1)
|
| // {
|
| // f_EPTF_UIHandler_headlessmodeover();
|
| // }
|
| // else
|
| // {
|
| // f_EPTF_UIHandler_initguitoclient(pl_event.connOpened.connId);
|
| // }
|
| }
|
| else if(ischosen(pl_event.connClosed))
|
| {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Transport is closed for client: "&log2str(pl_event.connClosed.connId));
|
| }
|
| //if(v_EPTF_UIHandler_headlessmode)
|
| //{
|
| f_EPTF_UIHandler_delclientid(pl_event.connClosed.connId);
|
| if (f_EPTF_Semaphore_isLocked(v_UIHandler_byeTimer)) {
|
| f_EPTF_Semaphore_unlock(v_UIHandler_byeTimer)
|
| }
|
| if (sizeof(v_UIHandler_GUIClientId) == 0)
|
| {
|
| f_EPTF_UIHandler_headlessmode();
|
| }
|
| //}
|
| }
|
| else if(ischosen(pl_event.result))
|
| {
|
| if(pl_event.result.errorCode == ERROR_AVAILABLE)
|
| {
|
| v_EPTF_CommPort_IPL4_incomingMessage.asp_Event := pl_event; // Artifact artf195095 : CLL - faulty IPl4 event handler?
|
| f_EPTF_TransportIPL4_defaultConnResultEventHandler();
|
| // I am XTDP-session server. Always!!! => wait for handshake request => nothing to do here
|
| if (not f_EPTF_UIHandler_isConnectedClientid(pl_event.result.connId)) {
|
|
|
| // // Handshake handling:
|
| // var charstring vl_handshakeError:=f_EPTF_UIHandler_handshake(v_EPTF_CommPort_IPL4_incomingMessage.asp_Event.result.connId);
|
| // if (vl_handshakeError!="") {
|
| // // handshake unsuccessful
|
| // return;
|
| // }
|
| //
|
| // if (not f_EPTF_UIHandler_authclient(pl_event.result.connId))
|
| // {
|
| // f_EPTF_UIHandler_closeXTDPSession(pl_event.result.connId);
|
| // return;
|
| // }
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&log2str(": GUI connected: ", pl_event.result.connId));
|
| }
|
| f_EPTF_UIHandler_addclientid(pl_event.result.connId);
|
| // v_UIHandler_guiConnected := true;
|
| // f_EPTF_UIHandler_headlessmodeover();
|
| }
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getMsgLen_XTDP
|
| //
|
| // Purpose:
|
| // Function to get the length of the received XTDP message
|
| //
|
| // Parameters:
|
| // stream - *in octetstring* - The received message
|
| // args - *in* - <ro_integer> - Function arguments
|
| //
|
| // Return Value:
|
| // integer - the length of the received message
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_UIHandler_getMsgLen_XTDP
|
| (
|
| in EPTF_Transport_TransportType pl_transportType,
|
| in octetstring pl_stream,
|
| inout EPTF_IntegerList pl_args
|
| )
|
| return integer
|
| {
|
| if (lengthof(pl_stream)<4)
|
| {
|
| return -1
|
| }
|
| else
|
| {
|
| return oct2int(substr(pl_stream,0, 4))
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getRawMsg_XTDP
|
| //
|
| // Purpose:
|
| // Function to get the raw XTDP message without the length
|
| //
|
| // Parameters:
|
| // stream - *in octetstring* - The received message
|
| //
|
| // Return Value:
|
| // octetstring - raw XTDP message
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_UIHandler_getRawMsg_XTDP(in octetstring stream) return octetstring
|
| {
|
| if (lengthof(stream) <4) {
|
| return ''O
|
| } else {
|
| return substr(stream,4, lengthof(stream)-4)
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendLength_XTDP
|
| //
|
| // Purpose:
|
| // Function to append the length to the encoded XTDP message
|
| //
|
| // Parameters:
|
| // stream - *in octetstring* - The received message
|
| //
|
| // Return Value:
|
| // octetstring - raw XTDP message
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_UIHandler_appendLength_XTDP(in octetstring stream) return octetstring
|
| {
|
| return int2oct(lengthof(stream)+4,4) & stream
|
| }
|
|
|
| } //group Transport funstions
|
|
|
| group simulation {
|
|
|
|
|
| private function f_EPTF_UIHandler_simulation_getData(
|
| out charstring pl_dataVarName,
|
| in charstring pl_source,
|
| in charstring pl_ptcName := "",
|
| in charstring pl_element,
|
| in EPTF_DataSource_Params pl_params := {},
|
| in EPTF_Var_SubscriptionMode pl_subscriptionMode := tsp_EPTF_UIHandler_subscriptionMode,
|
| in integer pl_refreshRate := tsp_EPTF_DataSource_refreshRate,
|
| in EPTF_Var_DirectContent vl_defaultValue
|
| ) runs on EPTF_UIHandler_Private_CT return integer {
|
| var integer vl_getDataResult := f_EPTF_DataSource_getData(pl_dataVarName, pl_source, pl_ptcName, pl_element, pl_params, pl_subscriptionMode, pl_refreshRate);
|
| if(vl_getDataResult == 0) {
|
|
|
| if(v_EPTF_UIHandler_simulation_buildDB_file != "") {
|
| var integer vl_simulationDBIdx;
|
| var charstring vl_simulation_id := "";
|
| var integer vl_params_size := sizeof(pl_params);
|
| for(var integer i := 0; i < vl_params_size; i := i + 1 ){
|
| vl_simulation_id := vl_simulation_id & "." & pl_params[i].paramName;
|
| vl_simulation_id := vl_simulation_id & "." & pl_params[i].paramValue;
|
| }
|
| vl_simulation_id:= "simulation." & pl_source & "." & pl_ptcName & "." & pl_element & "." & vl_simulation_id;
|
| if(not f_EPTF_str2int_HashMap_Find(v_UIHandler_simulation_varsHashMapId, vl_simulation_id, vl_simulationDBIdx)) {
|
| var integer vl_directContentDB_size := sizeof(v_UIHandler_simulation_directContentDB);
|
| var integer vl_varId := f_EPTF_Var_getId(pl_dataVarName);
|
| var EPTF_Var_DirectContent vl_currentContent;
|
| f_EPTF_Var_getContent(vl_varId, vl_currentContent);
|
| v_UIHandler_simulation_directContentDB[vl_directContentDB_size].directContent := vl_currentContent;
|
| v_UIHandler_simulation_directContentDB[vl_directContentDB_size].key := vl_simulation_id;
|
| f_EPTF_str2int_HashMap_Insert(v_UIHandler_simulation_varsHashMapId, vl_simulation_id, vl_directContentDB_size);
|
| }
|
| }
|
| return vl_getDataResult;
|
| } else if(v_EPTF_UIHandler_simulatonMode) {
|
| //get the data from DB
|
| if(f_EPTF_UIHandler_simulation_getDataFromDB(pl_dataVarName, pl_source, pl_ptcName, pl_element, pl_params) == 0) {
|
| return 0;
|
| } else { //create random data to simulate
|
| pl_dataVarName := log2str(vl_defaultValue);
|
| if(f_EPTF_Var_getId(pl_dataVarName) == -1) {
|
| f_EPTF_Var_newVar(log2str(vl_defaultValue), vl_defaultValue)
|
| }
|
| return 0;
|
| }
|
| } else {
|
| return vl_getDataResult;
|
| }
|
| return vl_getDataResult;
|
| }
|
|
|
|
|
| private function f_EPTF_UIhandler_simulation_getCondition(
|
| out boolean pl_conditionValue,
|
| in charstring pl_source,
|
| in charstring pl_ptcName := "",
|
| in charstring pl_method,
|
| in EPTF_DataSource_Params pl_params := {}
|
| ) runs on EPTF_UIHandler_Private_CT return integer {
|
| var integer vl_getDataResult := f_EPTF_DataSource_getCondition(pl_conditionValue, pl_source, pl_ptcName, pl_method, pl_params);
|
| var charstring pl_dataVarName := "";
|
| if(vl_getDataResult == 0) {
|
| if(v_EPTF_UIHandler_simulation_buildDB_file != "") {
|
| var integer vl_simulationDBIdx;
|
| var charstring vl_simulation_id := "";
|
| var integer vl_params_size := sizeof(pl_params);
|
| for(var integer i := 0; i < vl_params_size; i := i + 1 ){
|
| vl_simulation_id := vl_simulation_id & "." & pl_params[i].paramName;
|
| vl_simulation_id := vl_simulation_id & "." & pl_params[i].paramValue;
|
| }
|
| vl_simulation_id:= "simulation." & pl_source & "." & pl_ptcName & "." & "condition" & "." & vl_simulation_id;
|
| if(not f_EPTF_str2int_HashMap_Find(v_UIHandler_simulation_varsHashMapId, vl_simulation_id, vl_simulationDBIdx)) {
|
| var integer vl_directContentDB_size := sizeof(v_UIHandler_simulation_directContentDB);
|
| var integer vl_varId;
|
| f_EPTF_Var_newBool(vl_simulation_id, pl_conditionValue, vl_varId)
|
| var EPTF_Var_DirectContent vl_currentContent;
|
| f_EPTF_Var_getContent(vl_varId, vl_currentContent);
|
| v_UIHandler_simulation_directContentDB[vl_directContentDB_size].directContent := vl_currentContent;
|
| v_UIHandler_simulation_directContentDB[vl_directContentDB_size].key := vl_simulation_id;
|
| f_EPTF_str2int_HashMap_Insert(v_UIHandler_simulation_varsHashMapId, vl_simulation_id, vl_directContentDB_size);
|
| }
|
| }
|
| return vl_getDataResult;
|
| } else if(v_EPTF_UIHandler_simulatonMode) {
|
| //get the data from DB
|
| if(f_EPTF_UIHandler_simulation_getDataFromDB(pl_dataVarName, pl_source, pl_ptcName, "condition", pl_params) == 0) {
|
| var integer vl_varId := f_EPTF_Var_getId(pl_dataVarName);
|
| pl_conditionValue := f_EPTF_Var_getBoolValue(vl_varId);
|
| return 0;
|
| } else { //create random data to simulate?
|
| pl_conditionValue := true;
|
| return 0;
|
| }
|
| } else {
|
| return vl_getDataResult;
|
| }
|
| return vl_getDataResult;
|
| }
|
|
|
| private function f_EPTF_UIhandler_simulation_getDefaultValue(in EPTF_UIHandler_GuiItemRec pl_widgetRec, out EPTF_Var_DirectContent vl_defaultValue) {
|
| if(ispresent(pl_widgetRec.widgetDataType)) {
|
| if(pl_widgetRec.widgetDataType == checkBox) {
|
| vl_defaultValue := { boolVal := true };
|
| } else if(pl_widgetRec.widgetDataType == floatField) {
|
| vl_defaultValue := { floatVal := 1.1 };
|
| // NOT SUPPORTED:
|
| //} else if(pl_widgetRec.widgetDataType == image) {
|
| // vl_defaultValue := { intVal := 1 };
|
| } else if(pl_widgetRec.widgetDataType == integerField) {
|
| vl_defaultValue := { intVal := 1 };
|
| } else if(pl_widgetRec.widgetDataType == none_) {
|
| vl_defaultValue := { charstringVal := "my_value" };
|
| } else if(pl_widgetRec.widgetDataType == pushButton) {
|
| vl_defaultValue := { intVal := 1 };
|
| } else if(pl_widgetRec.widgetDataType == statusLED) {
|
| vl_defaultValue := { statusLEDVal := { led_black, "my_led" } };
|
| } else if(pl_widgetRec.widgetDataType == statusLEDWithText) {
|
| vl_defaultValue := { statusLEDVal := { led_black, "my_led" } };
|
| } else if(pl_widgetRec.widgetDataType == string) {
|
| vl_defaultValue := { charstringVal := "my_string" };
|
| } else if(pl_widgetRec.widgetDataType == toggleButton) {
|
| vl_defaultValue := { boolVal := true };
|
| } else if(pl_widgetRec.widgetDataType == trace) {
|
| vl_defaultValue := { floatVal := 1.1 };
|
| // NOT SUPPORTED:
|
| //} else if(pl_widgetRec.widgetDataType == valueList) {
|
| // vl_defaultValue := { intVal := 1 };
|
| }
|
| } else {
|
| vl_defaultValue := { charstringVal := "omit"};
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_simulation_Subscribe2saveDBButton_vars
|
| //
|
| // Purpose:
|
| // Subscribe variable to saveDB button and adds test management
|
| // post processing functions
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_simulation_Subscribe2saveDBButton_vars() runs on EPTF_UIHandler_Private_CT {
|
| var integer vl_idx;
|
| f_EPTF_Var_newInt(
|
| c_EPTF_UIHandler_simulation_saveDBToFile, 0, vl_idx);
|
| f_EPTF_Var_addPostProcFn(
|
| vl_idx, { refers(f_EPTF_UIHandler_simulation_saveDB_PostProc), {}} );
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_simulation_saveDB_PostProc
|
| //
|
| // Purpose:
|
| // Test management post proc function to save DB to file
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_simulation_saveDB_PostProc(
|
| in integer pl_idx,
|
| in EPTF_IntegerList pl_argList)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if(v_EPTF_UIHandler_simulation_buildDB_file != "") {
|
| f_EPTF_UIHandler_simulation_saveDBToFile(v_EPTF_UIHandler_simulation_buildDB_file);
|
| } else {
|
| f_EPTF_UIHandler_error(%definitionId&": FileName to save simulation Database was not given");
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_simulation_saveDBToFile(in charstring pl_fileName) runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| var integer vl_file := f_FIO_open_trunc_wronly(pl_fileName);
|
| var integer vl_retval:=-1;
|
| if(vl_file==-1){
|
| f_EPTF_UIHandler_error(%definitionId&": Couldn't open the file "&pl_fileName&".");
|
| return false;
|
| }
|
|
|
| var charstring vl_stringDB := f_EPTF_UIHandler_simulation_encode_directContentDB(v_UIHandler_simulation_directContentDB);
|
| vl_retval:=f_FIO_write_text(vl_file, vl_stringDB)
|
| if(-1 == vl_retval){
|
| f_EPTF_UIHandler_error(%definitionId&": Couldn't read the file "&pl_fileName&".");
|
| return false;
|
| }
|
|
|
| if( f_FIO_close(vl_file)==-1) {
|
| f_EPTF_UIHandler_error(%definitionId&": Could not close the file "&pl_fileName&".");
|
| return false;
|
| }
|
| return true;
|
| }
|
|
|
| function f_EPTF_UIHandler_simulation_createDBFromFile(in charstring pl_fileName, out EPTF_UIHandler_simulation_directContentDB pl_DB)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| var charstring vl_stringDB;
|
| f_EPTF_UIHandler_readFileToCharstring(pl_fileName, vl_stringDB);
|
| f_EPTF_UIHandler_simulation_decode_directContentDB(vl_stringDB, pl_DB)
|
|
|
| }
|
|
|
|
|
| private function f_EPTF_UIHandler_simulation_getDataFromDB(
|
| out charstring pl_dataVarName,
|
| in charstring pl_source,
|
| in charstring pl_ptcName := "",
|
| in charstring pl_element,
|
| in EPTF_DataSource_Params pl_params := {})
|
| runs on EPTF_UIHandler_Private_CT return integer
|
| {
|
| var charstring vl_simulation_id := "";
|
| var integer vl_Idx := -1;
|
| var integer vl_paramSize := sizeof(pl_params);
|
| for(var integer i := 0; i < vl_paramSize; i := i + 1 ){
|
| vl_simulation_id := vl_simulation_id & "." & pl_params[i].paramName;
|
| vl_simulation_id := vl_simulation_id & "." & pl_params[i].paramValue;
|
| }
|
| vl_simulation_id:= "simulation." & pl_source & "." & pl_ptcName & "." & pl_element & "." & vl_simulation_id;
|
|
|
| //if(f_EPTF_str2int_HashMap_Find(v_UIHandler_simulation_varsHashMapId, vl_simulation_id, vl_Idx)) {
|
| //variable created in init function at simulation mode. The variable name is the simulation id.
|
| if(f_EPTF_Var_getId(vl_simulation_id) != -1) {
|
| pl_dataVarName := vl_simulation_id;
|
| return 0;
|
| } else {
|
| return -1;
|
| }
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_simulation_encode_directContentDB
|
| //
|
| // Purpose:
|
| // Encodes a EPTF_UIHandler_simulation_directContentDB to its charstring representation
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public external function f_EPTF_UIHandler_simulation_encode_directContentDB(in EPTF_UIHandler_simulation_directContentDB pl_DB)
|
| return charstring;
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_simulation_decode_directContentDB
|
| //
|
| // Purpose:
|
| // Decode a charstring to EPTF_UIHandler_simulation_directContentDB
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public external function f_EPTF_UIHandler_simulation_decode_directContentDB(in charstring pl_dbStr, out EPTF_UIHandler_simulation_directContentDB pl_DB);
|
|
|
|
|
|
|
|
|
|
|
| }// /group simulation
|
|
|
|
|
| } // group PrivateFunctions
|
|
|
| group CLI{
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_init_CT
|
| // Parameters:
|
| // pl_prefix - *in charstring* - all UIHandler command-line interface
|
| // commands are prefixed with this value
|
| // Purpose:
|
| // The initialization function.
|
| ///////////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_CLIClient_init_CT(in charstring pl_prefix)
|
| runs on EPTF_UIHandler_Private_CT {
|
| //if (not v_UIHandler_CLI_initialized)
|
| {
|
| //f_EPTF_UIHandler_init_CT(pl_selfName, pl_connectGUI);
|
| //f_EPTF_Logging_init_CT(pl_selfName);
|
| //f_EPTF_CLI_Client_init_CT(pl_selfName, pl_CLI_compRef)
|
| v_UIHandler_CLI_loggingMaskId := f_EPTF_Logging_registerComponentMasks(tsp_EPTF_UIHandler_CLI_loggingComponentMask, c_EPTF_UIHandler_loggingEventClasses, EPTF_Logging_CLL);
|
| if(tsp_debug_EPTF_UIHandler_CLI_Functions) {
|
| f_EPTF_Logging_enableLocalMask(v_UIHandler_CLI_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
|
| } else {
|
| f_EPTF_Logging_disableLocalMask(v_UIHandler_CLI_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
|
| }
|
| //f_EPTF_Base_registerCleanup(refers(f_EPTF_UIHandler_CLIClient_cleanup_CT));
|
|
|
| f_EPTF_HashMap_init_CT (pl_prefix);
|
| v_UIHandler_CLI_vars2Display := f_EPTF_str2int_HashMap_New("v_UIHandler_CLI_vars2Display");
|
|
|
| if(registerOK != f_EPTF_CLI_Client_registerCommand(pl_prefix&c_UIHandler_CLIClient_commandGET, c_UIHandler_CLIClient_commandGETHelp, refers(f_EPTF_UIHandler_CLIClient_handleGET))){
|
| f_EPTF_Base_assert("Registration failed for command: ", false)
|
| }
|
| if(registerOK != f_EPTF_CLI_Client_registerCommand(pl_prefix&c_UIHandler_CLIClient_commandSET, c_UIHandler_CLIClient_commandSETHelp, refers(f_EPTF_UIHandler_CLIClient_handleSET))){
|
| f_EPTF_Base_assert("Registration failed for command: "&c_UIHandler_CLIClient_commandSET, false)
|
| }
|
| if(registerOK != f_EPTF_CLI_Client_registerCommand(pl_prefix&c_UIHandler_CLIClient_commandLS, c_UIHandler_CLIClient_commandLSHelp, refers(f_EPTF_UIHandler_CLIClient_handleLS))){
|
| f_EPTF_Base_assert("Registration failed for command: "&c_UIHandler_CLIClient_commandLS, false)
|
| }
|
| if(registerOK != f_EPTF_CLI_Client_registerCommand(pl_prefix&c_UIHandler_CLIClient_commandLSREADONLY, c_UIHandler_CLIClient_commandLSREADONLYHelp, refers(f_EPTF_UIHandler_CLIClient_handleLSREADONLY))){
|
| f_EPTF_Base_assert("Registration failed for command: "&c_UIHandler_CLIClient_commandLSREADONLY, false)
|
| }
|
| if(registerOK != f_EPTF_CLI_Client_registerCommand(pl_prefix&c_UIHandler_CLIClient_commandLSWRITABLE, c_UIHandler_CLIClient_commandLSWRITABLEHelp, refers(f_EPTF_UIHandler_CLIClient_handleLSWRITABLE))){
|
| f_EPTF_Base_assert("Registration failed for command: "&c_UIHandler_CLIClient_commandLSWRITABLE, false)
|
| }
|
| if(registerOK != f_EPTF_CLI_Client_registerCommand(pl_prefix&c_UIHandler_CLIClient_commandDISPLAY, c_UIHandler_CLIClient_commandDISPLAYHelp, refers(f_EPTF_UIHandler_CLIClient_handleDISPLAY))){
|
| f_EPTF_Base_assert("Registration failed for command: "&c_UIHandler_CLIClient_commandDISPLAY, false)
|
| }
|
| if(registerOK != f_EPTF_CLI_Client_registerCommand(pl_prefix&c_UIHandler_CLIClient_commandHIDE, c_UIHandler_CLIClient_commandHIDEHelp, refers(f_EPTF_UIHandler_CLIClient_handleHIDE))){
|
| f_EPTF_Base_assert("Registration failed for command: "&c_UIHandler_CLIClient_commandHIDE, false)
|
| }
|
|
|
| v_UIHandler_CLI_def := activate(as_UIHandler_CLIClient_main());
|
| //v_UIHandler_CLI_initialized := true;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_cleanup_CT
|
| //
|
| // Purpose:
|
| // Cleanup function of the EPTF_UIHandler_Private_CT component.
|
| //
|
| // Detailed Comments:
|
| // This function mustn't be called directly. You must call f_EPTF_Base_cleanup_CT instead.
|
| ///////////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_CLIClient_cleanup_CT()
|
| runs on EPTF_UIHandler_Private_CT {
|
| //if (v_UIHandler_CLI_initialized)
|
| {
|
| //deactivate(v_UIHandler_CLI_def);
|
| if(t_UIHandler_CLI_refresh.running){
|
| t_UIHandler_CLI_refresh.stop;
|
| }
|
| f_EPTF_str2int_HashMap_Delete("v_UIHandler_CLI_vars2Display");
|
| //unmap(self:v_UIHandler_CLI_TELNETaspIf, system:v_UIHandler_CLI_TELNETaspIf);
|
| //unmap(self:v_UIHandler_CLI_displayTELNETaspIf, system:v_UIHandler_CLI_displayTELNETaspIf);
|
| //v_UIHandler_CLI_initialized := false;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_logAll
|
| //
|
| // Purpose:
|
| // Log all internal variables in EPTF_UIHandler_Private_CT component.
|
| //
|
| // Detailed Comments:
|
| //
|
| ///////////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_CLIClient_logAll()
|
| runs on EPTF_UIHandler_Private_CT {
|
| log("------Content of EPTF_UIHandler_CLIClient_CT: -------");
|
| //log("v_UIHandler_CLI_initialized: ", v_UIHandler_CLI_initialized);
|
| log("v_UIHandler_CLI_clientConnected: ", v_UIHandler_CLI_clientConnected);
|
| log("v_UIHandler_CLI_displayConnected: ", v_UIHandler_CLI_displayConnected);
|
| log("v_UIHandler_CLI_vars2Display: ", v_UIHandler_CLI_vars2Display);
|
| log("------Finished Content of EPTF_UIHandler_CLIClient_CT -------");
|
| }//f_
|
|
|
| friend function f_EPTF_UIHandler_CLIClient_displayVarContent(in charstring pl_msg)
|
| runs on EPTF_UIHandler_Private_CT {
|
| f_EPTF_CLI_Client_sendCommandDisplay(c_UIHandler_CLIClient_commandDISPLAY, pl_msg)
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_refreshTimeout
|
| // Purpose:
|
| // Periodically displays the variables.
|
| ///////////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_CLIClient_refreshTimeout() runs on EPTF_UIHandler_Private_CT {
|
| if(v_UIHandler_CLI_displayConnected){
|
| var charstring vl_varName;
|
| var boolean vl_hasItem := f_EPTF_str2int_HashMap_Begin(v_UIHandler_CLI_vars2Display, vl_varName);
|
| //log(vl_varName);
|
| while(vl_hasItem){
|
| var integer vl_varIdx;
|
| if(not f_EPTF_str2int_HashMap_Find(v_UIHandler_CLI_vars2Display, vl_varName, vl_varIdx)){
|
| f_EPTF_UIHandler_CLIClient_error(log2str("Fatal hashmap error displaying variable ",vl_varName));
|
| //f_EPTF_Base_stop();
|
| }
|
| var EPTF_Var_DirectContent vl_content;
|
| f_EPTF_Var_getContent(vl_varIdx, vl_content);
|
| f_EPTF_UIHandler_CLIClient_displayVarContent( f_UIHandler_CLIClient_varContentAnswer(vl_varName, f_EPTF_Var_directContent2str(vl_content)))
|
| vl_hasItem := f_EPTF_str2int_HashMap_Next(v_UIHandler_CLI_vars2Display, vl_varName)
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_CLIClient_main
|
| // Purpose:
|
| // The main altstep.
|
| ///////////////////////////////////////////////////////////////
|
| friend altstep as_UIHandler_CLIClient_main() runs on EPTF_UIHandler_Private_CT {
|
| [] as_UIHandler_CLIClient_handleRefreshTimeout(){repeat;}
|
| // [] as_UIHandler_CLI_handleTelnetCmd(){repeat;}
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Altstep: as_UIHandler_CLIClient_handleRefreshTimeout
|
| // Purpose:
|
| // The periodic refresh.
|
| ///////////////////////////////////////////////////////////////
|
| friend altstep as_UIHandler_CLIClient_handleRefreshTimeout() runs on EPTF_UIHandler_Private_CT {
|
| [] t_UIHandler_CLI_refresh.timeout{
|
| f_EPTF_UIHandler_CLIClient_refreshTimeout();
|
| t_UIHandler_CLI_refresh.start( ts_CLI_refreshRate );
|
| }
|
| }
|
|
|
| friend function f_EPTF_UIHandler_CLIClient_var2str(in integer pl_varIdx)
|
| runs on EPTF_UIHandler_Private_CT
|
| return charstring
|
| {
|
| var EPTF_Var_DirectContent vl_content;
|
| f_EPTF_Var_getContent(pl_varIdx, vl_content);
|
| if(ischosen(vl_content.intVal)) {
|
| return int2str(vl_content.intVal);
|
| } else if(ischosen(vl_content.floatVal)) {
|
| return float2str(vl_content.floatVal);
|
| } else if(ischosen(vl_content.boolVal)) {
|
| if(vl_content.boolVal) { return "true"; }
|
| else { return "false"; }
|
| } else if(ischosen(vl_content.charstringVal)) {
|
| return vl_content.charstringVal;
|
| } else if(ischosen(vl_content.octetstringVal)) {
|
| return oct2str(vl_content.octetstringVal);
|
| } else if(ischosen(vl_content.hexstringVal)) {
|
| return hex2str(vl_content.hexstringVal);
|
| } else if(ischosen(vl_content.bitstringVal)) {
|
| return bit2str(vl_content.bitstringVal);
|
| } else if(ischosen(vl_content.integerlistVal)) {
|
| return log2str(vl_content.integerlistVal);
|
| } else if(ischosen(vl_content.floatlistVal)) {
|
| return log2str(vl_content.floatlistVal);
|
| } else if(ischosen(vl_content.statusLEDVal)) {
|
| return log2str(vl_content.statusLEDVal);
|
| }
|
| return log2str(vl_content);
|
| }
|
|
|
| //FIXME
|
| public function f_EPTF_CLI_Client_split(in charstring pl_string) return EPTF_CharstringList {
|
| return f_EPTF_CLI_splitString(pl_string)
|
| }
|
|
|
| friend function f_EPTF_UIHandler_CLIClient_handleGET(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var integer vl_ret := -1
|
| var charstring vl_varName := pl_commandArgs
|
| if("" != vl_varName){
|
| var integer vl_varIdx:=f_EPTF_Var_getId(vl_varName);
|
| if (-1 < vl_varIdx) {
|
| var EPTF_Var_DirectContent vl_content;
|
| f_EPTF_Var_getContent(vl_varIdx, vl_content);
|
| pl_result := f_UIHandler_CLIClient_varContentAnswer(vl_varName, f_EPTF_Var_directContent2str(vl_content))
|
| vl_ret := 0
|
| }else{
|
| pl_result := f_UIHandler_CLIClient_errInvalidVarName(vl_varName, c_UIHandler_CLIClient_commandGET)
|
| }
|
| }else{
|
| pl_result := f_UIHandler_CLIClient_errEmptyVarName(c_UIHandler_CLIClient_commandGET)
|
| }
|
| return vl_ret
|
| }
|
|
|
| friend function f_EPTF_UIHandler_CLIClient_handleSET(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var integer vl_ret := -1
|
| // Old mechanism : simple regexp.
|
| // var charstring vl_varName := regexp(pl_commandArgs,c_UIHandler_CLI_assignExt,0);
|
| // var charstring vl_newContent := regexp(pl_commandArgs,c_UIHandler_CLI_assignExt,1);
|
|
|
| //If help is needed, return immediately.
|
| if(pl_commandArgs == "help"){
|
| pl_result := c_UIHandler_CLIClient_cmdUsage&c_UIHandler_CLIClient_setUsage;
|
| return vl_ret;
|
| }
|
|
|
| var charstring vl_varName := "";
|
| var charstring vl_newContent := "";
|
| var integer vl_startVarname := -1;
|
| var integer vl_endVarname := -1;
|
| var boolean vl_varnameWithQuot := false;
|
| var boolean vl_moreLetItEqualSignFound := false;
|
| var integer vl_letItEqualSignFound := -1;
|
| var integer vl_backslashInARowCounter := 0;
|
| var boolean vl_backslashInARowCounterResetNextTime := false;
|
|
|
| //Loop along the input string letter by letter.
|
| for(var integer i:= 0; i< lengthof(pl_commandArgs)-1; i:= i +1){
|
|
|
| //Value backslash counter reset-ed
|
| if(vl_backslashInARowCounterResetNextTime==true){
|
| vl_backslashInARowCounter := 0;
|
| vl_backslashInARowCounterResetNextTime := false;
|
| }
|
|
|
| //When a contiguous backslash sequence ends, this terminates in the next round of the loop
|
| if(vl_startVarname > -1 and vl_backslashInARowCounter > 0 and pl_commandArgs[i] != "\\" ){
|
| vl_backslashInARowCounterResetNextTime := true;
|
| }
|
|
|
| //The String has definitely started, with or without quote
|
| if(vl_startVarname == -1 and pl_commandArgs[i] != " " and pl_commandArgs[i] != "\t" ){
|
| if(pl_commandArgs[i] == "\"" and i + 1 < lengthof(pl_commandArgs)){
|
| vl_startVarname := i+1;
|
| vl_varnameWithQuot := true;
|
| } else {
|
| vl_startVarname := i;
|
| }
|
| continue;
|
| }
|
| //Quoted varname ends at the paired quote character
|
| if(pl_commandArgs[i] == "\"" and vl_varnameWithQuot==true and (vl_backslashInARowCounter mod 2 == 0)){
|
| vl_endVarname := i-1;
|
| continue;
|
| }
|
|
|
| //Count backslashes
|
| if(pl_commandArgs[i] == "\\" and vl_startVarname > -1){
|
| vl_backslashInARowCounter := vl_backslashInARowCounter + 1;
|
| continue;
|
| }
|
|
|
| //Non-quoted varname ends at last non-space character before :=
|
| if(vl_startVarname > -1 and vl_endVarname == -1 and vl_varnameWithQuot == false and (pl_commandArgs[i] == " " or pl_commandArgs[i] == "\t" )){
|
| vl_endVarname := i-1;
|
| continue;
|
| }
|
|
|
| //Not Quoted Value end reset, because a not whitespace has arrived
|
| if(vl_startVarname > -1 and vl_endVarname > -1 and i+1< lengthof(pl_commandArgs) and vl_varnameWithQuot == false
|
| and (pl_commandArgs[i] != ":" or pl_commandArgs[i+1] != "=" ) and pl_commandArgs[i] != " " and pl_commandArgs[i] !="\t" ){
|
| vl_endVarname := -1;
|
| continue;
|
| }
|
|
|
| //Non-space character after quoted varname -> parse error
|
| if(vl_startVarname > -1 and vl_endVarname > -1 and i+1< lengthof(pl_commandArgs) and vl_varnameWithQuot == true
|
| and (pl_commandArgs[i] != ":" or pl_commandArgs[i+1] != "=" ) and pl_commandArgs[i] != " " and pl_commandArgs[i] !="\t" ){
|
| break;
|
| }
|
|
|
| //Non-quoted varname ends at := if there are no spaces before :=
|
| if(vl_startVarname > -1 and vl_endVarname == -1 and i+1< lengthof(pl_commandArgs) and vl_varnameWithQuot == false
|
| and pl_commandArgs[i] == ":" and pl_commandArgs[i+1] == "="){
|
| vl_endVarname := i-1;
|
| }
|
|
|
| //A Let It Be Equal sign has come, we register it. It is used when start has been found, but no end of the string
|
| //that is not quoted but it looked it to be before.
|
| if(i+1< lengthof(pl_commandArgs) and pl_commandArgs[i] == ":" and pl_commandArgs[i+1] == "="){
|
| if(vl_letItEqualSignFound > -1){
|
| vl_moreLetItEqualSignFound := true;
|
| } else {
|
| vl_letItEqualSignFound := i;
|
| }
|
| }
|
|
|
| //The := and a valid varname start and end has been found, variable name is ready, let's find out the content.
|
| if(vl_startVarname > -1 and vl_endVarname > -1 and i+1< lengthof(pl_commandArgs) and pl_commandArgs[i] == ":" and pl_commandArgs[i+1] == "="){
|
| vl_varName := substr(pl_commandArgs,vl_startVarname,vl_endVarname-vl_startVarname+1);
|
| vl_varName := f_EPTF_Common_decodeEscapeSequence(vl_varName);
|
| vl_newContent := substr(pl_commandArgs,i+2,lengthof(pl_commandArgs)-i-2);
|
| vl_newContent := f_EPTF_UIHandler_CLIClient_clearStringFromStartAndEndWhiteSpaces(vl_newContent);
|
| break;
|
| }
|
| }
|
|
|
| //If we found the start of the variable name, but not the end, than it is probably the case, that
|
| //we thought that it is a quoted variable name, but it isn't. Try the other way, the quot is the part of the variable name
|
| if( vl_startVarname > -1 and vl_endVarname == -1 and vl_varName == "" and vl_newContent == ""
|
| and vl_moreLetItEqualSignFound == false and vl_letItEqualSignFound > -1){
|
|
|
| //If it was thought to be quoted, but it isn't, we put the quot alsointo the name.
|
| if(vl_varnameWithQuot==true){
|
| vl_varName := substr(pl_commandArgs,vl_startVarname-1, vl_letItEqualSignFound-vl_startVarname+1);
|
| } else {
|
| //I really don't know, if this case is possible.
|
| // remove this case, if not needed.
|
| vl_varName := substr(pl_commandArgs,vl_startVarname, vl_letItEqualSignFound-vl_startVarname);
|
| }
|
| var integer vl_i;
|
| //Remove white spaces from the back.
|
| for( vl_i := lengthof(vl_varName)-1; vl_i > 0; vl_i:= vl_i-1){
|
| if(vl_varName[vl_i] != "" and vl_varName[vl_i] != "\t"){
|
| break;
|
| }
|
| }
|
| vl_varName := substr(vl_varName, 0, vl_i);
|
| vl_varName := f_EPTF_Common_decodeEscapeSequence(vl_varName);
|
| vl_newContent := substr(pl_commandArgs,vl_letItEqualSignFound+2,lengthof(pl_commandArgs)-vl_letItEqualSignFound-2);
|
| vl_newContent := f_EPTF_UIHandler_CLIClient_clearStringFromStartAndEndWhiteSpaces(vl_newContent);
|
| }
|
|
|
| if(f_EPTF_UIHandler_CLIClient_debugEnabled()){
|
| f_EPTF_UIHandler_CLIClient_debug("SET command arrived, variable name : " & vl_varName);
|
| f_EPTF_UIHandler_CLIClient_debug("SET command arrived, variable content : " & vl_newContent);
|
| }
|
|
|
| if("" != vl_varName and "" != vl_newContent){
|
| //var charstring vl_varName := vl_args[0]
|
| //var charstring vl_newContent := vl_args[1]
|
| var integer vl_varIdx:=f_EPTF_Var_getId(vl_varName);
|
| if (-1 < vl_varIdx) {
|
| if(f_EPTF_UIHandler_isGuiVarEditable(vl_varIdx)) {
|
| if(f_EPTF_UIHandler_parseParamValue(vl_varIdx, vl_newContent)){
|
| //f_EPTF_CLI_Client_sendCommandDisplay(c_UIHandler_CLIClient_commandSET,
|
| pl_result := f_UIHandler_CLIClient_setContentOK(vl_varName,vl_newContent)
|
| //log(%definitionId,": pl_result==",pl_result)
|
| vl_ret := 0
|
| }else{
|
| pl_result := f_UIHandler_CLIClient_errInvalidContent(vl_newContent, c_UIHandler_CLIClient_commandSET)
|
| }
|
| } else {
|
| pl_result := f_UIHandler_CLIClient_errVarIsReadonly(vl_varName)
|
| }
|
| }else{
|
| pl_result := f_UIHandler_CLIClient_errInvalidVarName(vl_varName, c_UIHandler_CLIClient_commandSET)
|
| }
|
| }else{
|
| pl_result := c_UIHandler_CLIClient_cmdUsage&c_UIHandler_CLIClient_setUsage;
|
| }
|
| return vl_ret
|
| }
|
|
|
| private function f_EPTF_UIHandler_CLIClient_clearStringFromStartAndEndWhiteSpaces (
|
| in charstring pl_stringToStrip) return charstring{
|
| var charstring vl_newContent := pl_stringToStrip
|
| var integer vl_startValue := -1;
|
| var integer vl_endValue := -1;
|
| var boolean vl_valueWithQuot := false;
|
| var integer vl_valueBackslashInARowCounter := 0;
|
| var boolean vl_valueBackslashInARowCounterResetNextTime := false;
|
| //Go throug all the letters in the input string);
|
| for(var integer j:= 0; j< lengthof(vl_newContent); j:= j +1){
|
| //Value backslash counter reset-ed
|
| if(vl_valueBackslashInARowCounterResetNextTime==true){
|
| vl_valueBackslashInARowCounter := 0;
|
| vl_valueBackslashInARowCounterResetNextTime := false;
|
| }
|
|
|
| //When a contiguous backslash sequence ends, this terminates in the next round of the loop
|
| if(vl_startValue > -1 and vl_valueBackslashInARowCounter > 0 and vl_newContent[j] != "\\" ){
|
| vl_valueBackslashInARowCounterResetNextTime := true;
|
| }
|
| //The String has definitely started, with or without quote
|
| if(vl_startValue == -1 and vl_newContent[j] != " " and vl_newContent[j] != "\t" ){
|
| if(vl_newContent[j] == "\"" and j + 1 < lengthof(vl_newContent)){
|
| //Quoted Value start
|
| vl_startValue := j+1;
|
| vl_valueWithQuot := true;
|
| } else {
|
| //Not Quoted Value start
|
| vl_startValue := j;
|
| }
|
| continue;
|
| }
|
|
|
| //Quoted varname ends at the paired quote character
|
| if(vl_newContent[j] == "\"" and vl_valueWithQuot==true and (vl_valueBackslashInARowCounter mod 2 == 0)){
|
| vl_endValue := j-1;
|
| continue;
|
| }
|
|
|
| //Count backslashes
|
| if(vl_newContent[j] == "\\" and vl_startValue > -1){
|
| vl_valueBackslashInARowCounter := vl_valueBackslashInARowCounter + 1;
|
| continue;
|
| }
|
|
|
| //Not Quoted Value probably end, but not sure, it depends on the forthcomming letters
|
| if(vl_startValue > -1 and vl_valueWithQuot == false and (vl_newContent[j] == " " or vl_newContent[j] == "\t" )){
|
| if(vl_endValue == -1){
|
| vl_endValue := j-1;
|
| }
|
| continue;
|
| }
|
|
|
| //Not Quoted Value end reset, because a not whitespace has arrived
|
| if(vl_startValue > -1 and vl_endValue > -1 and vl_valueWithQuot == false and vl_newContent[j] != " " and vl_newContent[j] !="\t" ){
|
| vl_endValue := -1;
|
| continue;
|
| }
|
|
|
| //After a Quoted Value, a non-whitespace character has arrived, it will be error at the end.
|
| if(vl_startValue > -1 and vl_endValue > -1 and j+1< lengthof(vl_newContent) and vl_valueWithQuot == true
|
| and vl_newContent[j] != " " and vl_newContent[j] !="\t" ){
|
| vl_startValue := -1;
|
| vl_endValue := -1;
|
| break;
|
| }
|
|
|
| }
|
|
|
| //After examing all letters, endvalue not found. This means that we thought that this is a quoted string, but it isn't
|
| //or the string ends with a value character.
|
| if( vl_endValue == -1){
|
| if(vl_valueWithQuot == true and vl_startValue > 0){ vl_startValue:= vl_startValue-1;}
|
| vl_endValue := lengthof(vl_newContent)-1;
|
| }
|
|
|
| //Get the value if possible, do the decode of the Escape Sequences
|
| if(vl_startValue > -1 and vl_endValue-vl_startValue+1 > 0){
|
| vl_newContent := substr(vl_newContent,vl_startValue,vl_endValue-vl_startValue+1);
|
| vl_newContent := f_EPTF_Common_decodeEscapeSequence(vl_newContent);
|
| } else {
|
| vl_newContent := "";
|
| }
|
| return vl_newContent;
|
| }
|
|
|
|
|
|
|
| friend function f_EPTF_UIHandler_CLIClient_handleLS (
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var EPTF_UIHandler_OpenSubscriptions vl_subs := f_EPTF_UIHandler_openSubscriptions();
|
| var charstring vl_list := "";
|
| for(var integer i:=0;i<sizeof(vl_subs);i:=i+1) {
|
| if(i>0) { vl_list := vl_list & "\n" }
|
| vl_list := vl_list & f_EPTF_Var_getName(vl_subs[i].varIdx);
|
| vl_list := vl_list & " := ";
|
| vl_list := vl_list & f_EPTF_UIHandler_CLIClient_var2str(vl_subs[i].varIdx);
|
| }
|
| pl_result := vl_list
|
| return 0
|
| }
|
| friend function f_EPTF_UIHandler_CLIClient_handleLSREADONLY(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var EPTF_UIHandler_OpenSubscriptions vl_subs := f_EPTF_UIHandler_openSubscriptions();
|
| var charstring vl_list := "";
|
| for(var integer i:=0;i<sizeof(vl_subs);i:=i+1) {
|
| if(not f_EPTF_UIHandler_isGuiVarEditable(vl_subs[i].varIdx)) {
|
| if(lengthof(vl_list)>0) { vl_list := vl_list & "\n" }
|
| vl_list := vl_list & f_EPTF_Var_getName(vl_subs[i].varIdx);
|
| vl_list := vl_list & " := ";
|
| vl_list := vl_list & f_EPTF_UIHandler_CLIClient_var2str(vl_subs[i].varIdx);
|
| }
|
| }
|
| pl_result := vl_list
|
| return 0
|
| }
|
| friend function f_EPTF_UIHandler_CLIClient_handleLSWRITABLE(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var EPTF_UIHandler_OpenSubscriptions vl_subs := f_EPTF_UIHandler_openSubscriptions();
|
| var charstring vl_list := "";
|
| for(var integer i:=0;i<sizeof(vl_subs);i:=i+1) {
|
| if(f_EPTF_UIHandler_isGuiVarEditable(vl_subs[i].varIdx)) {
|
| if(lengthof(vl_list)>0) { vl_list := vl_list & "\n" }
|
| vl_list := vl_list & f_EPTF_Var_getName(vl_subs[i].varIdx);
|
| vl_list := vl_list & " := ";
|
| vl_list := vl_list & f_EPTF_UIHandler_CLIClient_var2str(vl_subs[i].varIdx);
|
| }
|
| }
|
| pl_result := vl_list
|
| return 0
|
| }
|
| friend function f_EPTF_UIHandler_CLIClient_handleDISPLAY(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var integer vl_ret := -1
|
| var charstring vl_varName := pl_commandArgs
|
| if("" != vl_varName){
|
| var integer vl_varIdx:=f_EPTF_Var_getId(vl_varName);
|
| if (-1 < vl_varIdx) {
|
| var integer vl_temp;
|
| if(not f_EPTF_str2int_HashMap_Find(v_UIHandler_CLI_vars2Display, vl_varName,vl_temp)){
|
| f_EPTF_str2int_HashMap_Insert(v_UIHandler_CLI_vars2Display, vl_varName, vl_varIdx);
|
| }
|
| var EPTF_Var_DirectContent vl_content;
|
| f_EPTF_Var_getContent(vl_varIdx, vl_content);
|
| pl_result := f_UIHandler_CLIClient_varContentAnswer(vl_varName, f_EPTF_Var_directContent2str(vl_content))
|
| if(not t_UIHandler_CLI_refresh.running){
|
| t_UIHandler_CLI_refresh.start( ts_CLI_refreshRate );
|
| }
|
| vl_ret := 0
|
| }else{
|
| pl_result := f_UIHandler_CLIClient_errInvalidVarName(vl_varName, c_UIHandler_CLIClient_commandDISPLAY)
|
| }
|
| }else{
|
| pl_result := f_UIHandler_CLIClient_errEmptyVarName(c_UIHandler_CLIClient_commandDISPLAY)
|
| }
|
| return vl_ret
|
| }
|
| friend function f_EPTF_UIHandler_CLIClient_handleHIDE(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var integer vl_ret := -1
|
| //Hide all the variables
|
| if(""==pl_commandArgs){
|
| f_EPTF_str2int_HashMap_Clear(v_UIHandler_CLI_vars2Display);
|
| if(t_UIHandler_CLI_refresh.running){
|
| t_UIHandler_CLI_refresh.stop;
|
| }
|
| vl_ret := 0
|
| }else{
|
| var charstring vl_varName := pl_commandArgs
|
| var integer vl_varIdx:=f_EPTF_Var_getId(vl_varName);
|
| if (-1 < vl_varIdx) {
|
| var integer vl_temp;
|
| if(f_EPTF_str2int_HashMap_Find(v_UIHandler_CLI_vars2Display, vl_varName,vl_temp)){
|
| f_EPTF_str2int_HashMap_Erase(v_UIHandler_CLI_vars2Display, vl_varName);
|
| }
|
| if(0 == f_EPTF_str2int_HashMap_Size(v_UIHandler_CLI_vars2Display)){
|
| if(t_UIHandler_CLI_refresh.running){
|
| t_UIHandler_CLI_refresh.stop;
|
| }
|
| }
|
| pl_result := f_UIHandler_CLIClient_hideAnswer(vl_varName)
|
| vl_ret := 0
|
| }else{
|
| pl_result := f_UIHandler_CLIClient_errInvalidVarName(vl_varName, c_UIHandler_CLIClient_commandHIDE)
|
| }
|
| }
|
| return vl_ret
|
| }
|
| friend function f_EPTF_UIHandler_CLIClient_handleQUIT(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var integer vl_ret := -1
|
| return vl_ret
|
| }
|
| friend function f_EPTF_UIHandler_CLIClient_handleSTOP(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| f_EPTF_Base_stopAll(none);
|
| return 0
|
| }
|
| friend function f_EPTF_UIHandler_CLIClient_handleHELP(
|
| in charstring pl_commandArgs,
|
| inout charstring pl_result)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| pl_result := c_UIHandler_CLIClient_help
|
| return 0
|
| }
|
|
|
| group Logging {
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_error
|
| //
|
| // Purpose:
|
| // Function to log an error from UIHandler_CLIClient feature.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_CLIClient_error(in charstring pl_message)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_Logging_error(true, tsp_EPTF_UIHandler_CLI_loggingComponentMask&": "&pl_message);
|
| f_EPTF_Base_stopAll();
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_warning
|
| //
|
| // Purpose:
|
| // Function to log a warning from UIHandler_CLIClient feature.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_CLIClient_warning(in @lazy charstring pl_message)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_Logging_warningV2(pl_message, v_UIHandler_CLI_loggingMaskId, {c_EPTF_UIHandler_loggingClassIdx_Warning});
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_debug
|
| //
|
| // Purpose:
|
| // Function to log a debug message from UIHandler_CLIClient feature.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_CLIClient_debug(in @lazy charstring pl_message)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_Logging_debugV2(pl_message, v_UIHandler_CLI_loggingMaskId, {c_EPTF_UIHandler_loggingClassIdx_Debug});
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_debugEnabled
|
| //
|
| // Purpose:
|
| // Function to check if debug is enabled for UIHandler_CLIClient
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // *boolean* - true if debug enabled
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| friend function f_EPTF_UIHandler_CLIClient_debugEnabled()
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean
|
| {
|
| return f_EPTF_Logging_isEnabled(v_UIHandler_CLI_loggingMaskId, c_EPTF_UIHandler_loggingClassIdx_Debug);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_CLIClient_sendUserMessage
|
| //
|
| // Purpose:
|
| // Sends a custom message to the display terminal
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_CLIClient_sendUserMessage(in charstring pl_msg)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_UIHandler_CLIClient_displayVarContent(pl_msg)
|
| }
|
| }
|
| } //CLI
|
|
|
| group UIHandler_Config{
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_readFileToCharstring
|
| //
|
| // Purpose:
|
| // Loads a XUL describing a window layout and creates the described GUI.
|
| //
|
| // Parameters:
|
| // *in charstring pl_fileName* - The name of the file to be processed
|
| // It means the window if it's empty
|
| //
|
| // Detailed Comments:
|
| // Calls the <f_EPTF_UIHandler_createGUI> function
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_readFileToCharstring(
|
| in charstring pl_fileName,
|
| out charstring pl_fileContent)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| var integer vl_file := f_FIO_open_rdonly(pl_fileName);
|
| var integer vl_retval:=-1;
|
| if(vl_file==-1){
|
| f_EPTF_UIHandler_error(%definitionId&": Couldn't open the file "&pl_fileName&".");
|
| return false;
|
| }
|
|
|
| var integer vl_from:=f_FIO_seek_home(vl_file);
|
| var integer vl_to:=f_FIO_seek_end(vl_file);
|
| if( f_FIO_seek_home(vl_file)==-1) {
|
| f_EPTF_UIHandler_error(%definitionId&": File seek error in file "&pl_fileName&".");
|
| return false;
|
| }
|
|
|
| vl_retval:=f_FIO_read_text(vl_file, pl_fileContent, vl_to-vl_from)
|
| if(-1 == vl_retval){
|
| f_EPTF_UIHandler_error(%definitionId&": Couldn't read the file "&pl_fileName&".");
|
| return false;
|
| }
|
|
|
| if( f_FIO_close(vl_file)==-1) {
|
| f_EPTF_UIHandler_error(%definitionId&": Could not close the file "&pl_fileName&".");
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_createGUIFromFile
|
| //
|
| // Purpose:
|
| // This function reads the given file and calls the
|
| // f_EPTF_UIHandler_createGUI with the processed charstring.
|
| //
|
| // Parameters:
|
| // *in charstring pl_fileName* - The name of the XUL file to be processed
|
| // *in charstring pl_parentWidgetId* - ParentId where to insert the XUL.
|
| //
|
| // Detailed Comments:
|
| // Calls the <f_EPTF_UIHandler_createGUI> function
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_createGUIFromFile(
|
| in charstring pl_fileName,
|
| in charstring pl_parentWidgetId := "")
|
| runs on EPTF_UIHandler_CT
|
| return boolean {
|
| var charstring vl_GUI := "";
|
|
|
| f_EPTF_UIHandler_readFileToCharstring(pl_fileName, vl_GUI)
|
| return f_EPTF_UIHandler_createGUI(vl_GUI, pl_parentWidgetId);
|
| }
|
|
|
|
|
| // this function is only used in EPTF_CLL_UIHandler_GUIFunctions.cc, but passed to a function reference,
|
| // but this is needed to be able to log the function ref from TTCN
|
| private external function f_EPTF_UIHandler_expand_current_iterator(
|
| //request parameters:
|
| in charstring pl_source,
|
| in charstring pl_ptcName, // response may fill this if it was ""
|
| in charstring pl_element,
|
| in EPTF_DataSource_Params pl_params,
|
| // reponse parameters:
|
| in integer pl_errorCode, // error code in the response
|
| in charstring pl_remoteDataVarName, // var name on the remote component. In case errorCode!=0: it contains the error message
|
| in EPTF_Var_CT/*EPTF_DataSourceClient_CT*/ pl_ownerCompRef,// reference to the remote component
|
| in integer pl_localDataVarId, // var Id on the local component (contains the current value, not subscribed to remote!)
|
| in EPTF_Var_DirectContent pl_dataValue, // the value of the data
|
| // user data
|
| in EPTF_IntegerList pl_userData // user specific data given at the request
|
| );
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_createGUI
|
| //
|
| // Purpose:
|
| // This function processes the given XML and resolves
|
| // iterators, externalvalues and datasources in it.
|
| //
|
| // Parameters:
|
| // *in charstring pl_xul* - The XML to process
|
| // *in charstring pl_parentWidgetId* - ParentId where to insert the xml
|
| //
|
| // Detailed Comments:
|
| // This function can be used to create a GUI based on an XML.
|
| // The XML has to be valid against the XSD of the XTDP Protocol Module.
|
| // The GUI created from the XML will be placed under the parant widget id
|
| // specified in pl_parentWidgetId parameter. Use empty string to place
|
| // the XML to the main window.
|
| // Before this function is called with an XML, all datasources in it
|
| // should be ready and all variables belonging to the data sources
|
| // should exist. The function <f_EPTF_DataSource_registerReadyCallback>
|
| // can be used to register callback functions that are called when a data source
|
| // becomes ready. Before calling <f_EPTF_UIHandler_createGUI> you have to check
|
| // that all data sources in the XML became ready.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_createGUI(in charstring pl_xul,
|
| in charstring pl_parentWidgetId := "")
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| return f_EPTF_UIHandler_createGUI_private(pl_xul, pl_parentWidgetId, true);
|
| }
|
|
|
| private external function f_EPTF_UIHandler_expandXML(out charstring pl_xulExpanded, in charstring pl_xul, in charstring pl_parentWidgetId := "") return boolean;
|
|
|
| private external function f_EPTF_UIHandler_removeXML(in charstring pl_parentWidgetId := "") return boolean;
|
|
|
| private external function f_EPTF_UIHandler_refreshedXMLforNode(in integer pl_nodePointer, out charstring pl_xulExpanded) return boolean;
|
|
|
| private external function f_EPTF_UIHandler_printAllXML();
|
|
|
| private function f_EPTF_UIHandler_createGUI_private (
|
| in charstring pl_xul,
|
| in charstring pl_parentWidgetId := "",
|
| in boolean pl_appendTo_GUI_DescriptionDB := true,
|
| in boolean pl_send_to_RTGUI := true)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if (not v_UIHandler_initialized){ return false }
|
| v_UIHandler_createGUIRunning := true;
|
| var charstring vl_expandedXML;
|
| var boolean vl_return := true;
|
| var charstring vl_progressInfo := "Creating GUI from xml under widgetId: "&pl_parentWidgetId;
|
| f_EPTF_UIHandler_updateOwnProgress(vl_progressInfo);
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Started on: " & log2str(pl_xul));
|
| }
|
| if(f_EPTF_UIHandler_expandXML(vl_expandedXML, pl_xul, pl_parentWidgetId) == true) {
|
| var integer vl_widgetParentIdx := 0;
|
| var boolean vl_clearGui := false;
|
| if("" != pl_parentWidgetId){
|
| vl_widgetParentIdx := f_EPTF_UIHandler_widgetRecIndex(pl_parentWidgetId);
|
| if(-1 == vl_widgetParentIdx){
|
| f_EPTF_UIHandler_warning(%definitionId&": The received parent widget with ID """&pl_parentWidgetId&""" does not exist!");
|
| vl_widgetParentIdx := 0;
|
| }
|
| }
|
| if(pl_appendTo_GUI_DescriptionDB == true) {
|
| f_EPTF_UIHandler_addWidgetWithParent(pl_parentWidgetId, vl_expandedXML);
|
| }
|
| var Widgets vl_widgets := f_EPTF_UIHandler_XSD_decodeXUL(vl_expandedXML);
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Decoded widgets: " & log2str(vl_widgets));
|
| }
|
|
|
| f_EPTF_UIHandler_updateOwnProgress(vl_progressInfo&" Done.");
|
|
|
| var boolean vl_widgetExists;
|
|
|
| //If the root element is a window, clear the GUI
|
| if(ischosen(vl_widgets.window)){
|
| f_EPTF_UIHandler_clearInternalWidgetDB();
|
| vl_clearGui := true;
|
| }
|
|
|
| //var EPTF_UIHandler_WidgetsList vl_widgetslist;
|
| v_UIHandler_widgetIdxList := {}
|
| v_UIHandler_actualParentIdx := -1;
|
| v_UIHandler_actualParentIdxIsFilled := false;
|
|
|
| v_UIHandler_customGUIProcess := true;
|
| vl_return := f_EPTF_UIHandler_Config_Parse(vl_widgets,
|
| vl_widgetParentIdx,
|
| vl_widgetExists);
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Widgets after: " & log2str(vl_widgets));
|
| f_EPTF_UIHandler_debug(%definitionId&": "&f_EPTF_UIHandler_XSD_encodeXUL(vl_widgets));
|
| }
|
|
|
| if (vl_clearGui) {
|
| f_EPTF_UIHandler_clearGUI(false);
|
| }
|
|
|
| if(not v_UIHandler_initToGUIClient and pl_send_to_RTGUI){
|
|
|
| var integer vl_UIHandler_widgetIdxList_size := sizeof(v_UIHandler_widgetIdxList);
|
| for(var integer vl_i := 0; vl_i < vl_UIHandler_widgetIdxList_size; vl_i := vl_i + 1) {
|
| var integer vl_parentWidgetIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].parentIdx);
|
| var charstring vl_parentWidgetId := "";
|
| if(vl_parentWidgetIdx != -1) {
|
| vl_parentWidgetId := v_UIHandler_guiItemList[vl_parentWidgetIdx].id;
|
| }
|
| // the valuelist should only be put on the GUI if its parent (distribution chart) was not already put:
|
| if (v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType == wtValuelist) {
|
| // put only to the GUI if its parent chart is not in the v_UIHandler_widgetIdxList
|
| var boolean vl_parentWasUpdated := false;
|
| for (var integer vl_j:=vl_i-1; vl_j>=0; vl_j := vl_j - 1 ) {
|
| if (vl_parentWidgetIdx == v_UIHandler_widgetIdxList[vl_j]) {
|
| vl_parentWasUpdated := true;
|
| }
|
| }
|
| if (vl_parentWasUpdated) {
|
| continue; // vl_i
|
| }
|
| }
|
|
|
| //valuelist xulsformat is in the distribution chart, so alredy in the gui
|
| // if the xulformat is empty, that means it is intervallimits, which is inside the distribution chart and generated by buildchildrenxul below
|
| //at tree: need to build the whole tree, RTGUI doesn't support add treecell element
|
| if(ispresent(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].XULformat)) {
|
| if(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType != wtTreecell and
|
| v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType != wtTreecol) {
|
| //if(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType == wtDistributionchart or
|
| // v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType == wtTree) {
|
| var Widgets vl_xul;
|
| //buildchildrenxul cant handle window, f_EPTF_UIHandler_buildXUL makes the whole xul from the window.
|
| if(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType == wtWindow){
|
| f_EPTF_UIHandler_buildXUL(vl_xul);
|
| } else {
|
| f_EPTF_UIHandler_buildchildrenXUL(v_UIHandler_widgetIdxList[vl_i], vl_xul, true);
|
| }
|
| f_EPTF_UIHandler_XSD_addElementToGui_private(vl_xul, vl_parentWidgetId, vl_widgetExists,false);
|
| } else {
|
| var Widgets vl_xul;
|
| f_EPTF_UIHandler_buildchildrenXUL(v_UIHandler_widgetIdxList[vl_i], vl_xul, true);
|
| f_EPTF_UIHandler_XSD_addElementToGui_private(vl_xul, vl_parentWidgetId, vl_widgetExists,false);
|
| }
|
| }
|
| }
|
| }
|
|
|
| v_UIHandler_widgetIdxList := {};
|
| v_UIHandler_actualParentIdx := -1;
|
| v_UIHandler_actualParentIdxIsFilled := false;
|
|
|
| // wait to finish all getData handlers:
|
| f_EPTF_UIHandler_waitForProcessExternalData_handlers();
|
|
|
| // FIXME: if more progress info is added later, the progress variable has to be connected to the widget
|
| vl_return := f_EPTF_UIHandler_Config_connectAllVarsToWidget() and vl_return;
|
| } else {
|
| // XML Load error
|
| f_EPTF_UIHandler_error(%definitionId&": The received XML is invalid, it can not be decoded fully.\n"&
|
| "For further detailes see the log file above.");
|
| }
|
| v_UIHandler_createGUIRunning := false;
|
| return vl_return;
|
| }
|
|
|
|
|
| public function f_EPTF_UIHandler_createGUI_old (in charstring pl_xul,
|
| in charstring pl_parentWidgetId := "")
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| return f_EPTF_UIHandler_createGUI_private_old(pl_xul, pl_parentWidgetId, true);
|
| }
|
|
|
| private function f_EPTF_UIHandler_createGUI_private_old (
|
| in charstring pl_xul,
|
| in charstring pl_parentWidgetId := "",
|
| in boolean pl_appendTo_GUI_DescriptionDB := true,
|
| in boolean pl_send_to_RTGUI := true)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if (not v_UIHandler_initialized){ return false }
|
| v_UIHandler_createGUIRunning := true;
|
| var charstring vl_progressInfo := "Creating GUI from xml under widgetId: "&pl_parentWidgetId;
|
| f_EPTF_UIHandler_updateOwnProgress(vl_progressInfo);
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Started on: " & log2str(pl_xul));
|
| }
|
|
|
| var integer vl_widgetParentIdx := 0;
|
| var boolean vl_clearGui := false;
|
| if("" != pl_parentWidgetId){
|
| vl_widgetParentIdx := f_EPTF_UIHandler_widgetRecIndex(pl_parentWidgetId);
|
| if(-1 == vl_widgetParentIdx){
|
| f_EPTF_UIHandler_warning(%definitionId&": The received parent widget with ID """&pl_parentWidgetId&""" does not exist!");
|
| vl_widgetParentIdx := 0;
|
| }
|
| }
|
| if(pl_appendTo_GUI_DescriptionDB == true) {
|
| f_EPTF_UIHandler_addWidgetWithParent(pl_parentWidgetId, pl_xul);
|
| }
|
| var Widgets vl_widgets := f_EPTF_UIHandler_XSD_decodeXUL(pl_xul);
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Decoded widgets: " & log2str(vl_widgets));
|
| }
|
|
|
| f_EPTF_UIHandler_updateOwnProgress(vl_progressInfo&" Done.");
|
|
|
| var boolean vl_widgetExists;
|
|
|
| //If the root element is a window, clear the GUI
|
| if(ischosen(vl_widgets.window)){
|
| f_EPTF_UIHandler_clearInternalWidgetDB();
|
| vl_clearGui := true;
|
| }
|
|
|
| //var EPTF_UIHandler_WidgetsList vl_widgetslist;
|
| v_UIHandler_widgetIdxList := {}
|
| v_UIHandler_actualParentIdx := -1;
|
| v_UIHandler_actualParentIdxIsFilled := false;
|
| //vl_widgetParentIdx := 0;
|
| v_UIHandler_customGUIProcess := true;
|
| var boolean vl_return := f_EPTF_UIHandler_Config_Parse(vl_widgets,
|
| vl_widgetParentIdx,
|
| vl_widgetExists);
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Widgets after: " & log2str(vl_widgets));
|
| f_EPTF_UIHandler_debug(%definitionId&": "&f_EPTF_UIHandler_XSD_encodeXUL(vl_widgets));
|
| }
|
|
|
| if (vl_clearGui) {
|
| f_EPTF_UIHandler_clearGUI(false);
|
| }
|
|
|
| if(not v_UIHandler_initToGUIClient and pl_send_to_RTGUI){
|
|
|
| var integer vl_UIHandler_widgetIdxList_size := sizeof(v_UIHandler_widgetIdxList);
|
| for(var integer vl_i := 0; vl_i < vl_UIHandler_widgetIdxList_size; vl_i := vl_i + 1) {
|
| var integer vl_parentWidgetIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].parentIdx);
|
| var charstring vl_parentWidgetId := "";
|
| if(vl_parentWidgetIdx != -1) {
|
| vl_parentWidgetId := v_UIHandler_guiItemList[vl_parentWidgetIdx].id;
|
| }
|
| // the valuelist should only be put on the GUI if its parent (distribution chart) was not already put:
|
| if (v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType == wtValuelist) {
|
| // put only to the GUI if its parent chart is not in the v_UIHandler_widgetIdxList
|
| var boolean vl_parentWasUpdated := false;
|
| for (var integer vl_j:=vl_i-1; vl_j>=0; vl_j := vl_j - 1 ) {
|
| if (vl_parentWidgetIdx == v_UIHandler_widgetIdxList[vl_j]) {
|
| vl_parentWasUpdated := true;
|
| }
|
| }
|
| if (vl_parentWasUpdated) {
|
| continue; // vl_i
|
| }
|
| }
|
|
|
| //valuelist xulsformat is in the distribution chart, so alredy in the gui
|
| // if the xulformat is empty, that means it is intervallimits, which is inside the distribution chart and generated by buildchildrenxul below
|
| //at tree: need to build the whole tree, RTGUI doesn't support add treecell element
|
|
|
| if(ispresent(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].XULformat) and
|
| v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType != wtTreecell and
|
| v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType != wtTreecol) {
|
| //if(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType == wtDistributionchart or
|
| // v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType == wtTree) {
|
| var Widgets vl_xul;
|
| //buildchildrenxul cant handle window, f_EPTF_UIHandler_buildXUL makes the whole xul from the window.
|
| if(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].widgetType == wtWindow){
|
| f_EPTF_UIHandler_buildXUL(vl_xul);
|
| } else {
|
| f_EPTF_UIHandler_buildchildrenXUL(v_UIHandler_widgetIdxList[vl_i], vl_xul, true)
|
| }
|
| f_EPTF_UIHandler_XSD_addElementToGui(vl_xul, vl_parentWidgetId, vl_widgetExists,false);
|
| //} else {
|
| // f_EPTF_UIHandler_XSD_addElementToGui(v_UIHandler_guiItemList[v_UIHandler_widgetIdxList[vl_i]].XULformat, vl_parentWidgetId, vl_widgetExists,false);
|
| //}
|
| }
|
| }
|
| }
|
|
|
| v_UIHandler_widgetIdxList := {};
|
| v_UIHandler_actualParentIdx := -1;
|
| v_UIHandler_actualParentIdxIsFilled := false;
|
|
|
| // wait to finish all getData handlers:
|
| f_EPTF_UIHandler_waitForProcessExternalData_handlers();
|
|
|
| // FIXME: if more progress info is added later, the progress variable has to be connected to the widget
|
| vl_return := f_EPTF_UIHandler_Config_connectAllVarsToWidget() and vl_return;
|
| v_UIHandler_createGUIRunning := false;
|
|
|
| var integer vl_sizeof_postponedPostProcDB := sizeof(v_UIHandler_postponedPostProcDB);
|
| for(var integer vl_i := 0; vl_i < vl_sizeof_postponedPostProcDB ; vl_i := vl_i + 1){
|
| f_EPTF_UIHandler_updateMenulistItemsFromExternaldata(v_UIHandler_postponedPostProcDB[vl_i].idx, v_UIHandler_postponedPostProcDB[vl_i].argList);
|
| }
|
| v_UIHandler_postponedPostProcDB := {};
|
|
|
| return vl_return;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Config_Parse
|
| //
|
| // Purpose:
|
| // It parses the input xul into the database, replaces the iterator tags and handles datadescription tags.
|
| // Parameters:
|
| // - pl_xul - *in* <Widgets> - incoming xml
|
| // - pl_widgetsList - *out* <EPTF_UIHandler_WidgetsList> - result xml
|
| // - pl_parentIdx - *in* *integer* - the id of the parent widget under that the xul should be inserted
|
| // - pl_widgetExists - *out* *boolean* - Does any of the widgets defined in the incoming xml already exist on the GUI?
|
| //
|
| // Return Value:
|
| // *boolean* - All the widgets definied in the incoming xul is on the GUI and ready to run?
|
| //
|
| // Errors:
|
| // none
|
| //
|
| // Detailed Comments:
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Config_Parse (
|
| in Widgets pl_xul,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| var boolean vl_returnBool := false;
|
| if(ischosen(pl_xul.iterator )) {
|
| var Embeddedwidget vl_embeddedwidget := {iterator := pl_xul.iterator};
|
| return f_EPTF_UIHandler_Config_processIterator(vl_embeddedwidget, pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_xul.externalvalue )) {
|
| var Embeddedwidget vl_embeddedwidget := {externalvalue := pl_xul.externalvalue};
|
| return f_EPTF_UIHandler_Config_processIterator(vl_embeddedwidget, pl_parentIdx, true, pl_widgetExists);
|
| }
|
| else if(ischosen(pl_xul.window )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromWindow(pl_xul.window, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.tabpages )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromTabpages(pl_xul.tabpages, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.tree )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromTree(pl_xul.tree, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.treecols )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromTreecols(pl_xul.treecols.treecolgroups.treecolgroup_list, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.treecol )) {
|
| vl_returnBool := -1 != f_EPTF_UIHandler_appendTreecol(pl_xul.treecol, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.treechildren )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromTreeItemGroups(pl_xul.treechildren.treeitemgroups.treeitemgroup_list, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.treeitem )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromTreeRowGroups(pl_xul.treeitem.treerowgroups.treerowgroup_list, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.treerow )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromTreeCellGroups(pl_xul.treerow.treecellgroups.treecellgroup_list, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.treecell )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendCell(pl_xul.treecell, pl_parentIdx, pl_widgetExists, sizeof(v_UIHandler_guiItemList[pl_parentIdx].widgetData.treeData.columns)-1);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.hbox )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromHbox(pl_xul.hbox, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.label_ )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendLabel(pl_xul.label_, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.spacer )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendSpacer(pl_xul.spacer, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.button )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendButton(pl_xul.button, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
|
|
| }
|
| else if(ischosen(pl_xul.textbox )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendTextbox(pl_xul.textbox, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.chart )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendChart(pl_xul.chart, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.trace )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendTrace(pl_xul.trace, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.toolbar )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendToolbar(pl_xul.toolbar, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.toolbarbutton )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendToolbarbutton(pl_xul.toolbarbutton, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
|
|
| }
|
| else if(ischosen(pl_xul.toolbarelements )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendToolbarelements(pl_xul.toolbarelements, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.tracelist )) {
|
| var boolean vl_ret := true;
|
| for(var integer vl_i := 0; vl_i < sizeof(pl_xul.tracelist.trace_list);vl_i := vl_i + 1){
|
| vl_ret := vl_ret and f_EPTF_UIHandler_appendTrace(pl_xul.tracelist.trace_list[vl_i], pl_parentIdx, pl_widgetExists);
|
| }
|
| return vl_ret;
|
| }
|
| else if(ischosen(pl_xul.tabpage )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromTabpage(pl_xul.tabpage, pl_parentIdx, pl_widgetExists)
|
| //vl_returnBool := vl_returnBool and f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(pl_xul.tabpage.embeddedwidgets, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.listbox )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendListbox(pl_xul.listbox, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.listitem )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendListitem(pl_xul.listitem, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.numericalwidget )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendNumericalwidget(pl_xul.numericalwidget, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
|
|
| }
|
| else if(ischosen(pl_xul.menulist )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendMenulist(pl_xul.menulist, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.menuitem )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendMenuitem(pl_xul.menuitem, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.distributionchart )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendDistributionchart(pl_xul.distributionchart, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.valuelist )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendValuelist(pl_xul.valuelist, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.image )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendImage(pl_xul.image, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.pushbutton )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendPushbutton(pl_xul.pushbutton, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
|
|
| }
|
| else if(ischosen(pl_xul.togglebutton )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendTogglebutton(pl_xul.togglebutton, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
|
|
| }
|
| else if(ischosen(pl_xul.htmlcode )) {
|
| vl_returnBool := f_EPTF_UIHandler_appendHtmlcode(pl_xul.htmlcode, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| }
|
| else if(ischosen(pl_xul.tabpagelist)) {
|
| vl_returnBool := f_EPTF_UIHandler_appendAllWidgetIdsFromTabpagegroup_list(pl_xul.tabpagelist.tabpagegroups.tabpagegroup_list, pl_parentIdx, pl_widgetExists);
|
| return vl_returnBool;
|
| } else {
|
| f_EPTF_UIHandler_warning("Unhandled widget type in "&%definitionId&": "&log2str(pl_xul));
|
| return false;
|
| }
|
| return true;
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Config_processIterator
|
| //
|
| // Purpose:
|
| // It processes the Iterator widget: retrieves the iterator data from the DataSource Client - usnig the DataSource Server,
|
| // into which the client has registered previously, copies the embedded widgets according to the number of the iterator-request
|
| // result and replaces all %the iterator name%s to the current value of the iterator.
|
| // Parameters:
|
| // - pl_iterator - *in* <Iterator> - iterator widget currently processed.
|
| // - pl_result - *out* <EPTF_UIHandler_WidgetsList> - result of the function, contains the embedded widgets processed.
|
| // - pl_parentIdx - *in* *integer* - the id of the parent widget under that the xul should be inserted
|
| // - pl_widgetExists - *inout* *boolean* - Does any of the widgets defined in the intermediate xml already exist on the GUI?
|
| // - pl_isExternalValue - *in* *boolean* - Is the processed item externalvalue or iterator
|
| //
|
| // Return Value:
|
| // *boolean* - All the widgets definied in the iterator is on the GUI and ready to run?
|
| //
|
| // Errors:
|
| // Configuration Error - iterator with same name or communication error.
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Config_processIterator(
|
| in Embeddedwidget pl_embeddedWidget,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Iterator vl_iterator;
|
| var boolean vl_bool := false;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_embeddedWidget.iterator)) {
|
| vl_iterator := pl_embeddedWidget.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_embeddedWidget.externalvalue)) {
|
| vl_iterator := pl_embeddedWidget.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Embeddedwidgets vl_widgets := {embeddedwidget_list := {pl_embeddedWidget}};
|
| vl_bool := f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(vl_widgets,
|
| pl_parentIdx,
|
| pl_widgetExists);
|
| return vl_bool;
|
| }
|
|
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Started on : " & log2str(vl_iterator));
|
| }
|
|
|
| var integer vl_parentIdx;
|
| if(pl_createMetaIterator) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, iterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
| vl_bool := true; // bugfix_artf361869_empty_iterator: continue processing for empty iterator
|
| for(var integer j := 0; j < sizeof(vl_iterator.embeddedwidgets.embeddedwidget_list); j := j + 1){
|
| var Embeddedwidget vl_widget := vl_iterator.embeddedwidgets.embeddedwidget_list[j];
|
| var Embeddedwidgets vl_widgets := {embeddedwidget_list := {vl_widget}};
|
| vl_bool := f_EPTF_UIHandler_appendAllWidgetIdsFromEmbeddedwidgets(vl_widgets,
|
| vl_parentIdx,
|
| pl_widgetExists);
|
| }
|
| return vl_bool;
|
| }
|
|
|
| private external function dec_Embeddedwidgets (in octetstring p_oct, out Embeddedwidgets.embeddedwidget_list p_widgets) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Embeddedwidgets (in Embeddedwidgets.embeddedwidget_list p_widgets) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Config_processExternalData
|
| //
|
| // Purpose:
|
| // Processing externaldata tag : retrieving the Data from DataSource and DataSoureClient, after that we connect to WidgetId.
|
| // Parameters:
|
| // - pl_datadescription - *in* <Datadescription> - datadescription of the widget
|
| // - pl_widgetId - *in* *charstring* - connect datasource to the widget identied by this id
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Config_processExternalData(in Datadescription pl_datadescription,
|
| in charstring pl_widgetId)
|
| runs on EPTF_UIHandler_Private_CT{
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Started on : " & log2str(pl_datadescription));
|
| }
|
| // Ask the UIHandler about the datasource, then send him the question.
|
| var EPTF_DataSource_Params vl_dataparamList:= {};
|
| var charstring vl_varName := "";
|
| if(ispresent(pl_datadescription.params)){
|
| for(var integer i := 0; i < sizeof(pl_datadescription.params.dataparam_list); i := i + 1 ){
|
| var integer vl_dataParamsSize := sizeof(vl_dataparamList);
|
| vl_dataparamList[vl_dataParamsSize].paramName := f_unichar2charstr(pl_datadescription.params.dataparam_list[i].name); // FIXME
|
| vl_dataparamList[vl_dataParamsSize].paramValue := f_unichar2charstr(pl_datadescription.params.dataparam_list[i].value_);
|
| }
|
| }
|
| var charstring vl_source := f_unichar2charstr(pl_datadescription.source);
|
|
|
| var charstring vl_ptcname := "";
|
| if(ispresent(pl_datadescription.ptcname)){ vl_ptcname := f_unichar2charstr(pl_datadescription.ptcname)}
|
|
|
| var charstring vl_element := f_unichar2charstr(pl_datadescription.element);
|
|
|
|
|
| var integer vl_widgetRecIdx := f_EPTF_UIHandler_widgetRecIndex(pl_widgetId);
|
|
|
| v_UIHandler_nofRunning_processExternalData_handlers := v_UIHandler_nofRunning_processExternalData_handlers + 1;
|
| f_EPTF_DataSource_getData_nonBlocking(
|
| pl_source := vl_source,
|
| pl_ptcName := vl_ptcname,
|
| pl_element := vl_element,
|
| pl_params := vl_dataparamList,
|
| pl_getDataHandler := {refers(f_EPTF_UIHandler_Config_processExternalData_handler), {vl_widgetRecIdx}}
|
| );
|
|
|
| }
|
|
|
|
|
| private function f_EPTF_UIHandler_waitForProcessExternalData_handlers() runs on EPTF_UIHandler_Private_CT {
|
| timer t_maxWait := tsp_EPTF_UIHandler_maxWaitTimer;
|
| t_maxWait.start;
|
| timer t_wait := 0.0;
|
| t_wait.start;
|
| alt {
|
| [v_UIHandler_nofRunning_processExternalData_handlers==0] t_wait.timeout;
|
| [] t_maxWait.timeout {
|
| f_EPTF_UIHandler_warning(%definitionId&": ProcessExternalData_handlers are still running, but maximum waiting time expired. Continuing anyway...");
|
| }
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_GUIFunctions_waitForProcessExternalData_handlers( in integer pl_idx) runs on EPTF_UIHandler_Private_CT {
|
| timer t_wait := 0.0;
|
| t_wait.start;
|
| alt {
|
| [v_UIHandler_GUIFunctions_nofRunning_processExternalData_handlers[pl_idx]==0] t_wait.timeout;
|
| }
|
| }
|
|
|
| private function f_EPTF_UIHandler_GUIFunctions_waitForProcessExternalData_handlers_reset() runs on EPTF_UIHandler_Private_CT {
|
| v_UIHandler_GUIFunctions_nofRunning_processExternalData_handlers := {};
|
| }
|
|
|
| private function f_EPTF_UIHandler_Config_processExternalData_handler(
|
| //request parameters:
|
| in charstring pl_source,
|
| in charstring pl_ptcName, // response may fill this if it was ""
|
| in charstring pl_element,
|
| in EPTF_DataSource_Params pl_params,
|
| // reponse parameters:
|
| in integer pl_errorCode, // error code in the response
|
| in charstring pl_remoteDataVarName, // var name on the remote component. In case errorCode!=0: it contains the error message
|
| in EPTF_Var_CT/*EPTF_DataSourceClient_CT*/ pl_ownerCompRef,// reference to the remote component
|
| in integer pl_localDataVarId, // var Id on the local component (contains the current value, not subscribed to remote!)
|
| in EPTF_Var_DirectContent pl_dataValue, // the value of the data
|
| // user data
|
| in EPTF_IntegerList pl_userData // user specific data given at the request
|
| ) runs on EPTF_UIHandler_Private_CT {
|
|
|
| var integer vl_widgetRecIdx := pl_userData[0];
|
|
|
| var EPTF_UIHandler_WidgetIdString pl_widgetId := v_UIHandler_guiItemList[vl_widgetRecIdx].id;
|
| var EPTF_UIHandler_GuiItemRec vl_widgetRec;
|
| var EPTF_Var_DirectContent vl_defaultValue;
|
| f_EPTF_UIHandler_getWidgetRec(pl_widgetId, vl_widgetRec)
|
| f_EPTF_UIhandler_simulation_getDefaultValue(vl_widgetRec, vl_defaultValue);
|
|
|
| // widget id is checked because it could happen that the widget or its parent is removed meanwhile (artf552584)
|
| if (pl_errorCode==0 and v_UIHandler_guiItemList[vl_widgetRecIdx].id != "") {
|
|
|
| var charstring vl_varDataName := f_EPTF_Var_getName(pl_localDataVarId);
|
| f_EPTF_UIHandler_simulation_getData( vl_varDataName,
|
| pl_source,
|
| pl_ptcName,
|
| pl_element,
|
| pl_params,
|
| -,
|
| -,
|
| vl_defaultValue );
|
|
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": widgetId: " & log2str(pl_widgetId) & " varId: " & log2str(pl_localDataVarId));
|
| }
|
| f_EPTF_UIHandler_Config_registerVarToWidget(pl_widgetId, pl_localDataVarId, self, "",pl_dataValue);
|
| f_EPTF_Var_addSubsCanAdjustNotifyFn(pl_localDataVarId, {refers(f_EPTF_UIHandler_updateDisableStateByVarIdx), {}});// - called in f_EPTF_UIHandler_Config_connectAllVarsToWidget() as well
|
| f_EPTF_UIHandler_updateDisableStateByVarIdx(pl_localDataVarId, {});// - called in f_EPTF_UIHandler_Config_connectAllVarsToWidget() as well
|
| } else {
|
| if(v_EPTF_UIHandler_simulatonMode) {
|
| var charstring vl_dataVarName;
|
| //get the data from DB
|
| if(f_EPTF_UIHandler_simulation_getDataFromDB(vl_dataVarName, pl_source, pl_ptcName, pl_element, pl_params) != 0) {
|
| //create random data to simulate
|
| vl_dataVarName := log2str(vl_defaultValue);
|
| if(f_EPTF_Var_getId(vl_dataVarName) == -1) {
|
| f_EPTF_Var_newVar(log2str(vl_defaultValue), vl_defaultValue)
|
| }
|
| }
|
| } else {
|
| f_EPTF_UIHandler_warning(%definitionId&": Configuration error : Invalid dataSource parameters: \n"&
|
| "\nSource: "&pl_source&
|
| "\nPTC : "&pl_ptcName &
|
| "\nData Name : " &pl_element&
|
| "\nParams:" & log2str(pl_params)&
|
| "\nCheck the warnings above for more info.");
|
| }
|
| }
|
|
|
| v_UIHandler_nofRunning_processExternalData_handlers := v_UIHandler_nofRunning_processExternalData_handlers - 1;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_updateDisableStateByVarIdx
|
| //
|
| // Purpose:
|
| // Callback function for the variable's subsCanAdjust flag change event
|
| //
|
| // Parameters:
|
| // pl_idx - *in* *integer* - EPTF Variable index
|
| // pl_argList - *in* <EPTF_IntegerList> - argument list
|
| //
|
| // Detailed Comments:
|
| // See f_EPTF_Var_addSubsCanAdjustNotifyFn
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_UIHandler_updateDisableStateByVarIdx(in integer pl_idx, in EPTF_IntegerList pl_argList)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if(f_EPTF_Var_getSubsCanAdjust(pl_idx)) {
|
| f_EPTF_UIHandler_enableAllWidgetsOfVar(pl_idx);
|
| } else {
|
| f_EPTF_UIHandler_disableAllWidgetsOfVar(pl_idx);
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_enableAllWidgetsOfVar
|
| //
|
| // Purpose:
|
| // Enables all widgets connected to the provided variable
|
| //
|
| // Parameters:
|
| // pl_varIdx - *in* *integer* - the ID of the variable
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_enableAllWidgetsOfVar(in integer pl_varIdx)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if (not v_UIHandler_initialized){ return }
|
| var EPTF_UIHandler_OpenSubscriptions vl_varSubscriptions;
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": "&f_EPTF_Var_getName(pl_varIdx));
|
| }
|
|
|
| if(f_EPTF_UIHandler_getSubscriptionsByVarIdx(pl_varIdx, vl_varSubscriptions))//there are some subscriptions to the variable
|
| {
|
| for(var integer i:=0; i<sizeof(vl_varSubscriptions);i:=i+1)
|
| {
|
| var integer vl_widgetIdx := f_EPTF_UIHandler_widgetRecIndex(vl_varSubscriptions[i].widgetId);
|
| if(-1 < vl_widgetIdx) {
|
| f_EPTF_UIHandler_updateguilist_enablewidget(vl_widgetIdx);
|
| if (v_UIHandler_guiConnected) {
|
| // f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_enableWidget(vl_varSubscriptions[i].widgetId));
|
| // check here
|
| if(f_EPTF_UIHandler_isWidgetEnabled(vl_widgetIdx) == true){
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_enableWidget(vl_varSubscriptions[i].widgetId));
|
| } else {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_disableWidget(vl_varSubscriptions[i].widgetId));
|
| }
|
| }
|
| }
|
| }
|
| }
|
| else if(c_EPTF_Common_debugSwitch)
|
| {
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": no subscriptions can be found to the variable: " & f_EPTF_Var_getName(pl_varIdx));
|
| }
|
| }
|
| }
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_disableAllWidgetsOfVar
|
| //
|
| // Purpose:
|
| // Disables all widgets connected to the provided variable
|
| //
|
| // Parameters:
|
| // pl_varIdx - *in* *integer* - the ID of the variable
|
| //
|
| // Detailed Comments:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_disableAllWidgetsOfVar(in integer pl_varIdx)
|
| runs on EPTF_UIHandler_Private_CT
|
| {
|
| if (not v_UIHandler_initialized){ return }
|
| var EPTF_UIHandler_OpenSubscriptions vl_varSubscriptions;
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": "&f_EPTF_Var_getName(pl_varIdx));
|
| }
|
|
|
| if(f_EPTF_UIHandler_getSubscriptionsByVarIdx(pl_varIdx, vl_varSubscriptions))//there are some subscriptions to the variable
|
| {
|
| for(var integer i:=0; i<sizeof(vl_varSubscriptions);i:=i+1)
|
| {
|
| var integer vl_widgetIdx := f_EPTF_UIHandler_widgetRecIndex(vl_varSubscriptions[i].widgetId);
|
| if(-1 < vl_widgetIdx and f_EPTF_UIHandler_isWidgetEnabled(vl_widgetIdx)) {
|
| f_EPTF_UIHandler_updateguilist_disablewidget(vl_widgetIdx);
|
| if (v_UIHandler_guiConnected) {
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_disableWidget(vl_varSubscriptions[i].widgetId));
|
| }
|
| }
|
| }
|
| }
|
| else if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled())
|
| {
|
| f_EPTF_UIHandler_debug(%definitionId&": no subscriptions can be found to the variable: " & f_EPTF_Var_getName(pl_varIdx));
|
| }
|
| }
|
|
|
| group processIteratorDatas{
|
|
|
| private external function dec_Treecolgroups (in octetstring p_oct, out Treecolgroups.treecolgroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Treecolgroups (in Treecolgroups.treecolgroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| private function f_EPTF_UIHandler_Config_processTreecoliterator(
|
| in Treecolgroup pl_treecolgroup,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Treecoliterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_treecolgroup.iterator)) {
|
| vl_iterator := pl_treecolgroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_treecolgroup.externalvalue)) {
|
| vl_iterator := pl_treecolgroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Treecolgroups.treecolgroup_list vl_treecolgroup_list;
|
| vl_treecolgroup_list[0] := pl_treecolgroup;
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTreecols(vl_treecolgroup_list, pl_parentIdx, pl_widgetExists);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, treecoliterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
|
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTreecols(vl_iterator.treecolgroups.treecolgroup_list, vl_parentIdx, pl_widgetExists)
|
|
|
| }
|
|
|
| private external function dec_Treeitemgroups (in octetstring p_oct, out Treeitemgroups.treeitemgroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Treeitemgroups (in Treeitemgroups.treeitemgroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| private function f_EPTF_UIHandler_Config_processTreeItemiterator(
|
| in Treeitemgroup pl_treeitemgroup,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Treeitemiterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_treeitemgroup.iterator)) {
|
| vl_iterator := pl_treeitemgroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_treeitemgroup.externalvalue)) {
|
| vl_iterator := pl_treeitemgroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Treeitemgroups.treeitemgroup_list vl_treeitemgroup_list;
|
| vl_treeitemgroup_list[0] := pl_treeitemgroup;
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTreeItemGroups(vl_treeitemgroup_list, pl_parentIdx, pl_widgetExists);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, treeitemiterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
|
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTreeItemGroups(vl_iterator.treeitemgroups.treeitemgroup_list, vl_parentIdx, pl_widgetExists)
|
|
|
|
|
| }
|
|
|
| private external function dec_Treerowgroups (in octetstring p_oct, out Treerowgroups.treerowgroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Treerowgroups (in Treerowgroups.treerowgroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
|
|
| private function f_EPTF_UIHandler_Config_processTreerowiterator(
|
| in Treerowgroup pl_treerowgroup,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Treerowiterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
|
|
| if(ischosen(pl_treerowgroup.iterator)) {
|
| vl_iterator := pl_treerowgroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_treerowgroup.externalvalue)) {
|
| vl_iterator := pl_treerowgroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Treerowgroups.treerowgroup_list vl_treerowgroup_list;
|
| vl_treerowgroup_list[0] := pl_treerowgroup;
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTreeRowGroups(vl_treerowgroup_list, pl_parentIdx, pl_widgetExists);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, treerowiterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTreeRowGroups(vl_iterator.treerowgroups.treerowgroup_list, vl_parentIdx, pl_widgetExists)
|
| }
|
|
|
| private external function dec_Treecellgroups (in octetstring p_oct, out Treecellgroups.treecellgroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Treecellgroups (in Treecellgroups.treecellgroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| private function f_EPTF_UIHandler_Config_processTreecelliterator(
|
| inout Treecellgroup pl_treecellgroup,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Treecelliterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_treecellgroup.iterator)) {
|
| vl_iterator := pl_treecellgroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_treecellgroup.externalvalue)) {
|
| vl_iterator := pl_treecellgroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Treecellgroups.treecellgroup_list vl_treecellgroup_list;
|
| vl_treecellgroup_list[0] := pl_treecellgroup;
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTreeCellGroups(vl_treecellgroup_list, pl_parentIdx, pl_widgetExists, false);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, treecelliterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
|
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTreeCellGroups(vl_iterator.treecellgroups.treecellgroup_list, vl_parentIdx, pl_widgetExists, false)
|
| }
|
|
|
| private external function dec_Tabpagegroups (in octetstring p_oct, out Tabpagegroups.tabpagegroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Tabpagegroups (in Tabpagegroups.tabpagegroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| private function f_EPTF_UIHandler_Config_processTabpageiterator(
|
| in Tabpagegroup pl_tabpagegroup,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Tabpageiterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_tabpagegroup.iterator)) {
|
| vl_iterator := pl_tabpagegroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_tabpagegroup.externalvalue)) {
|
| vl_iterator := pl_tabpagegroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Tabpagegroups.tabpagegroup_list vl_tabpagegroup_list;
|
| vl_tabpagegroup_list[0] := pl_tabpagegroup;
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTabpagegroup_list(vl_tabpagegroup_list, pl_parentIdx, pl_widgetExists);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
|
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, tabpageiterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
|
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromTabpagegroup_list(vl_iterator.tabpagegroups.tabpagegroup_list, vl_parentIdx, pl_widgetExists);
|
| return;
|
|
|
| }
|
|
|
|
|
|
|
|
|
| private external function dec_Externaldatagroups (in octetstring p_oct, out Externaldatagroups.externaldatagroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Externaldatagroups (in Externaldatagroups.externaldatagroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| private function f_EPTF_UIHandler_Config_processValueListiterator(
|
| in Externaldatagroup pl_externaldatagroup,
|
| inout Distributionchart pl_xul,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Externaldataiterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_externaldatagroup.iterator)) {
|
| vl_iterator := pl_externaldatagroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_externaldatagroup.externalvalue)) {
|
| vl_iterator := pl_externaldatagroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Externaldatagroups.externaldatagroup_list vl_externaldatagroup_list;
|
| vl_externaldatagroup_list[0] := pl_externaldatagroup;
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromExternaldatagroup_list(vl_externaldatagroup_list, pl_parentIdx, pl_widgetExists, pl_xul);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
|
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, valuelistiterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
| f_EPTF_UIHandler_appendAllWidgetIdsFromExternaldatagroup_list(vl_iterator.externaldatagroups.externaldatagroup_list, vl_parentIdx, pl_widgetExists, pl_xul)
|
|
|
| }
|
|
|
| private external function dec_Listitemgroups (in octetstring p_oct, out Listitemgroups.listitemgroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Listitemgroups (in Listitemgroups.listitemgroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| private function f_EPTF_UIHandler_Config_processListitemiterator(
|
| in Listitemgroup pl_listitemgroup,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Listitemiterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_listitemgroup.iterator)) {
|
| vl_iterator := pl_listitemgroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_listitemgroup.externalvalue)) {
|
| vl_iterator := pl_listitemgroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Listitemgroups.listitemgroup_list vl_listitemgroup_list;
|
| vl_listitemgroup_list[0] := pl_listitemgroup;
|
| f_EPTF_UIHandler_Config_processListitemgroups(vl_listitemgroup_list, pl_parentIdx, pl_widgetExists);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, listitemiterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
|
|
| f_EPTF_UIHandler_Config_processListitemgroups(vl_iterator.listitemgroups.listitemgroup_list, vl_parentIdx, pl_widgetExists)
|
| }
|
|
|
| private external function dec_Menuitemgroups (in octetstring p_oct, out Menuitemgroups.menuitemgroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Menuitemgroups (in Menuitemgroups.menuitemgroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| private function f_EPTF_UIHandler_Config_processMenuitemiterator(
|
| in Menuitemgroup pl_menuitemgroup,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Menuitemiterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_menuitemgroup.iterator)) {
|
| vl_iterator := pl_menuitemgroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_menuitemgroup.externalvalue)) {
|
| vl_iterator := pl_menuitemgroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Menuitemgroups.menuitemgroup_list vl_menuitemgroup_list;
|
| vl_menuitemgroup_list[0] := pl_menuitemgroup;
|
| f_EPTF_UIHandler_appendMenuitemGroups(vl_menuitemgroup_list, pl_parentIdx, pl_widgetExists);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, menuitemiterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
|
|
|
|
| f_EPTF_UIHandler_appendMenuitemGroups(vl_iterator.menuitemgroups.menuitemgroup_list, vl_parentIdx, pl_widgetExists)
|
| }
|
|
|
| private external function dec_Tracegroups (in octetstring p_oct, out Tracegroups.tracegroup_list p_groups) return integer
|
| with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}
|
| private external function enc_Tracegroups (in Tracegroups.tracegroup_list p_groups) return octetstring
|
| with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}
|
|
|
| private function f_EPTF_UIHandler_Config_processTraceiterator(
|
| in Tracegroup pl_tracegroup,
|
| in integer pl_parentIdx,
|
| in boolean pl_createMetaIterator := true,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT{
|
| var integer vl_iteratorVarIdx;
|
| var integer vl_nodePointer;
|
| var Traceiterator vl_iterator;
|
| var boolean vl_isExternalValue;
|
| if(ischosen(pl_tracegroup.iterator)) {
|
| vl_iterator := pl_tracegroup.iterator;
|
| vl_isExternalValue := false;
|
| } else if(ischosen(pl_tracegroup.externalvalue)) {
|
| vl_iterator := pl_tracegroup.externalvalue;
|
| vl_isExternalValue := true;
|
| } else {
|
| //from postproc
|
| var Tracegroups.tracegroup_list vl_tracegroup_list;
|
| vl_tracegroup_list[0] := pl_tracegroup;
|
| f_EPTF_UIHandler_Config_processTracegroups(vl_tracegroup_list, pl_parentIdx, pl_widgetExists);
|
| return;
|
| }
|
|
|
| //creating iterator element in widget database for meta data
|
| var integer vl_parentIdx;
|
| if(pl_createMetaIterator == true) {
|
| //insert the iterator with its meta information to database:
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_iterator.metadata));
|
| vl_parentIdx := f_EPTF_UIHandler_appendMetaIterator(pl_parentIdx, pl_widgetExists, traceiterator, vl_iteratorVarIdx, vl_nodePointer, vl_isExternalValue);
|
| } else {
|
| vl_parentIdx := pl_parentIdx;
|
| }
|
|
|
| f_EPTF_UIHandler_Config_processTracegroups(vl_iterator.tracegroups.tracegroup_list, vl_parentIdx, pl_widgetExists)
|
| }
|
|
|
| }//group
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Config_registerVarToWidget
|
| //
|
| // Purpose:
|
| // Stores a widget-variable connection to a database
|
| //
|
| // Parameters:
|
| // pl_widgetId - *in* *charstring* - the widget id
|
| // pl_varIdx - *inout* *integer* - the var index to connect to
|
| // pl_provider - *inout* *EPTF_Var_CT* - the provider component
|
| // pl_providedParamName - *inout* *charstring* - the provided param name
|
| // pl_currentValue - *in* <EPTF_Var_DirectContent> - the current value of the var pl_varIdx
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Config_registerVarToWidget(in charstring pl_widgetId,
|
| in integer pl_varIdx,
|
| in EPTF_Var_CT pl_provider,
|
| in charstring pl_providedParamName,
|
| in EPTF_Var_DirectContent pl_currentValue
|
| )
|
| runs on EPTF_UIHandler_Private_CT {
|
|
|
| if(f_EPTF_UIHandler_checkSubscriptCompatibility(pl_widgetId, pl_varIdx, pl_currentValue) == true) {
|
| var integer vl_size := sizeof(v_EPTF_UIHandler_Config_ConnectVarToWidgets);
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[vl_size] := c_EPTF_UIHandler_Config_ConnectVarToWidget_init;
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[vl_size].widgetId := pl_widgetId;
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[vl_size].varIdx := pl_varIdx;
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[vl_size].provider := pl_provider;
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[vl_size].providedParamName := pl_providedParamName;
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[vl_size].initialValue := pl_currentValue;
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Config_connectAllVarsToWidget
|
| //
|
| // Purpose:
|
| // Connects all a widget-variable connections stored in the database
|
| //
|
| // Parameters:
|
| // -
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Config_connectAllVarsToWidget()
|
| runs on EPTF_UIHandler_Private_CT return boolean {
|
| var boolean vl_ret := true;
|
|
|
| for(var integer i:=0; i<sizeof(v_EPTF_UIHandler_Config_ConnectVarToWidgets); i:=i+1) {
|
| vl_ret := vl_ret and f_EPTF_UIHandler_Config_connectToWidget(
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[i].widgetId,
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[i].varIdx,
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[i].provider,
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[i].providedParamName,
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets[i].initialValue
|
| );
|
| f_EPTF_Var_addPostProcFn(v_EPTF_UIHandler_Config_ConnectVarToWidgets[i].varIdx, {refers(f_EPTF_UIHandler_refreshVar),{}});
|
| f_EPTF_Var_addSubsCanAdjustNotifyFn(v_EPTF_UIHandler_Config_ConnectVarToWidgets[i].varIdx, {refers(f_EPTF_UIHandler_updateDisableStateByVarIdx),{}});
|
| f_EPTF_UIHandler_updateDisableStateByVarIdx(v_EPTF_UIHandler_Config_ConnectVarToWidgets[i].varIdx, {});
|
| }
|
|
|
| v_EPTF_UIHandler_Config_ConnectVarToWidgets := {};
|
| return vl_ret;
|
| }
|
|
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_Config_connectToWidget
|
| //
|
| // Purpose:
|
| // Connects a widget id to a variable
|
| //
|
| // Parameters:
|
| // pl_widgetId - *in* *charstring* - the widget id
|
| // pl_varIdx - *inout* *integer* - the var index to connect to
|
| // pl_provider - *inout* *EPTF_Var_CT* - the provider component
|
| // pl_providedParamName - *inout* *charstring* - the provided param name
|
|
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_Config_connectToWidget(in charstring pl_widgetId,
|
| in integer pl_varIdx,
|
| in EPTF_Var_CT pl_provider,
|
| in charstring pl_providedParamName,
|
| in EPTF_Var_DirectContent pl_initialValue := {unknownVal := {omit}} )
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
|
|
| if(f_EPTF_UIHandler_checkSubscriptCompatibility(pl_widgetId, pl_varIdx, pl_initialValue) != true) {
|
| return false;
|
| }
|
| // copied and simplified from f_EPTF_UIHandler_handleSubscriptNote, which handles subscribeMe requests
|
| // Does not handle remote subscription!!!!
|
| var EPTF_UIHandler_OpenSubscription vl_subs := c_UIHandler_defOpenSubscription;
|
| //log("DEBUG: ","------- connect to a widget -------",pl_msg.widgetId);
|
| //Check if the widget is already connected
|
| var integer vl_subsIdx := f_EPTF_UIHandler_getSubscriptionIdxByWidgetId(pl_widgetId);
|
| if(-1 != vl_subsIdx){
|
| if(v_UIHandler_openSubscriptions[vl_subsIdx].varIdx == pl_varIdx){
|
| f_EPTF_UIHandler_warning("The widget's already connected to the same variable!");
|
| return true;
|
| }
|
| f_EPTF_UIHandler_warning("The widget is already connected!");
|
| return false;
|
| }
|
| if( not f_EPTF_UIHandler_widgetTypeFromId(pl_widgetId, vl_subs)
|
| /*-1 == f_EPTF_UIHandler_widgetRecIndex(pl_msg.widgetId)*/
|
| ){
|
| f_EPTF_UIHandler_warning("The widget "&pl_widgetId&" affected in the subscription note does not exist.");
|
| return false;
|
| }
|
|
|
| var EPTF_UIHandler_GuiItemRec vl_wRec;
|
| f_EPTF_UIHandler_getWidgetRec(pl_widgetId, vl_wRec);
|
| if(vl_wRec.widgetType == wtTrace){
|
| f_EPTF_UIHandler_createTraceHistory(vl_wRec.XULformat.trace.maxPoints, vl_wRec.id, pl_varIdx);
|
| }
|
|
|
| vl_subs.widgetId := pl_widgetId;
|
| vl_subs.provider := pl_provider;
|
| vl_subs.varIdx := pl_varIdx;
|
| vl_subs.providedParamName:=pl_providedParamName;
|
| f_EPTF_UIHandler_newSubscription(vl_subs);
|
| f_EPTF_UIHandler_refreshWidget(vl_subs, true,pl_initialValue);
|
| return true;
|
| }
|
|
|
| private function f_EPTF_UIHandler_Config_appendListitemFromList(
|
| inout EPTF_UIHandler_WidgetsList pl_widgets,
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| pl_widgetExists := false;
|
| var boolean vl_bool := false;
|
| for(var integer i := 0; i<sizeof(pl_widgets); i:= i + 1){
|
| var Listitem vl_xul := pl_widgets[i].listitem;
|
| vl_xul.id := f_EPTF_UIHandler_setWidgetID(vl_xul.id);
|
| vl_bool := vl_bool and -1 != f_EPTF_UIHandler_addWidgetRec({
|
| f_EPTF_UIHandler_unichar2charstring(vl_xul.id),
|
| wtListitem,
|
| omit,
|
| pl_parentIdx,
|
| {},
|
| omit,
|
| {listitem := f_EPTF_UIHandler_deleteChildrenFromListitem(vl_xul)}, false}, pl_widgetExists);
|
| }
|
| return vl_bool;
|
| }
|
|
|
| }
|
| group obsoleteXTDPAspFunctions{
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_XSD_addElementToGui
|
| //
|
| // Purpose:
|
| // if the element to add to the Runtime Gui proves to be valid (will not destroy consistency),
|
| // function sends out singleAddElementToGUI XTDP addRequest to the Gui and also adds this new
|
| // element to GUI item list. With call of f_EPTF_UIHandler_expandXML for XML handling.
|
| //
|
| // Return Value:
|
| // boolean
|
| //
|
| // Detailed Comments:
|
| // It returns true if new element proved to be valid, XTDP addRequest is sent.
|
| ///////////////////////////////////////////////////////////
|
| public function f_EPTF_UIHandler_XSD_addElementToGui(
|
| in Widgets pl_widgets,
|
| in EPTF_UIHandler_WidgetIdString pl_parentWidgetID := "",
|
| inout boolean pl_widgetExists,
|
| in boolean pl_updatedb := true)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean {
|
| if (not v_UIHandler_initialized){ return false }
|
| var charstring vl_expandedXML;
|
| var charstring vl_xul := f_EPTF_UIHandler_XSD_encodeXUL(pl_widgets);
|
| var boolean vl_ret := true;
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&": Started on: " & log2str(vl_xul));
|
| }
|
| vl_ret := f_EPTF_UIHandler_expandXML(vl_expandedXML, vl_xul, pl_parentWidgetID);
|
| if(vl_ret == true) {
|
| if(vl_expandedXML != "") {
|
| // Convert into widgets, becouse iterators - optimal if check the metadata= exitence and if no pl_widgets
|
| var integer vl_separatorPos := f_strstr(vl_expandedXML,"metadata=");
|
| if (vl_separatorPos<0) {
|
| vl_ret := f_EPTF_UIHandler_XSD_addElementToGui_private(pl_widgets, pl_parentWidgetID, pl_widgetExists, pl_updatedb);
|
| } else {
|
| var Widgets vl_expandedXul := f_EPTF_UIHandler_XSD_decodeXUL(vl_expandedXML);
|
| vl_ret := f_EPTF_UIHandler_XSD_addElementToGui_private(vl_expandedXul, pl_parentWidgetID, pl_widgetExists, pl_updatedb);
|
| }
|
| } else {
|
| f_EPTF_UIHandler_warning("Invalid parent ID: "& pl_parentWidgetID);
|
| vl_ret := false;
|
| }
|
| } else {
|
| // XML Load error
|
| f_EPTF_UIHandler_error(%definitionId&": The received XML is invalid, it can not be decoded fully.\n"&
|
| "For further detailes see the log file above.");
|
| }
|
| return vl_ret;
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_XSD_addElementToGui_private
|
| //
|
| // Purpose:
|
| // if the element to add to the Runtime Gui proves to be valid (will not destroy consistency),
|
| // function sends out singleAddElementToGUI XTDP addRequest to the Gui and also adds this new
|
| // element to GUI item list.
|
| //
|
| // Return Value:
|
| // boolean
|
| //
|
| // Detailed Comments:
|
| // It returns true if new element proved to be valid, XTDP addRequest is sent.
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_XSD_addElementToGui_private(
|
| in Widgets pl_widgets,
|
| in EPTF_UIHandler_WidgetIdString pl_parentWidgetID := "",
|
| inout boolean pl_widgetExists,
|
| in boolean pl_updatedb := true)
|
| runs on EPTF_UIHandler_Private_CT
|
| return boolean{
|
| if(ischosen(pl_widgets.metaiterator)) {
|
| //no need to add metaiterator
|
| return true;
|
| }
|
| f_EPTF_UIHandler_waitForLayoutReady();
|
| pl_widgetExists := false;
|
| //If there is no parent ID, the main window will be the first element.
|
| var integer vl_parentIdx := v_UIHandler_windowIndex;
|
| if (pl_parentWidgetID != "") {
|
| vl_parentIdx := f_EPTF_UIHandler_widgetRecIndex(pl_parentWidgetID);
|
| if(-1 == vl_parentIdx){
|
| f_EPTF_UIHandler_warning("Invalid parent ID: "& pl_parentWidgetID);
|
| return false;
|
| }
|
| if(v_UIHandler_guiItemList[vl_parentIdx].widgetType == wtMetaIterator) {
|
| vl_parentIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(vl_parentIdx);
|
| }
|
| }
|
| if(not ischosen(pl_widgets.window)){
|
| if(-1 == vl_parentIdx){
|
| f_EPTF_UIHandler_warning("Adding widget to the window, but there is no window yet!");
|
| return false;
|
| }
|
| if (pl_updatedb){
|
| f_EPTF_UIHandler_addWidgetWithParent(pl_parentWidgetID, f_EPTF_UIHandler_XSD_encodeXUL(pl_widgets));
|
| if (f_EPTF_UIHandler_appendAllWidgetIdsFromXul(pl_widgets, vl_parentIdx, pl_widgetExists)) {
|
| //send element to the GUI
|
| if (pl_parentWidgetID=="") {
|
| pl_parentWidgetID := v_UIHandler_guiItemList[v_UIHandler_windowIndex].id;
|
| }
|
| if(ischosen(pl_widgets.tabpage) and v_UIHandler_guiItemList[vl_parentIdx].widgetType == wtTabpage) {
|
| pl_parentWidgetID := v_UIHandler_guiItemList[v_UIHandler_guiItemList[vl_parentIdx].parentIdx].id;
|
| }
|
| if(not pl_widgetExists) {
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| var charstring vl_widgetId := "";
|
| f_EPTF_UIHandler_getWidgetID(pl_widgets, vl_widgetId);
|
| if(vl_widgetId == ""){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(pl_parentWidgetID);
|
| } else {
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(vl_widgetId);
|
| }
|
| }
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleAddElementToGUI(pl_parentWidgetID, pl_widgets));
|
| } else {
|
| }
|
| return true;
|
| }
|
| } else {
|
| if (pl_parentWidgetID=="") {pl_parentWidgetID := v_UIHandler_guiItemList[v_UIHandler_windowIndex].id;}
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| var charstring vl_widgetId := "";
|
| f_EPTF_UIHandler_getWidgetID(pl_widgets, vl_widgetId);
|
| if(vl_widgetId == ""){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(pl_parentWidgetID);
|
| } else {
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(vl_widgetId);
|
| }
|
| }
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleAddElementToGUI(pl_parentWidgetID, pl_widgets));
|
| return true;
|
| }
|
| } else {
|
| //This is a window
|
| if(-1 != v_UIHandler_windowIndex){
|
| if(v_UIHandler_guiItemList[v_UIHandler_windowIndex].id != pl_widgets.window.id){
|
| f_EPTF_UIHandler_warning("There is another window already!");
|
| return false;
|
| }
|
| }
|
| if (pl_updatedb){
|
| if(f_EPTF_UIHandler_appendAllWidgetIdsFromXul(pl_widgets, vl_parentIdx, pl_widgetExists)){
|
| if(not pl_widgetExists) {
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| var charstring vl_widgetId := "";
|
| f_EPTF_UIHandler_getWidgetID(pl_widgets, vl_widgetId);
|
| if(vl_widgetId == ""){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(pl_parentWidgetID);
|
| } else {
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(vl_widgetId);
|
| }
|
| }
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleAddElementToGUI(omit, pl_widgets));
|
| }
|
| }
|
| return true;
|
| } else {
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| var charstring vl_widgetId := "";
|
| f_EPTF_UIHandler_getWidgetID(pl_widgets, vl_widgetId);
|
| if(vl_widgetId == ""){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(pl_parentWidgetID);
|
| } else {
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(vl_widgetId);
|
| }
|
| }
|
| f_EPTF_UIHandler_send_XTDP(ts_ASP_XTDP_singleAddElementToGUI(omit, pl_widgets));
|
| return true;
|
| }
|
| }
|
| if(c_EPTF_Common_debugSwitch and f_EPTF_UIHandler_debugEnabled()){
|
| f_EPTF_UIHandler_debug(%definitionId&" failed");
|
| }
|
| return false;
|
| }
|
| }
|
|
|
| group RingBufferFunctions
|
| {
|
| private function f_EPTF_UIHandler_createTraceHistory(in integer pl_maxPoints, in charstring pl_traceId, in integer pl_varId)runs on EPTF_UIHandler_Private_CT
|
| {
|
| f_EPTF_UIHandler_ChartDataType_RB_init(v_EPTF_UIHandler_TraceRingBuffers[sizeof(v_EPTF_UIHandler_TraceRingBuffers)], pl_maxPoints);
|
| var integer vl_i, vl_ringBufferIdx:=sizeof(v_EPTF_UIHandler_TraceRingBuffers)-1;
|
| f_EPTF_str2int_HashMap_Insert (v_EPTF_UIHandler_Traces_HashmapId, pl_traceId, vl_ringBufferIdx);
|
| var float vl_startTime := f_EPTF_Base_getAbsTimeInSecs();
|
| for(vl_i := 0; vl_i < pl_maxPoints; vl_i := vl_i+1){
|
| f_EPTF_UIHandler_ChartDataType_RB_push_front(v_EPTF_UIHandler_TraceRingBuffers[vl_ringBufferIdx], {0.0, vl_startTime});
|
| }
|
| var integer vl_traceIdx := f_EPTF_UIHandler_widgetRecIndex(pl_traceId);
|
| var integer vl_chartIdx := v_UIHandler_guiItemList[vl_traceIdx].parentIdx;
|
| f_EPTF_UIHandler_traceHistoryCallBack(pl_varId,{vl_ringBufferIdx, vl_chartIdx});
|
| f_EPTF_Var_addPostProcFn(pl_varId, {refers(f_EPTF_UIHandler_traceHistoryCallBack), {vl_ringBufferIdx, vl_chartIdx}});
|
| }
|
|
|
| private function f_EPTF_UIHandler_traceHistoryCallBack(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_UIHandler_Private_CT{
|
| if(not v_UIHandler_initialized) {
|
| return; // after UIHandler cleanup
|
| }
|
| var float vl_timestamp := f_EPTF_Base_getAbsTimeInSecs();
|
| var EPTF_Var_DirectContent vl_value;
|
| f_EPTF_Var_getContent(pl_idx, vl_value);
|
| var integer vl_ringBufferIdx := pl_argList[0];
|
| var integer vl_chartIdx := pl_argList[1];
|
| for( var integer i := 0; i < sizeof(v_UIHandler_guiItemList[vl_chartIdx].children); i := i + 1) {
|
| var charstring vl_traceId := v_UIHandler_guiItemList[v_UIHandler_guiItemList[vl_chartIdx].children[i]].id;
|
| var integer vl_currentRingBufferIdx;
|
| if(not f_EPTF_str2int_HashMap_Find(v_EPTF_UIHandler_Traces_HashmapId, vl_traceId, vl_currentRingBufferIdx)) {
|
| // error
|
| } else {
|
| var EPTF_Var_DirectContent vl_currentvalue := vl_value;
|
| if(vl_currentRingBufferIdx != vl_ringBufferIdx) {
|
| f_EPTF_UIHandler_getLatestValueOfTrace(vl_traceId, vl_currentvalue);
|
| var charstring vl_currentstrValue := regexp(vl_currentvalue.charstringVal,c_EPTF_CLI_everything&":"&c_EPTF_CLI_floatNumber,1);
|
| if(vl_currentstrValue != "") {
|
| vl_currentvalue := { floatVal := str2float(vl_currentstrValue)}
|
| }
|
| }
|
| if(ischosen(vl_currentvalue.floatVal)){
|
| f_EPTF_UIHandler_ChartDataType_RB_push_front(v_EPTF_UIHandler_TraceRingBuffers[vl_currentRingBufferIdx], {vl_currentvalue.floatVal, vl_timestamp});
|
| }
|
| else if(ischosen(vl_currentvalue.intVal)){
|
| f_EPTF_UIHandler_ChartDataType_RB_push_front(v_EPTF_UIHandler_TraceRingBuffers[vl_currentRingBufferIdx], {int2float(vl_currentvalue.intVal), vl_timestamp});
|
| }
|
| }
|
| }
|
|
|
|
|
| }
|
|
|
| friend function f_EPTF_UIHandler_getHistoryOfTrace(in charstring pl_traceId, out EPTF_Var_DirectContent pl_content)runs on EPTF_UIHandler_Private_CT{
|
| pl_content.charstringVal := "";
|
| var integer vl_i, vl_ringBufferIdx := -1;
|
| var UIHandler_ChartDataType vl_data;
|
| f_EPTF_str2int_HashMap_Find(v_EPTF_UIHandler_Traces_HashmapId, pl_traceId, vl_ringBufferIdx);
|
| for(vl_i := f_EPTF_UIHandler_ChartDataType_RB_capacity(v_EPTF_UIHandler_TraceRingBuffers[vl_ringBufferIdx])-1; vl_i>-1; vl_i := vl_i -1)
|
| {
|
| vl_data := f_EPTF_UIHandler_ChartDataType_RB_get(v_EPTF_UIHandler_TraceRingBuffers[vl_ringBufferIdx], vl_i);
|
| pl_content.charstringVal := pl_content.charstringVal & float2str(vl_data.timestamp) & ":" & float2str(vl_data.data) & "_";
|
| }
|
| pl_content.charstringVal := substr(pl_content.charstringVal, 0, lengthof(pl_content.charstringVal)-1);
|
| }
|
| friend function f_EPTF_UIHandler_getLatestValueOfTrace(in charstring pl_traceId, out EPTF_Var_DirectContent pl_content)runs on EPTF_UIHandler_Private_CT{
|
| pl_content.charstringVal := "";
|
| var integer vl_ringBufferIdx := -1;
|
| var UIHandler_ChartDataType vl_data;
|
| f_EPTF_str2int_HashMap_Find(v_EPTF_UIHandler_Traces_HashmapId, pl_traceId, vl_ringBufferIdx);
|
| vl_data := f_EPTF_UIHandler_ChartDataType_RB_front(v_EPTF_UIHandler_TraceRingBuffers[vl_ringBufferIdx]);
|
| pl_content.charstringVal := float2str(vl_data.timestamp) & ":" & float2str(vl_data.data);
|
| }
|
| }
|
|
|
| ////////////Dynamic iterator handling
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_addWidgetWithParent
|
| //
|
| // Purpose:
|
| // Adding new element to GUI description database
|
| //
|
| // Parameters:
|
| // pl_parentWidgetId - *in* *charstring* - the pl_parentWidgetId, where the xml described GUI part belongs
|
| // pl_xml_widgets - *in* *charstring* - the GUI description XML
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_addWidgetWithParent(in charstring pl_parentWidgetId, in charstring pl_xml_widgets)
|
| runs on EPTF_UIHandler_Private_CT {
|
| v_UIHandler_GUI_DescriptionDB_Idx := sizeof(v_UIHandler_GUI_DescriptionDB);
|
| v_UIHandler_GUI_DescriptionDB[v_UIHandler_GUI_DescriptionDB_Idx] := c_UIHandler_GUI_DescriptionDB_Item;
|
| v_UIHandler_GUI_DescriptionDB[v_UIHandler_GUI_DescriptionDB_Idx].parentWidgetId := pl_parentWidgetId;
|
| v_UIHandler_GUI_DescriptionDB[v_UIHandler_GUI_DescriptionDB_Idx].xml_widgets := pl_xml_widgets;
|
|
|
| }
|
|
|
|
|
| //FIXME: update the itarator variable created from a non-CharstringList variable (e.g in function f_EPTF_UIHandler_Config_processIterator and f_EPTF_UIHandler_Config_getIteratorData)
|
|
|
| // this postproc rebuilds the GUI XML based on the custom XML using the new values of the iterator
|
| private function f_EPTF_UIHandler_updateIterator_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_UIHandler_Private_CT {
|
| var integer vl_iteratorVarIdx := pl_idx;
|
| var integer vl_metaIteratorIdx := pl_argList[0];
|
| // check if metaIterator exists:
|
| if (
|
| vl_metaIteratorIdx<sizeof(v_UIHandler_guiItemList)
|
| and ispresent(v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData)
|
| and ispresent(v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer)
|
| and ischosen(v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData)
|
| and v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.iteratorVarIdx == vl_iteratorVarIdx
|
| ) {
|
| // metaIterator found
|
| var integer vl_nodePointer := v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer;
|
|
|
| // check if value was changed:
|
| var EPTF_CharstringList vl_currentValue := v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.currentValue;
|
| var EPTF_CharstringList vl_newValue := f_EPTF_Var_getCharstringlistValue(v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.iteratorVarIdx);
|
| if (vl_currentValue == vl_newValue) {
|
| // no change
|
| return;
|
| } else {
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.currentValue := vl_newValue;
|
| }
|
|
|
| // get XML descriptor from custom XML:
|
| var integer vl_UIHandler_GUI_DescriptionDB_Idx := v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.GUI_DescriptionDB_Idx;
|
|
|
| var charstring vl_parentWidgetId := v_UIHandler_GUI_DescriptionDB[vl_UIHandler_GUI_DescriptionDB_Idx].parentWidgetId;
|
| var charstring vl_xml_widgets := v_UIHandler_GUI_DescriptionDB[vl_UIHandler_GUI_DescriptionDB_Idx].xml_widgets;
|
| var Widgets vl_widgets;
|
| var integer vl_retval;
|
| vl_retval := dec_Widgets(char2oct(vl_xml_widgets), vl_widgets);
|
| if(0 != vl_retval){
|
| // this should never happen
|
| f_EPTF_UIHandler_error(%definitionId&": The received XML is invalid, it can not be decoded fully.\n"&
|
| "Unable to update gui while updating the iterator "&int2str(vl_metaIteratorIdx)&" . The XML: "&vl_xml_widgets)
|
| }
|
|
|
| // clear all children of the metaIterator from database:
|
| var EPTF_IntegerList vl_childrens := v_UIHandler_guiItemList[vl_metaIteratorIdx].children;
|
| for(var integer vl_i := 0; vl_i < sizeof(vl_childrens); vl_i := vl_i + 1){
|
| f_EPTF_UIHandler_removeElementFromGuiByIdx(vl_childrens[vl_i], false, false);
|
| }
|
|
|
|
|
|
|
| //checking what parentid is removed. It's childrens need to be rebuild after the iterator refreshed. (If the parentIdx still exists)
|
| var EPTF_IntegerList vl_removedDescriptionDBIdxs := {};
|
| for(var integer vl_i := 0; vl_i < sizeof(v_UIHandler_GUI_DescriptionDB); vl_i := vl_i + 1) {
|
| if (f_EPTF_UIHandler_widgetRecIndex(v_UIHandler_GUI_DescriptionDB[vl_i].parentWidgetId) == -1) {
|
| vl_removedDescriptionDBIdxs[sizeof(vl_removedDescriptionDBIdxs)] := vl_i;
|
| }
|
| }
|
|
|
| //Rebuild the gui:
|
| var boolean vl_widgetExists;
|
| var charstring vl_widget_xml;
|
| var octetstring vl_widgetOctString;
|
| if(not f_EPTF_UIHandler_refreshedXMLforNode(vl_nodePointer, vl_widget_xml)) {
|
| f_EPTF_UIHandler_error(%definitionId&": Unable to generate the xml, after iterator is changed for nodepointer:"&log2str(vl_nodePointer))
|
| }
|
|
|
| select (v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.iteratorUnionType) {
|
| case(iterator) {
|
| vl_widget_xml := "<iterator xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</iterator>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Embeddedwidgets.embeddedwidget_list vl_embeddedwidget_list;
|
| dec_Embeddedwidgets(vl_widgetOctString, vl_embeddedwidget_list);
|
|
|
| // rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_embeddedwidget_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_embeddedwidget_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_embeddedwidget_list := vl_embeddedwidget_list[0].iterator.embeddedwidgets.embeddedwidget_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_embeddedwidget_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_embeddedwidget_list := vl_embeddedwidget_list[0].externalvalue.embeddedwidgets.embeddedwidget_list;
|
| }
|
|
|
| var integer vl_embeddedwidget_list_size := sizeof(vl_embeddedwidget_list);
|
| for(var integer i := 0; i < vl_embeddedwidget_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processIterator( vl_embeddedwidget_list[i], vl_metaIteratorIdx, true, vl_widgetExists);
|
| }
|
| }
|
| case(tabpageiterator) {
|
| vl_widget_xml := "<tabpagegroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</tabpagegroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Tabpagegroups.tabpagegroup_list vl_tabpagegroup_list;
|
| dec_Tabpagegroups(vl_widgetOctString, vl_tabpagegroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_tabpagegroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_tabpagegroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_tabpagegroup_list := vl_tabpagegroup_list[0].iterator.tabpagegroups.tabpagegroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_tabpagegroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_tabpagegroup_list := vl_tabpagegroup_list[0].externalvalue.tabpagegroups.tabpagegroup_list;
|
| }
|
|
|
| var integer vl_tabpagegroup_list_size := sizeof(vl_tabpagegroup_list);
|
| for(var integer i := 0; i < vl_tabpagegroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processTabpageiterator(vl_tabpagegroup_list[i], vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| case(treecoliterator) {
|
| vl_widget_xml := "<treecolgroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</treecolgroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Treecolgroups.treecolgroup_list vl_treecolgroup_list;
|
| dec_Treecolgroups(vl_widgetOctString, vl_treecolgroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_treecolgroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_treecolgroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_treecolgroup_list := vl_treecolgroup_list[0].iterator.treecolgroups.treecolgroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_treecolgroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_treecolgroup_list := vl_treecolgroup_list[0].externalvalue.treecolgroups.treecolgroup_list;
|
| }
|
|
|
| var integer vl_treecolgroup_list_size := sizeof(vl_treecolgroup_list);
|
| for(var integer i := 0; i < vl_treecolgroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processTreecoliterator(vl_treecolgroup_list[i], vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| case(treeitemiterator) {
|
| vl_widget_xml := "<treeitemgroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</treeitemgroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Treeitemgroups.treeitemgroup_list vl_treeitemgroup_list;
|
| dec_Treeitemgroups(vl_widgetOctString, vl_treeitemgroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_treeitemgroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_treeitemgroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_treeitemgroup_list := vl_treeitemgroup_list[0].iterator.treeitemgroups.treeitemgroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_treeitemgroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_treeitemgroup_list := vl_treeitemgroup_list[0].externalvalue.treeitemgroups.treeitemgroup_list;
|
| }
|
|
|
| var integer vl_treeitemgroup_list_size := sizeof(vl_treeitemgroup_list);
|
| for(var integer i := 0; i < vl_treeitemgroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processTreeItemiterator(vl_treeitemgroup_list[i], vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
|
|
| }
|
| case(treerowiterator) {
|
| vl_widget_xml := "<treerowgroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</treerowgroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Treerowgroups.treerowgroup_list vl_treerowgroup_list;
|
| dec_Treerowgroups(vl_widgetOctString, vl_treerowgroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_treerowgroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_treerowgroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_treerowgroup_list := vl_treerowgroup_list[0].iterator.treerowgroups.treerowgroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_treerowgroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_treerowgroup_list := vl_treerowgroup_list[0].externalvalue.treerowgroups.treerowgroup_list;
|
| }
|
|
|
| var integer vl_treerowgroup_list_size := sizeof(vl_treerowgroup_list);
|
| for(var integer i := 0; i < vl_treerowgroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processTreerowiterator(vl_treerowgroup_list[i], vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| case(treecelliterator) {
|
| vl_widget_xml := "<treecellgroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</treecellgroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Treecellgroups.treecellgroup_list vl_treecellgroup_list;
|
| dec_Treecellgroups(vl_widgetOctString, vl_treecellgroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_treecellgroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_treecellgroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_treecellgroup_list := vl_treecellgroup_list[0].iterator.treecellgroups.treecellgroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_treecellgroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_treecellgroup_list := vl_treecellgroup_list[0].externalvalue.treecellgroups.treecellgroup_list;
|
| }
|
|
|
| var integer vl_treecellgroup_list_size := sizeof(vl_treecellgroup_list);
|
| for(var integer i := 0; i < vl_treecellgroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processTreecelliterator(vl_treecellgroup_list[i], vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| case(traceiterator) {
|
| vl_widget_xml := "<tracegroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</tracegroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Tracegroups.tracegroup_list vl_tracegroup_list;
|
| dec_Tracegroups(vl_widgetOctString, vl_tracegroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_tracegroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_tracegroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_tracegroup_list := vl_tracegroup_list[0].iterator.tracegroups.tracegroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_tracegroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_tracegroup_list := vl_tracegroup_list[0].externalvalue.tracegroups.tracegroup_list;
|
| }
|
|
|
| var integer vl_tracegroup_list_size := sizeof(vl_tracegroup_list);
|
| for(var integer i := 0; i < vl_tracegroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processTraceiterator(vl_tracegroup_list[i], vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| case(listitemiterator) {
|
| vl_widget_xml := "<listitemgroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</listitemgroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Listitemgroups.listitemgroup_list vl_listitemgroup_list;
|
| dec_Listitemgroups(vl_widgetOctString, vl_listitemgroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_listitemgroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_listitemgroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_listitemgroup_list := vl_listitemgroup_list[0].iterator.listitemgroups.listitemgroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_listitemgroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_listitemgroup_list := vl_listitemgroup_list[0].externalvalue.listitemgroups.listitemgroup_list;
|
| }
|
|
|
| var integer vl_listitemgroup_list_size := sizeof(vl_listitemgroup_list);
|
| for(var integer i := 0; i < vl_listitemgroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processListitemiterator(vl_listitemgroup_list[i], vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| case(menuitemiterator) {
|
| vl_widget_xml := "<listitemgroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</listitemgroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Menuitemgroups.menuitemgroup_list vl_menuitemgroup_list;
|
| dec_Menuitemgroups(vl_widgetOctString, vl_menuitemgroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_menuitemgroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_menuitemgroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_menuitemgroup_list := vl_menuitemgroup_list[0].iterator.menuitemgroups.menuitemgroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_menuitemgroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_menuitemgroup_list := vl_menuitemgroup_list[0].externalvalue.menuitemgroups.menuitemgroup_list;
|
| }
|
|
|
| var integer vl_menuitemgroup_list_size := sizeof(vl_menuitemgroup_list);
|
| for(var integer i := 0; i < vl_menuitemgroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processMenuitemiterator(vl_menuitemgroup_list[i], vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| case(externaldataiterator) {
|
| vl_widget_xml := "<externaldatagroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</externaldatagroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Externaldatagroups.externaldatagroup_list vl_externaldatagroup_list;
|
| dec_Externaldatagroups(vl_widgetOctString, vl_externaldatagroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_externaldatagroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_externaldatagroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_externaldatagroup_list := vl_externaldatagroup_list[0].iterator.externaldatagroups.externaldatagroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_externaldatagroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_externaldatagroup_list := vl_externaldatagroup_list[0].externalvalue.externaldatagroups.externaldatagroup_list;
|
| }
|
|
|
| var Distributionchart vl_xul;
|
| var integer vl_externaldatagroup_list_size := sizeof(vl_externaldatagroup_list);
|
| for(var integer i := 0; i < vl_externaldatagroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processValueListiterator(vl_externaldatagroup_list[i], vl_xul, vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| case(valuelistiterator) {
|
| vl_widget_xml := "<externaldatagroup_list xmlns=\"http://ttcn.ericsson.se/protocolModules/xtdp/xtdl\">" & vl_widget_xml & "</externaldatagroup_list>";
|
| vl_widgetOctString := char2oct(vl_widget_xml);
|
|
|
| var Externaldatagroups.externaldatagroup_list vl_externaldatagroup_list;
|
| dec_Externaldatagroups(vl_widgetOctString, vl_externaldatagroup_list);
|
|
|
| //rewrite to nodepointer with the actual value, and remove the metaiterator/externalvalue, it is already on the database
|
| if(ischosen(vl_externaldatagroup_list[0].iterator)) {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_externaldatagroup_list[0].iterator.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_externaldatagroup_list := vl_externaldatagroup_list[0].iterator.externaldatagroups.externaldatagroup_list;
|
| } else {
|
| f_EPTF_UIHandler_parseIteratorMetadata(vl_nodePointer,vl_iteratorVarIdx,f_unichar2charstr(vl_externaldatagroup_list[0].externalvalue.metadata));
|
| v_UIHandler_guiItemList[vl_metaIteratorIdx].widgetData.metaIteratorData.nodePointer := vl_nodePointer;
|
| vl_externaldatagroup_list := vl_externaldatagroup_list[0].externalvalue.externaldatagroups.externaldatagroup_list;
|
| }
|
|
|
| var Distributionchart vl_xul;
|
| var integer vl_externaldatagroup_list_size := sizeof(vl_externaldatagroup_list);
|
| for(var integer i := 0; i < vl_externaldatagroup_list_size; i := i + 1) {
|
| f_EPTF_UIHandler_Config_processValueListiterator(vl_externaldatagroup_list[i], vl_xul, vl_metaIteratorIdx, false, vl_widgetExists);
|
| }
|
| }
|
| }
|
|
|
| // notify the GUI about the update:
|
| var charstring vl_iteratorParentId := "";
|
| if(v_UIHandler_guiItemList[vl_metaIteratorIdx].parentIdx != -1) {
|
| var integer vl_iteratorNotMetaParentIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(v_UIHandler_guiItemList[vl_metaIteratorIdx].parentIdx);
|
| vl_iteratorParentId := v_UIHandler_guiItemList[vl_iteratorNotMetaParentIdx].id;
|
| }
|
| if(tsp_EPTF_UIHandler_enableBrowserGUI == true){
|
| f_EPTF_UIHandler_Browser_reportGUIChanged(vl_iteratorParentId);
|
| }
|
|
|
| //rebuild the runtimeGUI:
|
| if(v_UIHandler_guiConnected){
|
| var Widgets vl_widgets_to_send;
|
| f_EPTF_UIHandler_buildXUL(vl_widgets_to_send, true);
|
| f_EPTF_UIHandler_clearGUI(false);
|
| //var integer vl_notMetaParentIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(vl_metaIteratorIdx);
|
| // Ez itt ujra beolvastatja a widget kezelovel a teljes lapot - private helyette
|
| f_EPTF_UIHandler_XSD_addElementToGui_private(vl_widgets_to_send, "", vl_widgetExists,false);
|
| }
|
|
|
| // wait to finish all getData handlers:
|
| f_EPTF_UIHandler_waitForProcessExternalData_handlers()
|
| f_EPTF_UIHandler_Config_connectAllVarsToWidget();
|
|
|
| } else {
|
| // if not remove the postproc:
|
| f_EPTF_Var_removePostProcFn(pl_idx, {refers(f_EPTF_UIHandler_updateIterator_PostProc), {vl_metaIteratorIdx}});
|
| return; // no metaiterator found
|
| }
|
| }
|
|
|
| friend function f_EPTF_UIHandler_getNonEmptyParentId(in integer pl_parentIdx, out charstring pl_widgetid) runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| pl_widgetid := "";
|
| var integer vl_parentIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(pl_parentIdx);
|
| if(vl_parentIdx != -1){
|
| pl_widgetid := v_UIHandler_guiItemList[vl_parentIdx].id;
|
| while(pl_widgetid == "" and vl_parentIdx != -1){
|
| vl_parentIdx := f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(v_UIHandler_guiItemList[vl_parentIdx].parentIdx);
|
| if(vl_parentIdx != -1){
|
| pl_widgetid := v_UIHandler_guiItemList[vl_parentIdx].id;
|
| }
|
| }
|
| }
|
| return vl_parentIdx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendTreeRow
|
| //
|
| // Purpose:
|
| // appending the treerow widget to the widget database
|
| //
|
| // Parameters:
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendTreeRow(
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
|
|
| pl_widgetExists := false;
|
| var charstring vl_id := f_EPTF_UIHandler_unichar2charstring(f_EPTF_UIHandler_getrandomid(true));
|
| var integer vl_treerowIdx := f_EPTF_UIHandler_addWidgetRec({
|
| "",
|
| wtTreerow,
|
| omit,
|
| pl_parentIdx,
|
| { },
|
| omit,
|
| {treerow := { treecellgroups := {treecellgroup_list := {}}}}, false}, pl_widgetExists);
|
| return vl_treerowIdx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_appendMetaIterator
|
| //
|
| // Purpose:
|
| // appending the iterator widget to the widget database
|
| //
|
| // Parameters:
|
| // pl_parentIdx - *in* *integer* the idx of the parent widget in the gui items' list
|
| // pl_widgetExists - *inout* *boolean* returns true if the widget already exists
|
| // pl_iteratorVarIdx - *in* *integer* - the index of the iterator variable the new metaIterator belongs to
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_appendMetaIterator(
|
| in integer pl_parentIdx,
|
| inout boolean pl_widgetExists,
|
| in EPTF_UIHandler_IteratorUnionType pl_iteratorUnionType,
|
| in integer pl_iteratorVarIdx,
|
| in integer pl_nodePointer,
|
| in boolean pl_isExternalValue)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
|
|
| if (pl_iteratorVarIdx<0) {
|
| pl_iteratorVarIdx := f_EPTF_Var_getId("NonexistentIterator");
|
| if (pl_iteratorVarIdx == -1) {
|
| f_EPTF_Var_newCharstringlist("NonexistentIterator", {}, pl_iteratorVarIdx);
|
| }
|
| }
|
|
|
| pl_widgetExists := false;
|
| var charstring vl_id := "metaiterator_" & f_EPTF_UIHandler_unichar2charstring(f_EPTF_UIHandler_getrandomid());
|
|
|
| var EPTF_Var_DirectContent vl_currentContent;
|
| f_EPTF_Var_getContent(pl_iteratorVarIdx, vl_currentContent);
|
| // if its externalvalue or iterator vith single variable
|
| if( pl_isExternalValue == true or not ischosen(vl_currentContent.charstringlistVal)) {
|
| var charstring vl_varName := f_EPTF_Var_getName(pl_iteratorVarIdx);
|
| pl_iteratorVarIdx := f_EPTF_Var_getId(vl_varName&cg_ExternalVariableSign);
|
| if(pl_iteratorVarIdx == -1){
|
| f_EPTF_Var_newCharstringlist(vl_varName&cg_ExternalVariableSign, {vl_varName}, pl_iteratorVarIdx);
|
| }
|
| }
|
|
|
| var EPTF_CharstringList vl_currentValue := f_EPTF_Var_getCharstringlistValue(pl_iteratorVarIdx);
|
|
|
| //var charstring vl_id := "metaiterator_" & int2str(v_UIHandler_GUI_DescriptionDB_Idx) & "_" & int2str(vl_iteratorumber);
|
| var integer vl_metaIteratorIdx := f_EPTF_UIHandler_addWidgetRec({
|
| vl_id,
|
| wtMetaIterator,
|
| omit,
|
| pl_parentIdx,
|
| { },
|
| {metaIteratorData := {v_UIHandler_GUI_DescriptionDB_Idx, pl_iteratorUnionType, pl_iteratorVarIdx, vl_currentValue, pl_nodePointer}},
|
| {metaiterator := { id := vl_id }}, false}, pl_widgetExists);
|
| f_EPTF_Var_addPostProcFn(pl_iteratorVarIdx, {refers(f_EPTF_UIHandler_updateIterator_PostProc), {vl_metaIteratorIdx}});
|
| return vl_metaIteratorIdx;
|
|
|
| }
|
|
|
| friend function f_EPTF_UIHAndler_getNotMetaiteratorParentIdx(in integer pl_widgetIdx)
|
| runs on EPTF_UIHandler_Private_CT
|
| return integer{
|
| var integer vl_widgetIdx := pl_widgetIdx;
|
| while(vl_widgetIdx != -1 and v_UIHandler_guiItemList[vl_widgetIdx].widgetType == wtMetaIterator) {
|
| vl_widgetIdx := v_UIHandler_guiItemList[vl_widgetIdx].parentIdx;
|
| }
|
| return vl_widgetIdx;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_UIHandler_getNonMetaChildren
|
| //
|
| // Purpose:
|
| // Returns the list of all children. If one child is a metaiterator
|
| // it returns its non-meta children
|
| //
|
| // Parameters:
|
| // pl_itemIdx - *in* *integer* - the idx of the GUI item
|
| //
|
| // Return Value:
|
| // EPTF_IntegerList - list of non-meta children indexes
|
| //
|
| ///////////////////////////////////////////////////////////
|
| private function f_EPTF_UIHandler_getNonMetaChildren(
|
| in integer pl_itemIdx
|
| ) runs on EPTF_UIHandler_Private_CT return EPTF_IntegerList {
|
| var EPTF_IntegerList vl_nonMetaChildren := {};
|
|
|
| var EPTF_IntegerList vl_children := v_UIHandler_guiItemList[pl_itemIdx].children;
|
|
|
| for(var integer i:=0; i<sizeof(vl_children); i:=i+1) {
|
| if (v_UIHandler_guiItemList[vl_children[i]].widgetType == wtMetaIterator) {
|
| vl_nonMetaChildren := vl_nonMetaChildren & f_EPTF_UIHandler_getNonMetaChildren(vl_children[i]);
|
| } else {
|
| vl_nonMetaChildren[sizeof(vl_nonMetaChildren)] := vl_children[i];
|
| }
|
| }
|
| return vl_nonMetaChildren;
|
| }
|
|
|
| private function f_EPTF_UIHandler_parseIteratorMetadata(out integer pl_nodepointer, out integer pl_iteratorVarIdx, in charstring pl_metadata, in charstring pl_separator := "_") {
|
| var integer vl_separatorPos := f_strstr(pl_metadata,pl_separator);
|
| if (vl_separatorPos<0) {
|
| return; //error: no separator found
|
| }
|
|
|
| pl_nodepointer := str2int(substr(pl_metadata,0,vl_separatorPos));
|
| pl_iteratorVarIdx := str2int(substr(pl_metadata,vl_separatorPos+1,lengthof(pl_metadata)-vl_separatorPos-1));
|
| }
|
|
|
|
|
|
|
|
|
| public external function f_EPTF_UIHandler_GUIFunctions_Tests() return charstring
|
|
|
| } // end of module
|