void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig_Void( "check", _HELP("Connect event here to check the inventory for the item" ), _HELP("Check") ),
			InputPortConfig<string>( "item", _HELP("The item to add to the inventory" ), _HELP("Item"), _UICONFIG("enum_global_ref:item%s:ItemType")),
			InputPortConfig<string>( "ItemType", "", _HELP("Select from which items to choose"), 0, _UICONFIG("enum_string:All=,Givable=_givable,Selectable=_selectable")),
			{0}
		};

		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig<bool>("out", _HELP("True if the player has the item, false otherwise" ), _HELP("Out") ),
			OutputPortConfig_Void("False", _HELP("Triggered if player does not have the item" )),
			OutputPortConfig_Void("True",  _HELP("Triggered if player has the item" )),
			OutputPortConfig<EntityId>("ItemId", _HELP("Outputs the item's entity id" )),
			{0}
		};

		config.sDescription = _HELP("Check inventory to see if an item is present.");
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void("Play", _HELP("Play the fragment")),
			InputPortConfig<string>("Fragment", _HELP("Fragment name")),
			InputPortConfig<string>("Tags", _HELP("Tags, seperate by + sign")),
			InputPortConfig<int>("Priority", _HELP("Priority, higher number = higher priority")),
			InputPortConfig_Void("Pause", _HELP("Pauses the actionController")),
			InputPortConfig_Void("Resume", _HELP("Resumes this entity's actionController")),
			InputPortConfig_Void("ForceFinishLastQueued", _HELP("Finish the last queued action")),
			{0}
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void     ("Success",  _HELP("Triggers if succeeded to pass the command")),
			OutputPortConfig_Void		("Failed", _HELP("Triggers if anything went wrong")),
			{0}
		};

		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Play a Mannequin Fragment on a given entity with given Tags");
		config.SetCategory(EFLN_ADVANCED);
	}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig inp_config[] = 
		{
			InputPortConfig<int>("FilterAI", 0, _HELP("Filter which AIs are used for the alertness value."), _HELP("FilterAI"),_UICONFIG("enum_int:All=0,Enemies=1,Friends=2,Faction=3")),
			InputPortConfig<string>("Faction", "", _HELP("Only used when 'FilterAI' input is set to 'Faction'. )."), 0, "enum_global:Faction"),
			InputPortConfig<bool>("Enabled", true, _HELP("To enable/disable the node.")),
			InputPortConfig_Void("Check", _HELP("instant check.")),
			{0}
		};

		static const SOutputPortConfig out_config[] = 
		{
			OutputPortConfig<int>("alertness", "0 - green\n1 - orange\n2 - red"),
			OutputPortConfig_Void("green"),
			OutputPortConfig_Void("orange"),
			OutputPortConfig_Void("red"),
			{0}
		};

		config.sDescription = _HELP( "The highest level of alertness of the specified AIs" );
		config.pInputPorts = inp_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}

void CFlashUIGotoAndPlayBaseNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		CreateMovieClipsPort(),
		CreateInstanceIdPort(),
		InputPortConfig_Void( "GotoAndPlay", "GotoAndPlay to frame" ),
		InputPortConfig_Void( "GotoAndStop", "GotoAndStop to frame" ),
		InputPortConfig<int>( "FrameId", -1, "Frame Number, -1 = use FrameName"),
		InputPortConfig<string>( "FrameName", "FrameName, only used if FrameId is set to -1" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SInputPortConfig in_config_tmpl[] = {
		CreateMovieClipsForTmplPort(),
		CreateInstanceIdPort(),
		CreateTmplInstanceNamePort(),
		InputPortConfig_Void( "GotoAndPlay", "GotoAndPlay to frame" ),
		InputPortConfig_Void( "GotoAndStop", "GotoAndStop to frame" ),
		InputPortConfig<int>( "FrameId", -1, "Frame Number, -1 = use FrameName"),
		InputPortConfig<string>( "FrameName", "FrameName, only used if FrameId is set to -1" ),
		InputPortConfig_Void( 0 ),
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnGotoAndPlay", "On GotoAndPlay" ),
		OutputPortConfig_Void( "OnGotoAndStop", "On GotoAndStop" ),
		{0}
	};

	config.pInputPorts  =  IsTemplate() ? in_config_tmpl : in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Access to MovieClips";
	config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig<int> ("FadeGroup", 0, _HELP("Fade Group [0-3]"), 0, _UICONFIG("enum_int:0=0,1=1,2=2,3=3")),
			InputPortConfig_Void("FadeIn", _HELP("Fade back from the specified color back to normal screen")),
			InputPortConfig_Void("FadeOut", _HELP("Fade the screen to the specified color")),
			InputPortConfig<bool> ("UseCurColor", true, _HELP("If checked, use the current color as Source color. Otherwise use [FadeColor] as Source color and Target color.")),
			InputPortConfig<float>("FadeInTime", 2.0f, _HELP("Duration of fade in")),
			InputPortConfig<float>("FadeOutTime", 2.0f, _HELP("Duration of fade out")),
			InputPortConfig<Vec3> ("color_FadeColor", _HELP("Target Color to fade to")),
			InputPortConfig<string> ("tex_TextureName", _HELP("Texture Name")),
			InputPortConfig<bool> ("UpdateAlways", false, _HELP("If checked, the Fader will be updated always, otherwise only if game is not paused.")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void("FadedIn", _HELP("FadedIn")),
			OutputPortConfig_Void("FadedOut", _HELP("FadedOut")),
			OutputPortConfig<Vec3> ("CurColor", _HELP("Current Faded Color")),
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Controls Screen Fading.");
		config.SetCategory(EFLN_ADVANCED);
	}

void CD6PlayerCreditRangeNode::GetConfiguration(SFlowNodeConfig& config)
{
    // Input ports
    static const SInputPortConfig inputs[] =
    {
        InputPortConfig_Void("Trigger", _HELP("Run the test")),
        InputPortConfig<unsigned int>("MinAmount", 0.0f, _HELP("Minimum amount to check for"), _HELP("Minimum Amount")),
        InputPortConfig<unsigned int>("MaxAmount", 0.0f, _HELP("Maximum amount to check for"), _HELP("Maximum Amount")),
        {0},
    };

    // Output ports
    static const SOutputPortConfig outputs[] =
    {
        OutputPortConfig_Void("Passed", _HELP("Triggered if test passes (in range)")),
        OutputPortConfig_Void("Failed", _HELP("Triggered if test fails (not in range)")),
        {0},
    };

    // Set up config
    config.nFlags |= EFLN_TARGET_ENTITY;
    config.pInputPorts = inputs;
    config.pOutputPorts = outputs;
    config.sDescription = _HELP("Determines if player's credits are in given range");
    config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void  ("Cloak", _HELP("Trigger to select Cloak Mode")),
			InputPortConfig_Void  ("Strength", _HELP("Trigger to select Strength Mode")),
			InputPortConfig_Void  ("Defense", _HELP("Trigger to select Defense Mode")),
			InputPortConfig_Void  ("Speed", _HELP("Trigger to select Speed Mode")),
			InputPortConfig<float>("Energy", 0.0f, _HELP("Set Energy")),
			InputPortConfig<int>  ("CloakLevel", 1, _HELP("Set cloak level [1-3]")),
			InputPortConfig_Void  ("BreakHUD", _HELP("Trigger to break the HUD, causing it to disappear")),
			InputPortConfig_Void  ("RebootHUD", _HELP("Trigger to reboot the HUD, causing it to appear")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void  ("Cloak", _HELP("Triggered on Default Mode")),
			OutputPortConfig_Void  ("Strength", _HELP("Triggered on Strength Mode")),
			OutputPortConfig_Void  ("Defense", _HELP("Triggered on Defense Mode")),
			OutputPortConfig_Void  ("Speed", _HELP("Triggered on Speed Mode")),
			OutputPortConfig<float>("Energy", _HELP("Current Energy")),
			OutputPortConfig<int>  ("CloakLevel", _HELP("Current cloak level [set when Cloak mode is active]")),
			// OutputPortConfig_Void  ("BreakHUD", "Triggered on breaking the HUD"),
			// OutputPortConfig_Void  ("RebootHUD", "Triggered on rebooting the HUD"),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("NanoSuit Node");
		config.SetCategory(EFLN_WIP);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		// Define input ports here, in same order as EInputPorts
		static const SInputPortConfig inputs[] =
		{
			InputPortConfig_Void("Enable", _HELP("Enable receiving signals")),
			InputPortConfig_Void("Disable", _HELP("Disable receiving signals")),
			InputPortConfig<int>("Port", 1234, _HELP("Port number"), 0,0),
			InputPortConfig<string>("Multicast", "225.1.1.2", _HELP("UDP Multicast address (between 225.0.0.1 and 239.255.255.255)"), 0,0),
			{0}
		};

		// Define output ports here, in same oreder as EOutputPorts
		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig<bool>("Success", _HELP("UDP socket successfully opened for listening")), 
			OutputPortConfig<bool>("Fail", _HELP("UDP socket failed to open")), 
			OutputPortConfig<bool>("Received", _HELP("New data")), 
			OutputPortConfig_Void("Value", _HELP("Value")),
			OutputPortConfig_Void("Error", _HELP("Error generated by UDP Listener")),
			{0}
		};

		// Fill in configuration
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Opens a Multicast UDP listener");
		//config.SetCategory(EFLN_ADVANCED);
	}

void CFlowNode_SimulateInput::GetConfiguration(SFlowNodeConfig &config)
{
	static const SInputPortConfig in_ports[] =
	{
		InputPortConfig<string>("ActionInput", _HELP("Action input to trigger"), _HELP("Action"), _UICONFIG("enum_global:input_actions")),
		InputPortConfig_Void("Press", _HELP("Simulate press")),
		InputPortConfig_Void("Hold", _HELP("Simulate hold event")),
		InputPortConfig_Void("Release", _HELP("Simulate relase")),
		InputPortConfig<float>("Value", 0.0f, _HELP("Value between 0 and 1")),
		{0}
	};

	static const SOutputPortConfig out_ports[] =
	{
		OutputPortConfig_Void("Pressed", _HELP("Pressed")),
		OutputPortConfig_Void("Held", _HELP("Held")),
		OutputPortConfig_Void("Released", _HELP("Released")),
		{0}
	};

	config.sDescription = _HELP("Simulate player actions input");
	config.pInputPorts = in_ports;
	config.pOutputPorts = out_ports;
	config.SetCategory(EFLN_DEBUG);
}

	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		// declare input ports
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig<bool>("MissionOnly", "Only trigger on events involving mission tracked entities"),
			InputPortConfig<string>("Class", "AllClasses", "Class you want to filter on. For custom classes, use CustomClasses input", 0,  _UICONFIG("enum_global:entity_classes") ),
			InputPortConfig<string>("CustomClasses", "Optional: Add classes you want to filter the entities on (comma separated)"),
			{0}
		};

		// declare output ports
		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig_Void("EntityAdded", "Fires when a entity is added to the radar from the Mission"),
			OutputPortConfig_Void("EntityRemoved", "Fires when a entity is removed from the radar by a Mission"),
			OutputPortConfig<EntityId>("Entity", "The entity that needs adding"),
			{0}
		};

		// we set pointers in "config" here to specify which input and output ports the node contains
		config.sDescription = _HELP("Fires when entities are added or removed to the radar from a mission");
		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.SetCategory(EFLN_APPROVED);
	}

void CFlashUIActionNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig<string>( "uiActions_UIAction", "Name of UI action", _HELP("UIAction") ),
		InputPortConfig<bool>( "Strict", false, "If true this node will log an error if the UIAction does not exist, otherwise it can be used in a more loose way." ),
		InputPortConfig_Void( "Start", "Start UI action" ),
		InputPortConfig<string>( "Args", "Comma separated argument string" ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnStart", "Triggered if this node starts the action" ),
		OutputPortConfig_Void( "OnEnd", "Triggered if action is stopped and was started by this node" ),
		OutputPortConfig_Void( "OnStartAll", "Always triggered if the action started" ),
		OutputPortConfig_Void( "OnEndAll", "Always triggered if action is stopped" ),
		OutputPortConfig<string>( "Args", "Comma separated argument string" ),
		{0}
	};


	config.pInputPorts = in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Controls an UI Action";
	config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		// Define input ports here, in same order as EInputPorts
		static const SInputPortConfig inputs[] =
		{
			InputPortConfig_Void("Enable", _HELP("Enable receiving signals")),
			InputPortConfig_Void("Disable", _HELP("Disable receiving signals")),
			InputPortConfig<int>("Port", 1234, _HELP("Port number"), 0,0),
			{0},
		};

		// Define output ports here, in same oreder as EOutputPorts
		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig<bool>("Success", _HELP("UDP socket successfully opened for listening")), 
			OutputPortConfig<bool>("Fail", _HELP("UDP socket failed to open")), 
			OutputPortConfig<bool>("Received", _HELP("New data")), 
			OutputPortConfig_Void("CVAR", _HELP("Value")),
			OutputPortConfig_Void("Value", _HELP("Value")),
			{0},
		};

		// Fill in configuration
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Opens a UDP listener");
		//config.SetCategory(EFLN_ADVANCED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void    ("Play", _HELP("Display USMPlayer and start playback")),
			InputPortConfig_Void    ("Stop", _HELP("Stop playback and hide USMPlayer")),
			InputPortConfig_Void    ("Pause", _HELP("Pause playback")),
			InputPortConfig_Void    ("Resume", _HELP("Resume playback")),
			InputPortConfig<int>    ("InstanceID", -1, _HELP("Instance ID of USMPlayer (e.g. to use USMPlayer on dynamic textures)")),
			InputPortConfig<string> ("VideoFile", _HELP("Name of usm file, file should be placed in Libs/UI/ or subfolder")),
			InputPortConfig<bool>   ("Transparent", false, _HELP("If player background is transparent or not")),
			InputPortConfig<bool>   ("Loop", false, _HELP("If true, video playback loops")),
			InputPortConfig<bool>   ("Skipable", true, _HELP("If true, player can skip video by pressing on of the skip keys (see ActionMap)")),
			InputPortConfig<int>    ("AudioChannel", 0, _HELP("Audio channel")),
			InputPortConfig<int>    ("SubtitleChannel", 0, _HELP("Subtitle channel")),
			InputPortConfig_Null()
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void  ("OnPlay",	_HELP("Triggered once the video started")),
			OutputPortConfig<bool> ("OnStop",	_HELP("Triggered once the video stopped. True if the video was finished, flase if skiped")),
			OutputPortConfig_Void  ("OnPause",	_HELP("Triggered once the video is paused")),
			OutputPortConfig_Void  ("OnResume",	_HELP("Triggered once the video resumes")),
			OutputPortConfig_Void  ("OnLooped",	_HELP("Triggered once the video looped and start again")),
			OutputPortConfig_Void  ("OnVideoNotFound",	_HELP("Triggered on Video was not found")),
			OutputPortConfig_Null()
		};

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP( "Video player node that is using USMPlayer UIElement" );
		config.SetCategory( EFLN_ADVANCED );
	}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] = 
		{
			InputPortConfig<Vec3>( "Destination",_HELP("Destination") ),
			InputPortConfig<bool>( "DynamicUpdate", true, _HELP("If dynamic update of Destination [follow-during-movement] is allowed or not"), _HELP("DynamicUpdate") ),
			InputPortConfig<int>( "ValueType", 0, _HELP("Defines if the 'Value' input will be interpreted as speed or as time (duration)."), _HELP("ValueType"), _UICONFIG("enum_int:speed=0,time=1") ),
			InputPortConfig<float>( "Speed", 0.f, _HELP("Speed (m/sec) or time (duration in secs), depending on 'ValueType' input."), _HELP("Value")),
			InputPortConfig<float>( "EaseDistance", 0.f, _HELP("Distance from destination at which the moving entity starts slowing down (0=no slowing down)"), _HELP("EaseInDistance") ),
			InputPortConfig<float>( "EaseOutDistance", 0.f, _HELP("Distance from destination at which the moving entity starts slowing down (0=no slowing down)") ),
			InputPortConfig<int> ( "CoordSys", 0, _HELP("Destination in world, local or parent space"), _HELP("CoordSys"), _UICONFIG("enum_int:Parent=0,World=1,Local=2") ),
			InputPortConfig_Void( "Start", _HELP("Trigger this port to start the movement") ),
			InputPortConfig_Void( "Stop",  _HELP("Trigger this port to stop the movement") ),
			{0}
		};
		static const SOutputPortConfig out_config[] = 
		{
			OutputPortConfig<Vec3>("Current",_HELP("Current position")),
			OutputPortConfig_Void("Start", _HELP("Triggered when start input is triggered")),
			OutputPortConfig_Void("Stop", _HELP("Triggered when stop input is triggered")),
			OutputPortConfig_Void("Finish", _HELP("Triggered when destination is reached")),
			OutputPortConfig_Void("DoneTrigger", _HELP("Triggered when destination is reached or stop input is triggered"), 	_HELP("Done")),
			{0}
		};
		config.sDescription = _HELP( "Move an entity to a destination position at a defined speed or in a defined interval of time" );
		config.nFlags |= EFLN_TARGET_ENTITY|EFLN_AISEQUENCE_SUPPORTED;
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}

    virtual void GetConfiguration( SFlowNodeConfig& config )
    {
        static const SInputPortConfig inPorts[] =
        {
            InputPortConfig_Void( "Start" ),
            InputPortConfig_Void( "Stop" ),
            InputPortConfig< string >( "PathName" ),
            InputPortConfig< bool >( "LoopPath", false ),
            InputPortConfig< float >( "Speed", 30 ),
            { 0 }
        };

        static const SOutputPortConfig outPorts[] =
        {
            OutputPortConfig_Void( "ArrivedAtEnd" ),
            OutputPortConfig_Void( "ArrivedNearToEnd" ),
            OutputPortConfig_Void( "Stopped" ),
            { 0 }
        };

        config.pInputPorts = inPorts;
        config.pOutputPorts = outPorts;
        config.nFlags |= EFLN_TARGET_ENTITY;
        config.sDescription = _HELP( "Set the path the AI should follow. When not in combat mode it will follow as accurately as possible from start to end. When in combat mode it represents the path along where the AI is allowed to position itself/patrol." );
        config.SetCategory( EFLN_APPROVED );
    }

//------------------------------------------------------------------------------------------------------
void CFlashUIDisplayConfigNode::GetConfiguration( SFlowNodeConfig &config )
{
    static const SInputPortConfig in_config[] = {
        CreateElementsPort(),
        CreateInstanceIdPort(),
        InputPortConfig_Void( "get",	"Get configuration" ),
        InputPortConfig_Void( "set",	"set configuration" ),

        InputPortConfig<bool>( "cursor", "Enables mouse cursor" ),
        InputPortConfig<bool>( "mouseEvents", "Enables mouse events" ),
        InputPortConfig<bool>( "keyEvents", "Enables mouse events" ),
        InputPortConfig<bool>( "consoleMouse", "Enables use controller stick as mouse on console (only if \"mouseEvents\" is enabled)" ),
        InputPortConfig<bool>( "consoleCursor", "Enables cursor on console (only if \"cursor\" is enabled)" ),
        InputPortConfig<bool>( "controllerInput", "Enables controller input" ),
        InputPortConfig<bool>( "eventsExclusive", "If set to true no other elements will receive events if this element receives them first" ),
        InputPortConfig<bool>( "fixedProjDepth", "If set to true this element will use pseudo 3D mode. The _z value of each movieclip will only affect its size to give the feeling of \"correct\" depth" ),

        InputPortConfig<bool>( "forceNoUnload", "If set to true this element will not be unloaded on level unload (flag will be applied to all instances!)" ),

        InputPortConfig<float>( "alpha", "Alpha" ),
        InputPortConfig<int>( "layer", "layer of the element" ),
        {0}
    };

    static const SOutputPortConfig out_config[] = {
        OutputPortConfig_Void( "OnSet", _HELP("Triggered on set")),
        OutputPortConfig_Void( "OnGet", _HELP("Triggered on get")),
        OutputPortConfig<bool>( "isVisible", "Current menu state" ),

        OutputPortConfig<bool>( "hasCursor", "Current cursor state" ),
        OutputPortConfig<bool>( "hasMouseEvents", "Current mouse event state" ),
        OutputPortConfig<bool>( "hasKeyEvents", "Current key event state" ),
        OutputPortConfig<bool>( "isConsoleMouse", "Current console mouse state" ),
        OutputPortConfig<bool>( "isConsoleCursor", "Current console cursor state" ),
        OutputPortConfig<bool>( "isControllerInput", "Current controller input state" ),
        OutputPortConfig<bool>( "isEventsExclusive", "Current event exclusive state" ),
        OutputPortConfig<bool>( "isFixedProjDepth", "Current fixedProjDepth state" ),

        OutputPortConfig<bool>( "isForceNoUnload", "Current forceNoUnload state" ),

        OutputPortConfig<float>( "alpha", "Current alpha value" ),
        OutputPortConfig<int>( "layer", "layer of the element" ),
        {0}
    };

    config.sDescription = "Node to setup flags for UIElements";
    config.pInputPorts = in_config;
    config.pOutputPorts = out_config;
    config.SetCategory( EFLN_APPROVED );
}

            virtual void GetConfiguration( SFlowNodeConfig& config )
            {
                static const SInputPortConfig inputs[] =
                {
                    InputPortConfig_Void( "Open",                                _HELP( "Open / Start paused (call Resume)" ) ),
                    InputPortConfig_Void( "Close",                               _HELP( "Close / Stop" ) ),

                    InputPortConfig<string>( "file_File",    "",                 _HELP( "videofile (set on Open)" ),                   "sFile",                        _UICONFIG( "" ) ),
                    InputPortConfig<string>( "sound_Sound",  "",                 _HELP( "soundfile/event (set on Open)" ),             "sSound",                       _UICONFIG( "" ) ),
                    InputPortConfig<bool>( "Loop",           true,               _HELP( "loops the video (set on Open)" ),             "bLoop" ),
                    InputPortConfig<bool>( "Skippable",      false,              _HELP( "Can this video be skipped by the user" ),     "bSkippable" ),
                    InputPortConfig<bool>( "BlockGame",      false,              _HELP( "Block Game while this video is playing" ),    "bBlockGame" ),

                    InputPortConfig<float>( "StartAt",       0.0,                _HELP( "start [sec]" ),                               "fStartAt" ),
                    InputPortConfig<float>( "EndAfter",      0.0,                _HELP( "end/loop [sec]" ),                            "fEndAfter" ),
                    InputPortConfig<int>( "CustomWidth",     -1,                 _HELP( "custom render width [px]" ),                  "nCustomWidth" ),
                    InputPortConfig<int>( "CustomHeight",    -1,                 _HELP( "custom render height [px]" ),                 "nCustomHeight" ),
                    InputPortConfig<int>( "TimeSource",      int( VTS_Default ),   _HELP( "timesource to sync to" ),                     "nTimeSource",                  _UICONFIG( "enum_int:Game=1,Sound=2,System=4,SoundOrGame=3,SoundOrSystem=6" ) ),
                    InputPortConfig<int>( "DropMode",        int( VDM_Default ),   _HELP( "dropmode to use for sync" ),                  "nDropMode",                    _UICONFIG( "enum_int:None=0,Drop=1,Seek=2,DropOutput=4,DropOrSeek=3,DropOutputOrSeek=6" ) ),
                    InputPortConfig<float>( "Speed",         1.0,                _HELP( "play speed" ),                                "fSpeed" ),

                    InputPortConfig_Void( "Resume",                              _HELP( "Resume" ) ),
                    InputPortConfig_Void( "Pause",                               _HELP( "Pause" ) ),

                    InputPortConfig_Void( "Seek",                                _HELP( "seeks to position" ) ),
                    InputPortConfig<float>( "PositionI",     0.0,                _HELP( "position for seek [sec]" ),                   "fPosition" ),
                    InputPortConfig_Null(),
                };

                static const SOutputPortConfig outputs[] =
                {
                    OutputPortConfig<int>( "VideoID",                            _HELP( "id for further use" ),                        "nVideoID" ),
                    OutputPortConfig<bool>( "Playing",                           _HELP( "currently playing" ),                         "bPlaying" ),
                    OutputPortConfig<float>( "PositionO",                        _HELP( "position [sec]" ),                            "fPosition" ),
                    OutputPortConfig_Void( "OnStart",                            _HELP( "start/loop begin reached" ) ),
                    OutputPortConfig_Void( "OnEnd",                              _HELP( "End reached" ) ),
                    OutputPortConfig<float>( "Duration",                         _HELP( "duration [sec]" ),                            "fDuration" ),
                    OutputPortConfig<float>( "FPS",                              _HELP( "frames per second" ),                         "fFPS" ),
                    OutputPortConfig<int>( "Width",                              _HELP( "decoder width [px]" ),                        "nWidth" ),
                    OutputPortConfig<int>( "Height",                             _HELP( "decoder height [px]" ),                       "nHeight" ),
                    OutputPortConfig_Null(),
                };

                config.pInputPorts = inputs;
                config.pOutputPorts = outputs;
                config.sDescription = _HELP( PLUGIN_CONSOLE_PREFIX "Videosource WebM" );

                config.SetCategory( EFLN_APPROVED );
            }

void CFlowConvoyNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig<string>( "Path",_HELP("Path to move the train on") ),
		InputPortConfig<int>( "LoopCount",0,_HELP("How many times to loop along the path (-1 for infinite)") ),
		InputPortConfig<float>( "Speed",_HELP("Speed in m/s (not work with negative speed)") ),
		InputPortConfig<float>( "DesiredSpeed",_HELP("Speed in m/s (not work with negative speed)") ),
		InputPortConfig<bool>( "Shift",_HELP("dO SHIFT") ),
		InputPortConfig<float>( "ShiftTime",_HELP("Speed in m/s (not work with negative speed)") ),
		InputPortConfig<float>( "StartDistance",_HELP("Start distance of the last coach end (from the start of the path)") ),
		InputPortConfig<int>( "SplitCoachNumber",_HELP("If acticated, the train splits from this coach") ),
		InputPortConfig<bool>( "XAxisIsForward", false, _HELP("If true, and coaches are not CHRs, will make X axis forward instead of Y") ),
		InputPortConfig_Void( "PlayHornSound",_HELP("If acticated, train horn sound played") ),
		InputPortConfig_Void( "PlayBreakSound",_HELP("If acticated, train break sound played") ),
		InputPortConfig_Void( "Start",_HELP("Trigger to start the convoy") ),
		InputPortConfig_Void( "Stop",_HELP("Trigger to stop the convoy") ),
		{0}
	};
	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void("onPathEnd", _HELP("Triggers when first coach reaches the end of the path")),
		OutputPortConfig<int> ("PlayerCoachIndex", _HELP("gives the coach index Player is standing on, (-1) if not on train for at least 4 seconds")),
		{0}
	};

	config.sDescription = _HELP( "Convoy node will move a special entity on an AIPath with speed" );
	config.pInputPorts = in_config;
	config.pOutputPorts = out_config;
	config.SetCategory(EFLN_APPROVED);
	config.nFlags |= EFLN_TARGET_ENTITY;
}

void CFlowNode_AISequenceAction_ApproachAndEnterVehicle::GetConfiguration(SFlowNodeConfig& config)
{
	static const SInputPortConfig inputPortConfig[] =
	{
		InputPortConfig_Void("Start"),
		InputPortConfig<EntityId>("VehicleId", _HELP("Vehicle to be entered")),
		InputPortConfig<int>("SeatNumber", _HELP("Seat to be entered"), _HELP("Seat"), _UICONFIG("enum_int:None=0,Driver=1,Gunner=2,Seat03=3,Seat04=4,Seat05=5,Seat06=6,Seath07=7,Seat08=8,Seat09=9,Seat10=10,Seat11=11")),
		InputPortConfig<int>("Speed", _HELP("Speed to approach the vehicle with"), NULL, _UICONFIG("enum_int:Walk=0,Run=1,Sprint=2")),
		InputPortConfig<int>("Stance", _HELP("Stance while approaching the vehicle"), NULL, _UICONFIG("enum_int:Relaxed=0,Alert=1,Combat=2")),
		InputPortConfig<bool>("Fast", _HELP("skip approaching and entering animation")),
		{ 0 }
	};

	static const SOutputPortConfig outputPortConfig[] =
	{
		OutputPortConfig_Void("Done"),
		{ 0 }
	};

	config.pInputPorts = inputPortConfig;
	config.pOutputPorts = outputPortConfig;
	config.sDescription = _HELP("Allows the AI agent to move to the specified vehicle and to then enter the specified seat");
	config.nFlags |= EFLN_TARGET_ENTITY | EFLN_AISEQUENCE_ACTION;
	config.SetCategory(EFLN_APPROVED);
}

// --------------------------------------------------------------
void CFlashUIToArrayNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig_Void( "Set", "Set this array"),
		InputPortConfig<int>( "Count", 4, _HELP("Number of elements for this array"), 0, _UICONFIG( "enum_int:1,2,3