r2.maxActivities = 14
r2.sequencesNb = 0

r2.TimeLimitsProp = {
						[tostring(i18n.get("uiR2EdNoTimeLimit"))]="No Limit",
						--["Until a certain time"]="Until",
						[tostring(i18n.get("uiR2EdWhileChat"))]="Chat",
						[tostring(i18n.get("uiR2EdForCertainTime"))]="Few Sec"
				    }
r2.TimeLimitsCB =   {
						["No Limit"]=tostring(i18n.get("uiR2EdNoTimeLimit")),
						--["Until"]="Until a certain time",
						["Chat"]=tostring(i18n.get("uiR2EdWhileChat")),
						["Few Sec"]=tostring(i18n.get("uiR2EdForCertainTime")),
				    }

r2.activityTypeMenu =   {
							["Inactive"]=tostring(i18n.get("uiR2EdInactive")),
							["Stand Still"]=tostring(i18n.get("uiR2EdStandStill")),
							["Follow Route"]=tostring(i18n.get("uiR2EdFollowRoad")),
							["Patrol"]=tostring(i18n.get("uiR2EdPatrol")),
							["Repeat Road"]=tostring(i18n.get("uiR2EdRepeatRoad")),
							--["Deploy"]=tostring(i18n.get("uiR2EdDeploy")),
							["Wander"]=tostring(i18n.get("uiR2EdWander")),
							["Stand On Start Point"]=tostring(i18n.get("uiR2EdStandOnStartPoint")),
							["Go To Start Point"]=tostring(i18n.get("uiR2EdGoToStartPoint")),
							["Go To Zone"]=tostring(i18n.get("uiR2EdGoToZone")),
							["Sit Down"]=tostring(i18n.get("uiR2EdSitDown")),
							["Stand Up"]=tostring(i18n.get("uiR2EdStandUp")),
							
						}

r2.fromNPCNameToId = {}
r2.fromEmoteIdToName = {}

r2.ownCreatedInstances = {}


------------------ INIT TRIGGERS EDITOR ----------------------------------------------------------------
function r2:initTriggersEditor()

	-- emote
	local menuName = "ui:interface:r2ed_triggers_menu"
	local emoteMenu = getUI(menuName)
	local emoteMenu = emoteMenu:getRootMenu()
	assert(emoteMenu)
	emoteMenu:reset()

	local emoteTable = initEmotesMenu(menuName, "")
	for id, name in pairs(emoteTable) do
		r2.fromEmoteIdToName[id] = name
	end
end

------------------ INIT TRIGGERS EDITOR ----------------------------------------------------------------
function r2:initActivityEditor(activityEditor)

	-- time limit
	local timeLimitCB = activityEditor:find("time_limit"):find("combo_box")
	assert(timeLimitCB)
	timeLimitCB:resetTexts()
	timeLimitCB:addText(i18n.get("uiR2EdNoTimeLimit"))
	--timeLimitCB:addText("Until a certain time")
	timeLimitCB:addText(i18n.get("uiR2EdForCertainTime"))
	timeLimitCB:addText(i18n.get("uiR2EdWhileChat"))
end

----------------------------------------------------------------------------------------------------
function r2:getSelectedEltUI(uiName)
	local id = r2:getSelectedEltUIId(uiName)
	if id then
		return getUI(id)
	else
		return nil
	end
end

----------------------------------------------------------------------------------------------------
function r2:getSelectedEltUIId(uiName)

	if uiName == nil then
		dumpCallStack(1)
		assert(false)
	end
	local windowUI = getUI("ui:interface:"..uiName)
	assert(windowUI)

	return windowUI.Env.selectedElementId
end

----------------------------------------------------------------------------------------------------
function r2:setSelectedEltUIId(uiName, eltUIId)
	local windowUI = getUI("ui:interface:"..uiName)
	assert(windowUI)

	windowUI.Env.selectedElementId = eltUIId
end

----------------------------------------------------------------------------------------------------
function r2:getSelectedEltInstId(uiName)

	local element = r2:getSelectedEltUI(uiName)
	if element ~= nil then
		return element.Env.elementId
	else
		return nil
	end
end

----------------------------------------------------------------------------------------------------
function r2:setSelectedEltInstId(uiName, instId)
	local element = r2:getSelectedEltUI(uiName)
	assert(element)
	element.Env.elementId = instId
end

----------------------------------------------------------------------------------------------------
function r2:getSelectedEltInst(uiName)
	local id = r2:getSelectedEltInstId(uiName)
	if id then
		return r2:getInstanceFromId(id)
	else
		return nil
	end
end

----------------------------------------------------------------------------------------------------
function r2:getSelectedSequInstId(uiName)
	local windowUI = getUI("ui:interface:"..uiName)
	assert(windowUI)

	local tab = windowUI:find("sequence_tabs")
	assert(tab)

	local sequence = windowUI:find(tab.associatedGroupSelection)
	assert(sequence)

	if sequence.Env == nil then return nil end

	return sequence.Env.sequenceId
end

----------------------------------------------------------------------------------------------------
function r2:getSelectedSequInst(uiName)
	local id = r2:getSelectedSequInstId(uiName)
	if id then
		return r2:getInstanceFromId(id)
	else
		return nil
	end
end

----------------------------------------------------------------------------------------------------
function r2:getSelectedSequ(uiName)
	local windowUI = getUI("ui:interface:"..uiName)
	assert(windowUI)

	local tab = windowUI:find("sequence_tabs")
	
	if tab~=nil then
		local associatedGroup = tab.associatedGroupSelection
		if associatedGroup == "" then
			return nil
		end

		local sequence = windowUI:find(associatedGroup)
		assert(sequence)

		return sequence
	else
		return windowUI:find("sequence_elts")
	end
end

----------------------------------------------------------------------------------------------------
function r2:setSelectedSequInstId(uiName, instanceId)

	local windowUI = getUI("ui:interface:"..uiName)
	assert(windowUI)

	local tab = windowUI:find("sequence_tabs")
	assert(tab)

	local sequence = windowUI:find(tab.associatedGroupSelection)
	assert(sequence)

	sequence.Env.sequenceId = instanceId
end

------------------ CLOSE ALL UI --------------------------------------------------------------------
function r2:closeActivitySequenceUI()

	local window = getUI("ui:interface:r2ed_edit_activity_sequence")
	if window~=nil then
		window.active = false

		r2:openAndUpdateMiniActivityView()
	end
end

------------------ NEW SEQUENCE --------------------------------------------------------------------
function r2:newActivitiesSequence(firstRequest, activitySequence, reset)	


	local triggersUI = getUI("ui:interface:r2ed_triggers")
	assert(triggersUI)

	local tab = triggersUI:find("sequence_tabs")
	assert(tab)

	if firstRequest and tab.tabButtonNb == 7 then return -1 end

	if firstRequest == true then
		activitySequence = r2.newComponent("ActivitySequence")

		--local name = tostring(i18n.get("uiR2EdSeq"))..tab.tabButtonNb+1
		--activitySequence.Name = name

		local npcGroup = r2:getSelectedInstance()
		assert(npcGroup)

		r2.requestInsertNode(npcGroup:getBehavior().InstanceId, "Activities", -1, "", activitySequence)
--		r2.requestInsertNode(npcGroup.InstanceId,"ActivitiesId",-1,"",activitySequence.InstanceId)
--		r2.requestInsertNode(r2:getCurrentAct().InstanceId,"ActivitiesIds",-1,"",activitySequence.InstanceId)

		r2.ownCreatedInstances[activitySequence.InstanceId] = true

		return activitySequence.InstanceId
	else

		local updateMiniActivityView = r2.ownCreatedInstances[activitySequence.InstanceId]
		if reset then
			r2.ownCreatedInstances[activitySequence.InstanceId] = true
		end
		
		local templateParams = {
									newElt="r2:newActivity(true)",
									newEltText=tostring(i18n.get("uiR2EdNewActivity")),
									eltOrderText=tostring(i18n.get("uiR2EdActivityOrder")),
									upElt="r2:upActivity()",
									downElt="r2:downActivity()",
									maxMinElts="r2:maximizeMinimizeActivities()",
									downUpColor="200 120 80 255",
									colPushed = "200 80 80 255",
									paramsL= "r2:selectSequenceTab('r2ed_triggers', "..tostring(tab.tabButtonNb)..")"
							   }

		local editorEltTemplate = "template_edit_activity"
		local sequence = r2:newElementsSequence("r2ed_triggers", templateParams, editorEltTemplate, 
			activitySequence, tostring(i18n.get("uiR2EdSeq")))
		r2:initActivityEditor(sequence:find("edit_element"))

		local activities = activitySequence.Components
		for a = 0, activities.Size - 1 do
			r2:newActivity(false, nil, activities[a])	
		end

		-- new MiniActivity sequence
		if updateMiniActivityView==true then		
			--r2:updateSequencesButtonBar(tab.tabButtonNb-1, activitySequence.Name)
			r2:updateSequencesButtonBar(tab.tabButtonNb-1, r2:getSequenceName(activitySequence))
			r2:openAndUpdateMiniActivityView()
		end
	end
end

------------------ REMOVE SEQUENCE -----------------------------------------------------------------
function r2:removeActivitiesSequence()

	local sequenceId = r2:removeElementsSequence("r2ed_triggers", "Activities", tostring(i18n.get("uiR2EdSeq")))
	
-- 	local group = r2:getSelectedInstance()
-- 	assert(group)
-- 	local sequenceIndex = -1
-- 	for i=0,group.ActivitiesId.Size-1 do
-- 		if group.ActivitiesId[i] == sequenceId then
-- 			sequenceIndex = i
-- 			break
-- 		end
-- 	end
-- 	if sequenceIndex ~= -1 then
-- 		r2.requestEraseNode(group.InstanceId, "ActivitiesId", sequenceIndex)
-- 	end
-- 
-- 	local currentAct = r2:getCurrentAct()
-- 	sequenceIndex = -1
-- 	for i=0,currentAct.ActivitiesIds.Size-1 do
-- 		if currentAct.ActivitiesIds[i] == sequenceId then
-- 			sequenceIndex = i
-- 			break
-- 		end
-- 	end
-- 	if sequenceIndex ~= -1 then
-- 		r2.requestEraseNode(currentAct.InstanceId, "ActivitiesIds", sequenceIndex)
-- 	end
end

function r2:removeActivitiesSequenceUI(tabIndex) 
	local firstEltName = r2:removeElementsSequenceUI(tabIndex, "r2ed_triggers", "Activities", tostring(i18n.get("uiR2EdSeq")))
	
	r2:updateSequencesButtonBar(0, firstEltName)
end

------------------ SELECT ACTIVITY ------------------------------------------------------------------
function r2:selectActivity()
	r2:selectTriggerElement(nil, "r2ed_triggers")

	if getUICaller().pushed == true then
		r2:updateActivityEditor() 
	end
end

------------------ NEW ACTIVITY --------------------------------------------------------------------
function r2:newActivity(firstRequest, tableInit, instanceElement, sequenceUI, sequenceInstId)
	


	local uiName = "r2ed_triggers"

	if sequenceUI == nil then
		sequenceUI = r2:getSelectedSequ(uiName)
	end
	local activityList
	if sequenceUI~=nil then
		activityList = sequenceUI:find("elements_list")
		assert(activityList)

		if activityList.childrenNb-1 == r2.maxActivities then return false end
	end

	if firstRequest == true then

		instanceElement = r2.newComponent("ActivityStep")

		if tableInit ~= nil then
			instanceElement.Activity = tableInit.Activity
			instanceElement.ActivityZoneId = r2.RefId(tableInit.ActivityZoneId)
			instanceElement.TimeLimit = tableInit.TimeLimit
			instanceElement.TimeLimitValue = tableInit.TimeLimitValue
		else
			instanceElement.TimeLimit = "No Limit"
			instanceElement.Activity = "Stand Still"
		end

		if sequenceInstId == nil then
			sequenceInstId = r2:getSelectedSequInstId(uiName)
		end
		assert(sequenceInstId)

		r2.requestInsertNode(sequenceInstId, "Components", -1, "", instanceElement)

		r2.ownCreatedInstances[instanceElement.InstanceId] = true
	else
	
		local templateParams =	{
								selectElt="r2:selectActivity()", 
								openEltEditor="r2:openActivityEditor()", 
								maxMinElt="r2:maximizeMinimizeActivity()", 
								removeElt="r2:removeActivity()",
								colOver="200 120 80 120",
								colPushed="200 120 80 255"
								}

		local element = r2:newTriggerElement(uiName, tostring(i18n.get("uiR2EdActivity")), templateParams, sequenceUI, instanceElement.InstanceId)

		r2:updateActivityChatSequence(element)

		-- active chat button if a chat sequence is associated to this activity
		if instanceElement.Chat ~= "" then
			
			local activityEditor = sequenceUI:find("edit_element")
			assert(activityEditor)
			local chatButtonEditor = activityEditor:find("open_chat_sequence")
			assert(chatButtonEditor)

			chatButtonEditor.active = true
		end
	end

	return true
end


function r2:buildActivityTitle(activityUI, erase)

	local activityInst = r2:getInstanceFromId(activityUI.Env.elementId)
	assert(activityInst)

	-- part1
	local index = r2:searchElementIndex(activityInst)
	if erase==true then index = index-1 end
	local part1 = tostring(i18n.get("uiR2EdActivity")).." "..index.." : "

	-- part2
	if  not r2.activityTypeMenu[activityInst.Activity] then
		debugInfo(colorTag(255,0,0).."The activity '".. activityInst.Activity.."' is not properly registred")
	end
	
	local part2 = r2.activityTypeMenu[activityInst.Activity].." "
	if activityInst.ActivityZoneId~= "" then
		local place = r2:getInstanceFromId(tostring(activityInst.ActivityZoneId))
		if place~=nil then
			part2 = part2.. place.Name .." "
		end	
	end

	-- part3
	local part3 = ""
	if activityInst.TimeLimit == "Few Sec" then
	
		local hourNb, minNb, secNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))

		local timeLimitText = tostring(i18n.get("uiR2EdFor")) .. " "
		if hourNb ~= 0 then timeLimitText = timeLimitText .. hourNb .. tostring(i18n.get("uiR2EdShortHours")) .. " " end
		if minNb ~= 0 then timeLimitText = timeLimitText .. minNb .. tostring(i18n.get("uiR2EdShortMinutes")) .. " " end
		timeLimitText = timeLimitText .. secNb .. tostring(i18n.get("uiR2EdShortSeconds")) 
		
		part3 = timeLimitText

	elseif r2.TimeLimitsCB[activityInst.TimeLimit] ~= nil then
		part3 = string.lower(r2.TimeLimitsCB[activityInst.TimeLimit])
	end

	-- title
	local title = activityUI:find("title")
	assert(title)
	title.text= part1..part2..part3
end

function r2:getActivityName(activityInst)

	-- part1
	local index = r2:searchElementIndex(activityInst)
	if erase==true then index = index-1 end
	local part1 = tostring(i18n.get("uiR2EdActivity")).." "..index.." : "

	-- part2
	if  not r2.activityTypeMenu[activityInst.Activity] then
		debugInfo(colorTag(255,0,0).."The activity '".. activityInst.Activity.."' is not properly registred")
	end
	
	local part2 = r2.activityTypeMenu[activityInst.Activity].." "
	if activityInst.ActivityZoneId~= "" then
		local place = r2:getInstanceFromId(tostring(activityInst.ActivityZoneId))
		if place~=nil then
			part2 = part2.. place.Name .." "
		end	
	end

	-- part3
	local part3 = ""
	if activityInst.TimeLimit == "Few Sec" then
	
		local hourNb, minNb, secNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))

		local timeLimitText = tostring(i18n.get("uiR2EdFor")) .. " "
		if hourNb ~= 0 then timeLimitText = timeLimitText .. hourNb .. tostring(i18n.get("uiR2EdShortHours")) .. " " end
		if minNb ~= 0 then timeLimitText = timeLimitText .. minNb .. tostring(i18n.get("uiR2EdShortMinutes")) .. " " end
		timeLimitText = timeLimitText .. secNb .. tostring(i18n.get("uiR2EdShortSeconds")) 
		
		part3 = timeLimitText

	elseif r2.TimeLimitsCB[activityInst.TimeLimit] ~= nil then
		part3 = string.lower(r2.TimeLimitsCB[activityInst.TimeLimit])
	end

	return part1..part2..part3
end

function r2:getElementName(elementInst)

	if elementInst:isKindOf("ActivityStep") then
		return r2:getActivityName(elementInst)
	elseif elementInst:isKindOf("ChatStep") then
		return r2:getChatName(elementInst)
	elseif elementInst:isKindOf("LogicEntityAction") then
		return r2:getActionName(elementInst)
	elseif elementInst:isKindOf("LogicEntityReaction") then
		return r2:getReactionName(elementInst)
	elseif elementInst:isKindOf("ChatSequence") or elementInst:isKindOf("ActivitySequence") then
		return r2:getSequenceName(elementInst)
	end

	return ""
end

function r2:updateActivityChatSequence(elementUI, canceledChatStepId)

	if elementUI == nil then
		elementUI = r2:getSelectedEltUI("r2ed_triggers")
	end
	assert(elementUI)

	local instance = r2:getInstanceFromId(elementUI.Env.elementId)
	assert(instance)

	local chatSequence = r2:getInstanceFromId(tostring(instance.Chat))

	local activityText = elementUI:find("text_list")
	assert(activityText)

	local sep = elementUI:find("sep")
	assert(sep)

	activityText:clear()

	if chatSequence ~= nil then
		local counterTime = 0

		if chatSequence.Components.Size > 0 then
			
			local emptyText = true

			activityText:addColoredTextChild("\n"..tostring(i18n.get("uiR2EdSequenceStart")), 255, 175, 135, 255)
			
			for c = 0, chatSequence.Components.Size - 1 do
				local chat = chatSequence.Components[c]

				if chat.InstanceId ~= canceledChatStepId then
					counterTime = counterTime + tonumber(chat.Time)

					local firstLine = true
				
					local who = tostring(chat.Actions[0].Who)
					if who ~= "" then

						local facing = tostring(chat.Actions[0].Facing)
						local emote = chat.Actions[0].Emote
						local says = chat.Actions[0].Says

						local minNb, secNb = r2:calculMinSec(counterTime)
						local countInfo = "*"
						if minNb ~= 0 then
							countInfo = countInfo..tostring(minNb)..tostring(i18n.get("uiR2EdShortMinutes"))
						end
						countInfo = countInfo.." "..tostring(secNb)..tostring(i18n.get("uiR2EdShortSeconds"))..":"

						if facing ~= "" then
							facing = r2:getInstanceFromId(who).Name .. " "..tostring(i18n.get("uiR2EdFaces")).." " .. r2:getInstanceFromId(facing).Name
							if firstLine then
								activityText:addColoredTextChild(countInfo, 220, 140, 100, 255)
								firstLine = false
							end
							activityText:addTextChild(facing)
							emptyText = false
						end
						if r2.fromEmoteIdToName[emote] ~= nil then
							emote = r2:getInstanceFromId(who).Name .. " "..string.lower(tostring(i18n.get("uiR2EdEmote"))).." : " .. r2.fromEmoteIdToName[emote]
							if firstLine then
								activityText:addColoredTextChild(countInfo, 220, 140, 100, 255)
								firstLine = false
							end
							activityText:addTextChild(emote)
							emptyText = false
						end
						if r2:getInstanceFromId(says)~=nil and r2:getInstanceFromId(says).Text ~= "" then
							says = r2:getInstanceFromId(who).Name .. " "..tostring(i18n.get("uiR2EdSays")).." : " .. r2:getInstanceFromId(says).Text 
							if firstLine then
								activityText:addColoredTextChild(countInfo, 220, 140, 100, 255)
								firstLine = false
							end
							activityText:addTextChild(says)
							emptyText = false
						end
					end
				end		
			end

			if emptyText == true then
				activityText:clear()
				sep.active = false
			else
				sep.active = true

				local hourNb, minNb, secNb = r2:calculHourMinSec(counterTime)
				local totalChatTime = ""
				if hourNb ~= 0 then
					totalChatTime = tostring(hourNb)..tostring(i18n.get("uiR2EdShortHours"))
				end
				if minNb ~= 0 then
					totalChatTime = totalChatTime.." "..tostring(minNb)..tostring(i18n.get("uiR2EdShortMinutes"))
				end
				totalChatTime = totalChatTime.." "..tostring(secNb)..tostring(i18n.get("uiR2EdShortSeconds"))
				activityText:addColoredTextChild(tostring(i18n.get("uiR2EdSequenceEnd")).." (".. totalChatTime ..")\n", 255, 175, 135, 255)
			end
		end	
	else
		sep.active = false	
	end

	--update title
	r2:buildActivityTitle(elementUI, false)

	if r2:getSelectedEltInstId("r2ed_triggers") == instance.InstanceId then
		local eltEditor = r2:getSelectedSequ("r2ed_triggers"):find("edit_element")
		assert(eltEditor)
		r2:updateActivityEditor()
	end
	
	r2:updateMiniActivityView()	
end

function r2:updateActivitiesWhithThisChatSequence(chatStep, canceled)

	local chatSequenceId = chatStep.Parent.Parent.InstanceId

	local chatStepId = nil
	if canceled == true then chatStepId = chatStep.InstanceId end

	local triggersUI = getUI("ui:interface:r2ed_triggers")
	assert(triggersUI)

	local tab = triggersUI:find("sequence_tabs")
	assert(tab)

	for s = 0,tab.tabButtonNb-1 do
		local activitySequence = tab:getGroup(s)
		assert(activitySequence)

		local activityList = activitySequence:find("elements_list")
		assert(activityList)

		for a=0, activityList.childrenNb-1 do
			local activity = activityList:getChild(a)
			assert(activity)

			if activity.Env.elementId~=nil then
				local activityInst = r2:getInstanceFromId(activity.Env.elementId)
				assert(activityInst)
				if tostring(activityInst.Chat) == chatSequenceId then
					r2:updateActivityChatSequence(activity, chatStepId)
				end
			end
		end
	end
end

------------------ REMOVE ACTIVITY ------------------------------------------------------------------
function r2:removeActivity()
	r2:removeTriggerElement("r2ed_triggers", tostring(i18n.get("uiR2EdActivity")))
end

function r2:removeActivityUI(sequenceUI, elementUI)

	r2:removeElementUI(sequenceUI, "r2ed_triggers", elementUI)
	r2:closeActivitySequenceUI()

	local activityList = sequenceUI:find("elements_list")
	assert(activityList)
end

------------------ UP ACTIVITY -----------------------------------------------------------------------
function r2:upActivity()
	r2:upTriggerElement("r2ed_triggers")
end

------------------ DOWN ACTIVITY ---------------------------------------------------------------------
function r2:downActivity()
	r2:downTriggerElement("r2ed_triggers")	
end

------------------ MAXIMIZE MINIMIZE ACTIVITIES ------------------------------------------------------
function r2:maximizeMinimizeActivities()
	r2:maximizeMinimizeTriggerElements("r2ed_triggers")
end

------------------ MAXIMIZE MINIMIZE ACTIVITY ------------------------------------------------------
function r2:maximizeMinimizeActivity()
	r2:maximizeMinimizeElement("r2ed_triggers")
end

------------------ OPEN ACTIVITY EDITOR ----------------------------------------------------------------
function r2:openActivityEditor()
	r2:updateActivityEditor()
	r2:openElementEditor("r2ed_triggers", "uiR2EDActivityStepEditor")
end

function r2:updateActivityEditor()

	local uiName = "r2ed_triggers"
	local instanceActivity = r2:getSelectedEltInst(uiName)

	local activityEditor = r2:getSelectedSequ(uiName):find("edit_element")
	assert(activityEditor)

	-- activity name
	local activityName = activityEditor:find("name")
	assert(activityName)

	-- activity type
	local activityButtonText = activityEditor:find("activity"):find("text")
	assert(activityButtonText)

	-- time limit
	local comboBox = activityEditor:find("time_limit").combo_box
	assert(comboBox)

	-- chat sequence
	local chatMenuButton = activityEditor:find("chat_script"):find("menu"):find("text")
	assert(chatMenuButton)

	local chatButtonEditor = activityEditor:find("open_chat_sequence")
	assert(chatButtonEditor)

	if instanceActivity then

		local index = r2:searchElementIndex(instanceActivity)
		if index~= nil then
			activityName.text = tostring(i18n.get("uiR2EdActivity")).." "..index.." : "
		else
			activityName.text = tostring(i18n.get("uiR2EdActivity")).." : "
		end
		
		-- activity type
		local activityText = r2.activityTypeMenu[instanceActivity.Activity]
		if activityText then
			activityButtonText.text = activityText
		end
		if instanceActivity.ActivityZoneId ~= "" then
			local place = r2:getInstanceFromId(instanceActivity.ActivityZoneId)
			assert(place)

			activityButtonText.text = activityButtonText.hardtext .. " " .. place.Name
		end

		-- time limit
		local timeLimit = instanceActivity.TimeLimit
		
		local certainTime = activityEditor:find("certain_time")
		assert(certainTime)

		comboBox.Env.locked = true
		if timeLimit == "Few Sec" then
			local timeLimitValue = tonumber(instanceActivity.TimeLimitValue)

			if timeLimitValue ~= nil then
				
				local hoursNb, minNb, secNb = r2:calculHourMinSec(timeLimitValue)

				local timeLimitText = tostring(i18n.get("uiR2EdFor")) .. " "
				if hoursNb ~= 0 then timeLimitText = timeLimitText .. hoursNb .. tostring(i18n.get("uiR2EdShortHours")) .. " " end
				if minNb ~= 0 then timeLimitText = timeLimitText .. minNb .. tostring(i18n.get("uiR2EdShortMinutes")) .. " " end
				timeLimitText = timeLimitText .. secNb .. tostring(i18n.get("uiR2EdShortSeconds")) 

				certainTime.active = true
				local hoursMenu = certainTime:find("hours"):find("text")
				assert(hoursMenu)
				hoursMenu.text = tostring(hoursNb)

				local minutesMenu = certainTime:find("minutes"):find("text")
				assert(minutesMenu)
				minutesMenu.text = tostring(minNb)

				local secondsMenu = certainTime:find("seconds"):find("text")
				assert(secondsMenu)
				secondsMenu.text = tostring(secNb)

				comboBox.view_text = timeLimitText
			end
		else
			certainTime.active = false
			timeLimit = r2.TimeLimitsCB[timeLimit]
			if timeLimit~= nil then
				comboBox.selection_text = timeLimit
			end
		end
		comboBox.Env.locked = false

		-- chat sequence  TEMP TEMP TEMP TEMP
		local sequenceChat = r2:getInstanceFromId(tostring(instanceActivity.Chat))
		local repeatLabelButton = activityEditor:find("repeat")
		assert(repeatLabelButton)

		if sequenceChat ~= nil then
			--chatMenuButton.text = sequenceChat.Name
			chatMenuButton.text = r2:getSequenceName(sequenceChat)

			repeatLabelButton.active = true
			local repeatButton = repeatLabelButton:find("toggle_butt")
			assert(repeatButton)
			repeatButton.pushed = not (instanceActivity.Type == "Repeating")

			chatButtonEditor.active = true
		else
			repeatLabelButton.active = false
			chatMenuButton.text = i18n.get("uiR2EdNoElt")

			chatButtonEditor.active = false
		end
		-- TEMP TEMP TEMP

	else

		local name = tostring(i18n.get("uiR2EdActivity")).." : "
		activityName.text = name
		
		activityButtonText.text = i18n.get("uiR2EdStandStill")
		comboBox.selection_text = i18n.get("uiR2EdNoTimeLimit")
		chatMenuButton.text = i18n.get("uiR2EdNoElt")

		chatButtonEditor.active = false
	end
end

------------------ REPEAT ACTIVITY SEQUENCE -------------------------------------------------------------
function r2:repeatActivitySequence()
	r2.requestNewAction(i18n.get("uiR2EDRepeatActivitySequenceAction"))

	local sequenceInstId = r2:getSelectedSequInstId("r2ed_triggers")
	assert(sequenceInstId)

	local sequenceType = not getUICaller().pushed
	if sequenceType==false then sequenceType=0 else sequenceType=1 end

	r2.requestSetNode(sequenceInstId, "Repeating", sequenceType) 
end

------------------ CLOSE ACTIVITY EDITOR ----------------------------------------------------------------
function r2:closeChatSequencesUI()

	local window = getUI("ui:interface:r2ed_chat_sequence")
	assert(window)
	window.active = false

	window = getUI("ui:interface:r2ed_edit_chat_sequence")
	assert(window)
	window.active = false
end

------------------ OPEN ACTIVITY MENU -------------------------------------------------------------------
function r2:openActivityMenu()

	local menuName = "ui:interface:r2ed_triggers_menu"
	local activityMenu = getUI(menuName)
	local activityMenu = activityMenu:getRootMenu()
	assert(activityMenu)
	activityMenu:reset()

	-- Inactive
--	activityMenu:addLine(i18n.get("uiR2EdInactive"), "lua", "r2:setActivity('Inactive')", "Inactive")

	-- Stand still
	activityMenu:addLine(i18n.get("uiR2EdStandStill"), "lua", "r2:setActivity('Stand Still')", "Stand Still")

	-- Follow route
	activityMenu:addLine(i18n.get("uiR2EdFollowRoad"), "", "", "Follow Route")
	local menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_road.tga", size="14" })
	activityMenu:setUserGroupLeft(1, menuButton)
	activityMenu:addSubMenu(1)
	local roadsMenu = activityMenu:getSubMenu(1)
	local roadsTable = r2.Scenario:getAllInstancesByType("Road")
	for key, road in pairs(roadsTable) do
		roadsMenu:addLine(road.Name, "lua", "r2:setActivity('Follow Route', '".. road.InstanceId .."')", road.InstanceId)
	end
	if table.getn(roadsTable) == 0 then
		roadsMenu:addLine(i18n.get("uiR2EdNoSelelection"), "lua", "r2:setActivity()", "")
	end

	-- Patrol
	activityMenu:addLine(i18n.get("uiR2EdPatrol"), "", "", "Patrol")
	menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_road.tga", size="14"})
	activityMenu:setUserGroupLeft(2, menuButton)
	activityMenu:addSubMenu(2)
	roadsMenu = activityMenu:getSubMenu(2)
	for key, road in pairs(roadsTable) do
		roadsMenu:addLine(road.Name, "lua", "r2:setActivity('Patrol', '".. road.InstanceId .."')", road.InstanceId)
	end
	if table.getn(roadsTable) == 0 then
		roadsMenu:addLine(i18n.get("uiR2EdNoSelelection"), "lua", "r2:setActivity()", "")
	end

	-- Repeat Road
	activityMenu:addLine(i18n.get("uiR2EdRepeatRoad"), "", "", "Repeat Road")
	menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_road.tga", size="14"})
	activityMenu:setUserGroupLeft(3, menuButton)
	activityMenu:addSubMenu(3)
	roadsMenu = activityMenu:getSubMenu(3)
	for key, road in pairs(roadsTable) do
		roadsMenu:addLine(road.Name, "lua", "r2:setActivity('Repeat Road', '".. road.InstanceId .."')", road.InstanceId)
	end
	if table.getn(roadsTable) == 0 then
		roadsMenu:addLine(i18n.get("uiR2EdNoSelelection"), "lua", "r2:setActivity()", "")
	end

	-- Wander
	activityMenu:addLine(i18n.get("uiR2EdWander"), "", "", "Wander")
	menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_region.tga", size="14"})
	activityMenu:setUserGroupLeft(4, menuButton)
	activityMenu:addSubMenu(4)
	local regionsMenu = activityMenu:getSubMenu(4)
	local regionsTable = r2.Scenario:getAllInstancesByType("Region")
	for key, region in pairs(regionsTable) do
		regionsMenu:addLine(region.Name, "lua", "r2:setActivity('Wander', '".. region.InstanceId .."')", region.InstanceId)
	end
	if table.getn(regionsTable) == 0 then
		regionsMenu:addLine(i18n.get("uiR2EdNoSelelection"), "lua", "r2:setActivity()", "")
	end

	-- Deploy
--	activityMenu:addLine(i18n.get("uiR2EdDeploy"), "", "", "Deploy")
--	menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_region.tga", size="14"})
--	activityMenu:setUserGroupLeft(6, menuButton)
--	activityMenu:addSubMenu(6)
--	local regionsMenu = activityMenu:getSubMenu(6)
--	local regionsTable = r2.Scenario:getAllInstancesByType("Region")
--	for key, region in pairs(regionsTable) do
--		regionsMenu:addLine(region.Name, "lua", "r2:setActivity('Deploy', '".. region.InstanceId .."')", region.InstanceId)
--	end
--	if table.getn(regionsTable) == 0 then
--		regionsMenu:addLine(i18n.get("uiR2EdNoSelelection"), "lua", "r2:setActivity()", "")
--	end

	r2:openTriggersMenu(getUICaller())
end

function r2:setActivity(activityType, placeId)



	local activityInstId = r2:getSelectedEltInstId("r2ed_triggers")
	assert(activityInstId)

	if activityType == nil then
		return
	elseif placeId == nil then
		r2.requestSetNode(activityInstId, "Activity", activityType)
		r2.requestSetNode(activityInstId, "ActivityZoneId", r2.RefId(""))
	else
		r2.requestSetNode(activityInstId, "Activity", activityType)
		r2.requestSetNode(activityInstId, "ActivityZoneId", r2.RefId(placeId))
	end
end

------------------ SET TIME LIMIT --------------------------------------------------------------------
function r2:setTimeLimit(timeLimit)
	
	if timeLimit == nil then
		timeLimit = getUICaller().selection_text 
		if getUICaller().Env.locked then return end
	end

	local uiName = "r2ed_triggers"
	local activity = r2:getSelectedEltUI(uiName)
	if activity == nil then return end

	local viewText
	local hasTimeLimitValue = false

	if timeLimit == tostring(i18n.get("uiR2EdForCertainTime")) then
		hasTimeLimitValue = true
		viewText = tostring(i18n.get("uiR2EdFor")) ..  " 20" .. tostring(i18n.get("uiR2EdShortSeconds")) 
		
		local eltEditor = r2:getSelectedSequ(uiName):find("edit_element")
		assert(eltEditor)
		local comboTime = eltEditor:find("time_limit"):find("combo_box") 
		assert(comboTime)																				
		comboTime.view_text = viewText
	else
		viewText = timeLimit
	end

	timeLimit = r2.TimeLimitsProp[timeLimit]

	local activityInstId = r2:getSelectedEltInstId(uiName)
	r2.requestSetNode(activityInstId, "TimeLimit", timeLimit)
	
	if hasTimeLimitValue then
		r2.requestSetNode(activityInstId, "TimeLimitValue", tostring(20))
	else	
		r2.requestSetNode(activityInstId, "TimeLimitValue", "")
	end
end

function r2:calculHourMinSec(totalSecNb)

	local minSecNb, hourNb = totalSecNb, 0
	while minSecNb > 3599 do
		hourNb = hourNb+1
		minSecNb = minSecNb - 3600
	end

	local minNb, secNb = 0, minSecNb
	while secNb > 59 do
		minNb = minNb+1
		secNb = secNb - 60
	end

	return hourNb, minNb, secNb
end

function r2:calculMinSec(totalSecNb)

	local minNb, secNb = 0, totalSecNb
	while secNb > 59 do
		minNb = minNb+1
		secNb = secNb - 60
	end

	return minNb, secNb
end

function r2:activityForHours(hourNb)

	local activityInst = r2:getSelectedEltInst("r2ed_triggers")
	assert(activityInst)

	local lastHourNb, minNb, secNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
	
	r2:setLimitTimeValue(hourNb, minNb, secNb)
end

function r2:activityForMinutes(minNb)

	local activityInst = r2:getSelectedEltInst("r2ed_triggers")
	assert(activityInst)

	local hoursNb, lastMinNb, secNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
	
	r2:setLimitTimeValue(hoursNb, minNb, secNb)
end

function r2:activityForSeconds(secNb)

	local activityInst = r2:getSelectedEltInst("r2ed_triggers")
	assert(activityInst)

	local hoursNb, minNb, lastSecNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
	
	r2:setLimitTimeValue(hoursNb, minNb, secNb)
end

------------------ SET LIMIT TIME VALUE -------------------------------------------------------------------
function r2:setLimitTimeValue(hourNb, minNb, secNb)

	local totalSec = tostring(hourNb*3600 + minNb*60 + secNb)
	r2.requestSetNode(r2:getSelectedEltInstId("r2ed_triggers"), "TimeLimitValue", totalSec)
end


------------------ OPEN SELECT CHAT MENU -------------------------------------------------------------------
function r2:openSelectChatMenu()

	-- triggers menu initialization
	local chatMenu = getUI("ui:interface:r2ed_triggers_menu")
	assert(chatMenu)

	local chatMenu = chatMenu:getRootMenu()
	assert(chatMenu)

	chatMenu:reset()

	-- first line "None"
	chatMenu:addLine(i18n.get("uiR2EdNoElt"), "lua", "r2:selectChatSequence('None')", "None")

	-- second line "More"
	chatMenu:addLine(i18n.get("uiR2EdMore"), "lua", "r2:openChatSequences()", "More")
	
	local entityInst = r2:getSelectedInstance()
	assert(entityInst)

	-- list of avoidable chat sequences
	local chatSequences = entityInst:getBehavior().ChatSequences
	for i=0, chatSequences.Size-1 do
		local chatS = chatSequences[i]
		assert(chatS)
		--chatMenu:addLine(chatS.Name, "lua", "r2:selectChatSequence('" .. chatS.InstanceId .. "')", chatS.InstanceId)
		chatMenu:addLine(r2:getSequenceName(chatS), "lua", "r2:selectChatSequence('" .. chatS.InstanceId .. "')", chatS.InstanceId)
	end

	r2:openTriggersMenu(getUICaller())
end

function r2:openChatSequences()
	local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
	assert(chatSequencesUI)

	chatSequencesUI.active = true
	chatSequencesUI:updateCoords()

	if chatSequencesUI.Env.openFirst == nil then
		chatSequencesUI:center()
		chatSequencesUI.Env.openFirst = true
	end
end

-----------------------------------------------------------------------------------------------------------
-- the commun "logic entity" menu is open
function r2:openTriggersMenu(caller)

	local menuName = "ui:interface:r2ed_triggers_menu"
	launchContextMenuInGame(menuName)
	local menu = getUI(menuName)

	menu:updateCoords()	
	menu.y = caller.y_real - (menu.h + 2)
	menu.x = caller.x_real
	menu:setMinW(caller.w)
	menu:updateCoords()	
end

------------------ SELECT CHAT SEQUENCE  -------------------------------------------------------------
function r2:selectChatSequence(choice, activityId)

	local chatSequenceUI = getUI("ui:interface:r2ed_chat_sequence")
	assert(chatSequenceUI)

	local uiName = "r2ed_triggers"

	if activityId == nil then 
		activityId = r2:getSelectedEltInstId(uiName)
	end

	local activityUI = r2:getSelectedEltUI(uiName)
	assert(activityUI)

	if choice == "None" then
		r2.requestSetNode(activityId, "Chat", r2.RefId(""))
		local sep = activityUI:find("sep")
		assert(sep)
		sep.active = false
	elseif choice == "More" then
		r2:openChatSequences()
	elseif choice then
		local chatSId = choice
		local activityInstId = r2:getSelectedEltInstId(uiName)
		r2.requestSetNode(activityId, "Chat", r2.RefId(chatSId))
		r2.requestSetNode(activityInstId, "Type", "Non Repeating")
	else
		debugInfo("r2:selectChatSequence : unknown menu selection")
	end
end

------------------ REPEAT OR NOT CHAT SEQUENCE  ------------------------------------------------------
function r2:repeatChatSequence()

	local activityInstId = r2:getSelectedEltInstId("r2ed_triggers")  
	assert(activityInstId)											 
	
	local sequenceType = "Repeating"
	if getUICaller().pushed then sequenceType = "Non Repeating" end

	r2.requestSetNode(activityInstId, "Type", sequenceType)					
end

------------------ NEW CHAT SEQUENCE  -------------------------------------------------------------
function r2:newChatsSequence(firstRequest, instanceSequence, reset)

	local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
	assert(chatSequencesUI)

	local tab = chatSequencesUI:find("sequence_tabs")
	assert(tab)

	-- limit sequences number
	if firstRequest and tab.tabButtonNb == 7 then return -1 end

	if firstRequest == true then
		instanceSequence = r2.newComponent("ChatSequence")

		--local name = tostring(i18n.get("uiR2EdChat"))..tab.tabButtonNb+1
		--instanceSequence.Name = name
		
		local npcGroup = r2:getSelectedInstance()
		assert(npcGroup)
		
		r2.requestInsertNode(npcGroup:getBehavior().InstanceId, "ChatSequences", -1, "", instanceSequence)

		r2.ownCreatedInstances[instanceSequence.InstanceId] = true
	else

		local templateParams = {
									newElt="r2:newChat(true)",
									newEltText=tostring(i18n.get("uiR2EdNewChat")),
									eltOrderText=tostring(i18n.get("uiR2EdChatOrder")),
									upElt="r2:upChat()",
									downElt="r2:downChat()",
									maxMinElts="r2:maximizeMinimizeChats()",
									downUpColor="120 150 140 255",
									colPushed = "0 255 0 255",
									paramsL= "r2:selectSequenceTab('r2ed_chat_sequence', "..tostring(tab.tabButtonNb)..")"
							   }

		if reset == true then
			r2.ownCreatedInstances[instanceSequence.InstanceId] = true
		end

		local editorEltTemplate = "template_edit_chat"
		local sequence = r2:newElementsSequence("r2ed_chat_sequence", templateParams, editorEltTemplate, 
			instanceSequence, tostring(i18n.get("uiR2EdSequChat")))

		local chats = instanceSequence.Components
		for c = 0, chats.Size - 1 do
			r2:newChat(false, chats[c])	
		end

		local eltEditor = sequence:find("edit_element")
		assert(eltEditor)

		local editBox = eltEditor:find("edit_box_group")
		assert(editBox)

		local scroll = sequence:find("edit_box_scroll_ed")
		assert(scroll)

		scroll:setTarget(editBox.id)
	end

	return instanceSequence.InstanceId
end

------------------- REMOVE CHATS SEQUENCE ---------------------------------------------------------
function r2:removeChatsSequence()

	-- remove sequence
	r2:removeElementsSequence("r2ed_chat_sequence", "ChatSequences", tostring(i18n.get("uiR2EdSequChat")))
end

function r2:removeChatsSequenceUI(sequIndex) 

	r2:closeChatEditor()

	-- remove sequence UI
	r2:removeElementsSequenceUI(sequIndex, "r2ed_chat_sequence", "ChatSequences", tostring(i18n.get("uiR2EdSequChat")))
end

------------------- SELECT CHAT -------------------------------------------------------------------
function r2:selectChat()
	r2:selectTriggerElement(nil, "r2ed_chat_sequence")

	if getUICaller().pushed == true then
		r2:updateChatEditor() 
	end
end

------------------- OPEN CHAT EDITOR --------------------------------------------------------------
function r2:openChatEditor()
	r2:updateChatEditor()
	r2:openElementEditor("r2ed_chat_sequence", "uiR2EDChatStepEditor")
end

function r2:updateChatEditor()

	local instanceChat = r2:getSelectedEltInst("r2ed_chat_sequence")
	
	local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
	assert(chatEditor)

	-- chat name
	local chatName = chatEditor:find("name")
	assert(chatName)

	-- time
	local minutesText = chatEditor:find("minutes"):find("text")
	assert(minutesText)

	local secondsText = chatEditor:find("seconds"):find("text")
	assert(secondsText)

	-- update NPC name lists
	local whoMenuText = chatEditor:find("whoMenu"):find("text")
	assert(whoMenuText)

	local toWhoMenuText = chatEditor:find("toWhoMenu"):find("text")
	assert(toWhoMenuText)

	local editBox = chatEditor:find("says"):find("edit_box_group")
	assert(editBox)

	local emoteButtonText = chatEditor:find("emote"):find("menu"):find("text")
	assert(emoteButtonText)

	if instanceChat then

		local index = r2:searchElementIndex(instanceChat)
		if index~= nil then
			chatName.text = tostring(i18n.get("uiR2EdChat")).." "..index.." : "
		else
			chatName.text = tostring(i18n.get("uiR2EdChat")).." : "
		end

		-- after value
		local time = instanceChat.Time
		local minNb, secNb = r2:calculMinSec(time)

		minutesText.text = tostring(minNb)
		secondsText.text = tostring(secNb)
			
		-- who
		local whoInst = r2:getInstanceFromId(tostring(instanceChat.Actions[0].Who))
		whoMenuText.text = whoInst.Name
		
		-- says what
		local textID = instanceChat.Actions[0].Says
		if textID ~= "" then
			editBox.input_string = r2:getInstanceFromId(textID).Text
		else
			editBox.input_string = ""
		end

		-- to who
		local toWhoInst = r2:getInstanceFromId(tostring(instanceChat.Actions[0].Facing))
		if toWhoInst then
			toWhoMenuText.text = toWhoInst.Name
		else
			toWhoMenuText.text = tostring(i18n.get("uiR2EdNobody"))
		end

		-- emote
		local emoteName = r2.fromEmoteIdToName[instanceChat.Actions[0].Emote]
		if emoteName then
			emoteButtonText.text = emoteName
		else
			emoteButtonText.text = tostring(i18n.get("uiR2EdNoElt"))
		end

	else

		local name = tostring(i18n.get("uiR2EdChat")).." : "
		chatName.text = name

		minutesText.text = tostring(0)
		secondsText.text = tostring(0)

		whoMenuText.text = ""

		editBox.input_string = ""

		toWhoMenuText.text = tostring(i18n.get("uiR2EdNobody"))

		emoteButtonText.text = tostring(i18n.get("uiR2EdNoElt"))
	end
end

------------------ OPEN CHAT SEQUENCE EDITOR  --------------------------------------------------
function r2:openChatSequenceEditor()

	local editor = getUI("ui:interface:r2ed_edit_chat_sequence")
	assert(editor)

	local chatsUI = getUI("ui:interface:r2ed_chat_sequence")
	assert(chatsUI)

	editor.x = chatsUI.x
	editor.y = chatsUI.y
	editor.active = true
end

------------------- MAX / MIN CHAT ----------------------------------------------------------------
function r2:maximizeMinimizeChat()
	r2:maximizeMinimizeElement("r2ed_chat_sequence")
end

-------------------- NEW CHAT ---------------------------------------------------------------------
function r2:newChat(firstRequest, instanceElement, sequenceUI)
	
	local uiName = "r2ed_chat_sequence"
	
	if firstRequest == true then
		instanceElement = r2.newComponent("ChatStep")

		instanceElement.Time = 3

		local who
		local selectedInst = r2:getSelectedInstance()
		assert(selectedInst)

		if selectedInst:isGrouped() then
			who = r2:getLeader(selectedInst)
		else
			who = selectedInst
		end
		local chatAction = r2.newComponent("ChatAction")
		chatAction.Who = who.InstanceId
		table.insert(instanceElement.Actions, chatAction)

		local sequenceInstId = r2:getSelectedSequInstId(uiName)

		r2.requestInsertNode(sequenceInstId, "Components", -1, "", instanceElement)

		r2.ownCreatedInstances[instanceElement.InstanceId] = true
	else

		local templateParams =	{
									selectElt="r2:selectChat()", 
									openEltEditor="r2:openChatEditor()", 
									maxMinElt="r2:maximizeMinimizeChat()", 
									removeElt="r2:removeChat()",
									colOver="120 150 140 100",
									colPushed="120 150 140 255"
								}

		if sequenceUI == nil then
			sequenceUI = r2:getSelectedSequ(uiName)
		end
		local element = r2:newTriggerElement(uiName, tostring(i18n.get("uiR2EdChat")), templateParams, sequenceUI, instanceElement.InstanceId)
		
		r2:updateChatText(element)
	end
end

function r2:searchElementIndex(eltInst)

	local components = eltInst.Parent
	local index 
	for i=0, components.Size-1 do
		local elt = components[i]
		if elt.InstanceId == eltInst.InstanceId then
			return (i+1)
		end
	end
end

function r2:buildChatTitle(chatUI, erase)

	local chatInst = r2:getInstanceFromId(chatUI.Env.elementId)
	assert(chatInst)

	-- part1
	local index = r2:searchElementIndex(chatInst)
	if erase==true then index = index-1 end
	local part1 = tostring(i18n.get("uiR2EdChat")).." "..index.." : "

	-- part2
	local minNb, secNb = r2:calculMinSec(chatInst.Time)
	local time = ""
	if minNb ~= 0 then
		time = tostring(minNb)..tostring(i18n.get("uiR2EdShortMinutes"))
	end
	time = time.." " ..tostring(secNb)..tostring(i18n.get("uiR2EdShortSeconds"))
	local part2 = "(" ..tostring(i18n.get("uiR2EdAfter")).." ".. time..") "

	-- part3
	local part3 = ""
	local action = chatInst.Actions[0]
	local who = action.Who
	if who ~= "" then
		who = r2:getInstanceFromId(who)
		assert(who)
		part3 = who.Name .. " " ..tostring(i18n.get("uiR2EdSays")).. " " 

		local says = action.Says
		if says ~= "" then
			says = r2:getInstanceFromId(says).Text 
			says = string.substr(says, 0, 4)
		end

		part3 = part3 .. says .. "..."
	end

	-- title
	local title = chatUI:find("title")
	assert(title)
	title.text= part1..part2..part3
end

function r2:getChatName(chatInst)

	-- part1
	local index = r2:searchElementIndex(chatInst)
	if erase==true then index = index-1 end
	local part1 = tostring(i18n.get("uiR2EdChat")).." "..index.." : "

	-- part2
	local minNb, secNb = r2:calculMinSec(chatInst.Time)
	local time = ""
	if minNb ~= 0 then
		time = tostring(minNb)..tostring(i18n.get("uiR2EdShortMinutes"))
	end
	time = time.." " ..tostring(secNb)..tostring(i18n.get("uiR2EdShortSeconds"))
	local part2 = "(" ..tostring(i18n.get("uiR2EdAfter")).." ".. time..") "

	-- part3
	local part3 = ""
	local action = chatInst.Actions[0]
	local who = action.Who
	if who ~= "" then
		who = r2:getInstanceFromId(who)
		assert(who)
		part3 = who.Name .. " " ..tostring(i18n.get("uiR2EdSays")).. " " 

		local says = action.Says
		if says ~= "" then
			says = r2:getInstanceFromId(says).Text 
			says = string.sub(says, 1, 4)
		end

		part3 = part3 .. says .. "..."
	end

	return part1..part2..part3

end

function r2:updateChatText(elementUI)

	if elementUI == nil then
		elementUI = r2:getSelectedEltUI("r2ed_chat_sequence")
	end
	assert(elementUI)

	local instance = r2:getInstanceFromId(elementUI.Env.elementId)
	assert(instance)

	local chatText = elementUI:find("text_list")
	assert(chatText)

	chatText:clear()

	local who = tostring(instance.Actions[0].Who)
	if who ~= "" then
		
		local text = ""
		local textEmpty = true

		local facing = tostring(instance.Actions[0].Facing)
		local emote = instance.Actions[0].Emote
		local says = instance.Actions[0].Says

		if facing ~= "" then
			text = "\n"..r2:getInstanceFromId(who).Name .." "..tostring(i18n.get("uiR2EdFaces")).." ".. r2:getInstanceFromId(facing).Name
			textEmpty = false
		end
		if r2.fromEmoteIdToName[emote] ~= nil then
			text = text .. "\n" .. r2:getInstanceFromId(who).Name .. " "..string.lower(tostring(i18n.get("uiR2EdEmote"))).." : " .. r2.fromEmoteIdToName[emote]
			textEmpty = false
		end
		if r2:getInstanceFromId(says)~=nil and r2:getInstanceFromId(says).Text ~= "" then
			text = text.."\n"..r2:getInstanceFromId(who).Name .. " "..tostring(i18n.get("uiR2EdSays")).." : " .. r2:getInstanceFromId(says).Text 
			textEmpty = false
		end
		text = text.."\n"

		chatText:addTextChild(text)

		local sep = elementUI:find("sep")
		assert(sep)
		if textEmpty == false then
			sep.active = true
		else
			chatText:clear()
			sep.active = false
		end
	end

	r2:buildChatTitle(elementUI, false)

	local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
	assert(chatEditor)

	if instance.InstanceId == r2:getSelectedEltInstId("r2ed_chat_sequence") then
		r2:updateChatEditor()
	end

	r2:updateActivitiesWhithThisChatSequence(instance, false)
end


-------------------- UP CHAT ----------------------------------------------------------------------
function r2:upChat()
	r2:upTriggerElement("r2ed_chat_sequence")
end

-------------------- DOWN CHAT --------------------------------------------------------------------
function r2:downChat()
	r2:downTriggerElement("r2ed_chat_sequence")	
end

-------------------- MAX / MIN CHATS --------------------------------------------------------------
function r2:maximizeMinimizeChats()
	r2:maximizeMinimizeTriggerElements("r2ed_chat_sequence")
end

-------------------- REMOVE CHAT ------------------------------------------------------------------
function r2:removeChat()
	r2:removeTriggerElement("r2ed_chat_sequence", tostring(i18n.get("uiR2EdChat")))
end

-------------------- CHAT TIME --------------------------------------------------------------------
function r2:setTime(minNb, secNb)

	local chatSequenceId = r2:getSelectedEltInstId("r2ed_chat_sequence")
	
	r2.requestSetNode(chatSequenceId, "Time", minNb*60+secNb)
end

-------------------- INIT TIME MENU -----------------------------------------------------------------
function r2:initTimeMenu(timeFunction, isHours)

	local timeMenu = getUI("ui:interface:r2ed_triggers_menu")
	assert(timeMenu)

	local timeMenu = timeMenu:getRootMenu()
	assert(timeMenu)

	timeMenu:reset()

	for i=0,9 do
		timeMenu:addLine(tostring(i), "lua", timeFunction .. "(" .. tostring(i) .. ")", tostring(i))
	end

	if isHours == true then
		timeMenu:addLine(tostring(10), "lua", timeFunction .. "(" .. tostring(10) .. ")", tostring(10))
	else

		local lineNb = 9
		for i=10, 50, 10 do
			local lineStr = tostring(i).."/"..tostring(i+9)
			timeMenu:addLine(lineStr, "", "", tostring(i))
			lineNb = lineNb+1

			timeMenu:addSubMenu(lineNb)
			local subMenu = timeMenu:getSubMenu(lineNb)

			for s=0,9 do
				lineStr = tostring(i+s) 
				subMenu:addLine(lineStr, "lua", timeFunction .. "(" .. tostring(i+s) .. ")", lineStr)
			end
		end
	end

	r2:openTriggersMenu(getUICaller())
end

-------------------- CHAT SECONDS -----------------------------------------------------------------
function r2:chatAfterSeconds(secNb)
	
	local chatStepInst = r2:getSelectedEltInst("r2ed_chat_sequence")

	local lastTime = chatStepInst.Time

	local minNb = 0
	while  lastTime > 59 do
		lastTime = lastTime - 60
		minNb = minNb + 1
	end

	r2:setTime(minNb, secNb)

	-- recover "says what" (equiv change focus)
	local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
	assert(chatEditor)

	local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
	if chatStepInst.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
		r2:setSaysWhat(saysWhat)
	end
end

-------------------- CHAT MINUTES -----------------------------------------------------------------
function r2:chatAfterMinutes(minNb)
	
	local chatStepInst = r2:getSelectedEltInst("r2ed_chat_sequence")

	local lastTime = chatStepInst.Time

	local secNb = lastTime
	while  secNb > 59 do
		secNb = secNb - 60
	end

	r2:setTime(minNb, secNb)

	-- recover "says what" (equiv change focus)
	local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
	assert(chatEditor)

	local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
	if chatStepInst.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
		r2:setSaysWhat(saysWhat)
	end
end

-------------------- WHO --------------------------------------------------------------------------
function r2:setWho(who, chatStepInst)

	if chatStepInst == nil then
		chatStepInst = r2:getSelectedEltInst("r2ed_chat_sequence")
	end
	assert(chatStepInst)
	
	r2.requestSetNode(chatStepInst.Actions[0].InstanceId, "Who", r2.RefId(who))
	
	if who == chatStepInst.Actions[0].Facing then
		r2:setToWho(tostring(i18n.get("uiR2EdNobody")))
	end

	-- recover "says what" (equiv change focus)
	local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
	assert(chatEditor)

	local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
	if chatStepInst.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
		r2:setSaysWhat(saysWhat)
	end
end

function r2:openWhoMenu(whoFunction, towho)

	local menuName = "ui:interface:r2ed_triggers_menu"
	
	local whoMenu = getUI(menuName)
	local whoMenu = whoMenu:getRootMenu()
	assert(whoMenu)

	whoMenu:reset()

	local npcTable = r2.Scenario:getAllInstancesByType("Npc")

	if towho == true then
		whoMenu:addLine(i18n.get("uiR2EdNobody"), "lua", whoFunction.."('" ..tostring(i18n.get("uiR2EdNobody")).. "')", "Nobody")
	end

	for key, npc in npcTable do
		local addLine = true
		if not npc:isBotObject() and not npc:isPlant() and not r2.isCreature(npc.InstanceId) then
			if towho == true then
				local chatStepInst= r2:getSelectedEltInst("r2ed_chat_sequence")
				assert(chatStepInst)

				local whoId = chatStepInst.Actions[0].Who
				if whoId~="" and whoId == npc.InstanceId then
					addLine = false	
				end
			end
			if addLine then
				whoMenu:addLine(npc.Name, "lua", whoFunction.."('" ..npc.InstanceId.. "')", npc.InstanceId)	
			end
		end
	end
	
	r2:openTriggersMenu(getUICaller())
end

-------------------- SAYS WHAT --------------------------------------------------------------------
function r2:setSaysWhat(what)

	if what == nil then
		what = getUICaller().input_string
	end

	local says = what

	local chatStep = r2:getSelectedEltInst("r2ed_chat_sequence")
	if chatStep ~= nil then
		if what ~= "" then
			what=r2.registerText(what).InstanceId
		end
		r2.requestSetNode(chatStep.Actions[0].InstanceId, "Says", what)

		local chatStepUI = r2:getSelectedEltUI("r2ed_chat_sequence")
		assert(chatStepUI)
	end
end

-------------------- CLOSE CHAT EDITOR ------------------------------------------------------------
function r2:closeChatEditor(chatEditor)

	if chatEditor == nil then
		chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
	end
	assert(chatEditor)

	local editSaysWhat = chatEditor:find("says"):find("edit_box_group")
	assert(editSaysWhat)

	if r2.callSetSaysWhat == true then
		r2:setSaysWhat(editSaysWhat.input_string)
	end
end

-------------------- TO WHO -----------------------------------------------------------------------
function r2:setToWho(toWho)
	
	local chatSequence = r2:getSelectedEltInst("r2ed_chat_sequence")
	assert(chatSequence)

	local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
	assert(chatEditor)

	-- recover "says what" (equiv change focus)
	local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
	if chatSequence.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
		r2:setSaysWhat(saysWhat)
	end

	if toWho == tostring(i18n.get("uiR2EdNobody")) then toWho="" end

	r2.requestSetNode(chatSequence.Actions[0].InstanceId, "Facing", r2.RefId(toWho))
end

-------------------- EMOTE ------------------------------------------------------------------------
function r2:openEmoteMenu()

	local menuName = "ui:interface:r2ed_triggers_menu"
	
	local emoteMenu = getUI(menuName)
	local emoteMenu = emoteMenu:getRootMenu()
	assert(emoteMenu)

	emoteMenu:reset()
	initEmotesMenu(menuName, "r2:setEmote")
	r2:openTriggersMenu(getUICaller())
end

function r2:setEmote(emoteId)
	
	local chatSequence = r2:getSelectedEltInst("r2ed_chat_sequence")
	assert(chatSequence)

	r2.requestSetNode(chatSequence.Actions[0].InstanceId, "Emote", emoteId)

	-- recover "says what" (equiv change focus)
	local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
	assert(chatEditor)

	local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
	if chatSequence.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
		r2:setSaysWhat(saysWhat)
	end
end

------------------ SELECT CHAT SEQUENCE ---------------------------------------------------------
function r2:selectChatsSequence(index)
	r2:selectElementsSequence("r2ed_chat_sequence", index)
	r2:updateMiniActivityView()
end

---------------------------------------------------------------------------------------------------
------------------------------  FACTORISATION  ----------------------------------------------------
---------------------------------------------------------------------------------------------------

------------------------------  Remove element  ---------------------------------------------------
function r2:removeTriggerElement(uiName, elementName)

	local wndUI = getUI("ui:interface:"..uiName)
	assert(wndUI)

	local tab = wndUI:find("sequence_tabs")
	assert(tab)

	local sequenceUI = wndUI:find(tab.associatedGroupSelection)
	assert(sequenceUI)

	r2:removeElement(sequenceUI, uiName, elementName)
end

-----------------------------------------------------------------------------------------------------
function r2:removeElement(sequence, uiName, elementName, removedElement)

	local listElements = sequence:find("elements_list")
	assert(listElements)

	local toErasedInstId
	if removedElement == nil then
		toErasedInstId = r2:getSelectedEltInstId(uiName)
	else
		toErasedInstId = removedElement.Env.elementId
	end
	assert(toErasedInstId)

	-- request erase node
	if toErasedInstId ~= nil and r2:getInstanceFromId(toErasedInstId) ~= nil then
		r2.requestEraseNode(toErasedInstId, "", -1)
	end
end

function r2:removeElementUI(sequence, uiName, removedElement)

	local listElements = sequence:find("elements_list")
	assert(listElements)

	-- update follow elements number
	local removedIndex = listElements:getElementIndex(removedElement)
	for i = removedIndex+1, (listElements.childrenNb-1) do
		local element = listElements:getChild(i)
		assert(element)

		if not element.Env.isEditor then
			r2:buildElementTitle(uiName, element, true)
		end
	end
	
	-- delete element and update coordinates of elements list
	if removedElement == r2:getSelectedEltUI(uiName) then
		r2:setSelectedEltUIId(uiName, nil)

		-- inactive element editor
		local eltEditor = listElements:find("edit_element")
		assert(eltEditor)
		eltEditor.active = false

		-- disactive up and down element buttons
		local upElement = sequence:find("up_element")
		assert(upElement)
		local downElement = sequence:find("down_element")
		assert(downElement)
		local elementOrder = sequence:find("element_order")
		assert(elementOrder)

		upElement.active = false
		downElement.active = false
		elementOrder.active = false
	end
	listElements.Env.elementsNb = listElements.Env.elementsNb - 1

	listElements:delChild(removedElement)
	listElements.parent:invalidateCoords()

	-- if any activity in list, disactive global minimize / maximize button
	if listElements.childrenNb == 1 then
		local minElts = sequence:find("minimize_elements")
		assert(minElts)

		local maxElts = sequence:find("maximize_elements")
		assert(maxElts)

		minElts.active = false
		maxElts.active = false
	end
end

------------------------------  Max / Min elements  -----------------------------------------------
function r2:maximizeMinimizeTriggerElements(uiName)

	local sequence = r2:getSelectedSequ(uiName)
	assert(sequence)

	r2:maximizeMinimizeElements(sequence, uiName)
end

------------------------------  Max / Min elements  -----------------------------------------------
function r2:maximizeMinimizeElements(sequence, uiName)

	local elements = sequence:find("elements_list")
	assert(elements)

	if elements.Env.minimize == nil then
		elements.Env.minimize = true
	end

	elements.Env.minimize = not elements.Env.minimize

	for i = 0, elements.childrenNb-1 do
		local element = elements:getChild(i)
		assert(element)

		if element.Env.isEditor ~= true then
			r2:maximizeMinimizeElement(uiName, element, elements.Env.minimize)
		end
	end

	local minElts = sequence:find("minimize_elements")
	assert(minElts)
	local maxElts = sequence:find("maximize_elements")
	assert(maxElts)

	if elements.Env.minimize == true then
		minElts.active = false
		maxElts.active = true
	else
		minElts.active = true
		maxElts.active = false
	end
end

------------------------------  Max / Min element  ------------------------------------------------
function r2:maximizeMinimizeElement(uiName, element, allMinimize)

	if element == nil then
		element = getUICaller().parent.parent.parent.parent.parent.parent
	end
	assert(element)

	local eltText = element:find("element_text")
	assert(eltText)

	local allMin, allMax = true, true
	if allMinimize ~= nil then
		allMin = allMinimize 
		allMax = not allMin
	end

	local maxButton = element:find("maximize_element")
	assert(maxButton)
	local minButton = element:find("minimize_element")
	assert(minButton)

	-- maximize
	if allMax and eltText.active==false then
		eltText.active = true
		maxButton.active = false
		minButton.active = true

	-- minimize
	elseif allMin and eltText.active==true then
		eltText.active = false
		maxButton.active = true
		minButton.active = false
	end
end

------------------------------------ Down element --------------------------------------------------
function r2:downTriggerElement(uiName)
	
	local eltSequenceUI = getUI("ui:interface:"..uiName)
	assert(eltSequenceUI)

	local tab = eltSequenceUI:find("sequence_tabs")
	assert(tab)

	local sequence = eltSequenceUI:find(tab.associatedGroupSelection)
	assert(sequence)

	local listElements = sequence:find("elements_list")
	assert(listElements)

	local selectedElement = r2:getSelectedEltUI(uiName)
	local index = listElements:getElementIndex(selectedElement)

	local sequenceId = r2:getSelectedSequInstId(uiName)
	if index < r2:getInstanceFromId(sequenceId).Components.Size-1 then
		r2.requestMoveNode(sequenceId, "Components", index+1,
						   sequenceId, "Components", index)
	end
end

------------------------------------ Down or up element UI ------------------------------------------

function r2:downUpElement(elementUI, uiName)

	local listElements = elementUI.parent
	assert(listElements)

	local eltEditor = listElements:find("edit_element")
	assert(eltEditor)

	local index = listElements:getElementIndex(elementUI)

	if index > 0 then
		local previousElement = listElements:getChild(index - 1)

		local editorBetweenBothElts = false
		if previousElement.Env.elementId==nil then
			previousElement = listElements:getChild(index - 2)
			editorBetweenBothElts = true
		end

		listElements:upChild(elementUI)
		if editorBetweenBothElts==true then
			listElements:upChild(elementUI)
		end

		local selectedEltUI = r2:getSelectedEltUI(uiName)
		if selectedEltUI~=nil then
			local selectedEltIndex = listElements:getElementIndex(selectedEltUI)
			local eltEditorIndex = listElements:getElementIndex(eltEditor)
			if eltEditorIndex~=selectedEltIndex+1 then
				if eltEditorIndex<selectedEltIndex then
					for i=eltEditorIndex, selectedEltIndex-1 do
						listElements:downChild(eltEditor)
					end
				else
					for i=selectedEltIndex, eltEditorIndex-2 do
						listElements:upChild(eltEditor)
					end
				end

			end

			if selectedEltUI==previousElement then
				previousElement.active = false
			elseif selectedEltUI==elementUI then
				elementUI.active = false
			end

			r2:updateElementEditor(uiName)
		end

		r2:buildElementTitle(uiName, previousElement, false)
		r2:buildElementTitle(uiName, elementUI, false)
	end
end

function r2:updateElementEditor(uiName)

	if uiName == "r2ed_triggers" then
		r2:updateActivityEditor()
	elseif uiName == "r2ed_chat_sequence" then
		r2:updateChatEditor()
	end
end

function r2:buildElementTitle(uiName, elementUI, erase)

	if uiName == "r2ed_triggers" then
		r2:buildActivityTitle(elementUI, erase)
	elseif uiName == "r2ed_chat_sequence" then
		r2:buildChatTitle(elementUI, erase)
	elseif uiName == r2.logicEntityUIPath.."actions" then
		r2:buildActionTitle(elementUI, erase)
	elseif uiName == r2.logicEntityUIPath.."reactions" then
		r2:buildReactionTitle(elementUI, erase)
	end
end

------------------------------------ Up element ------------------------------------------------------
function r2:upTriggerElement(uiName)
	
	local eltSequenceUI = getUI("ui:interface:"..uiName)
	assert(eltSequenceUI)

	local tab = eltSequenceUI:find("sequence_tabs")
	assert(tab)

	local sequence = eltSequenceUI:find(tab.associatedGroupSelection)
	assert(sequence)

	local listElements = sequence:find("elements_list")
	assert(listElements)

	local selectedElement = r2:getSelectedEltUI(uiName)
	local index = listElements:getElementIndex(selectedElement)

	if index>0 then
		local sequenceId = r2:getSelectedSequInstId(uiName)
		r2.requestMoveNode(sequenceId, "Components", index,
						   sequenceId, "Components", index-1)
	end
end

---------------------------------------------------------------------------------------------------
function r2:selectTriggerElement(sequenceUI, uiName, selectedButtonElt)

	if sequenceUI == nil then
		sequenceUI = r2:getSelectedSequ(uiName)
	end
	r2:selectElement(sequenceUI, uiName, true, selectedButtonElt)
end

---------------------------------------------------------------------------------------------------
function r2:closeElementEditor(uiName)
	
	if uiName == "r2ed_chat_sequence" then
		r2:closeChatEditor(getUICaller())
	end

	local sequenceUI = r2:getSelectedSequ(uiName)
	assert(sequenceUI)

	local selectedEltUI = r2:getSelectedEltUI(uiName)
	assert(selectedEltUI)

	local selectedEltButton = selectedEltUI:find("select")
	assert(selectedEltButton)

	selectedEltButton.pushed = false

	r2:selectElement(sequenceUI, uiName, false, selectedEltButton)
end

---------------- SELECT ELEMENT -------------------------------------------------------------------
function r2:selectElement(sequence, uiName, eltOrder, selectedButtonElt)

	local upElement = sequence:find("up_element")
	assert(upElement)
	local downElement = sequence:find("down_element")
	assert(downElement)
	local orderElt = sequence:find("element_order")

	if selectedButtonElt == nil then
		selectedButtonElt = getUICaller()
	end

	-- new selected element
	if selectedButtonElt.pushed == true then
		
		if r2:getSelectedEltUIId(uiName) then

			local lastSelectedElement = r2:getSelectedEltUI(uiName)
			assert(lastSelectedElement)

			local lastEltsList = lastSelectedElement.parent
			local editElt = lastEltsList:find("edit_element")
			assert(editElt)

			if r2:getSelectedEltUIId(uiName) == selectedButtonElt.parent.parent.parent.id then 
				return 
			end
			
			lastSelectedElement.active = true 
			lastSelectedElement:find("select").pushed = false
			
			editElt.active = false
		end

		r2:setSelectedEltUIId(uiName, selectedButtonElt.parent.parent.parent.id)
		
		local selectedElement = selectedButtonElt.parent.parent.parent
		assert(selectedElement)

		if eltOrder then
			upElement.active = true
			downElement.active = true
			orderElt.active = true
		end

		-- update element editor position in list
		local eltsList = sequence:find("elements_list")
		assert(eltsList)
		local editElt = eltsList:find("edit_element")
		assert(editElt)

		local indexSelectedElt = eltsList:getElementIndex(selectedElement)
		local indexEltEditor = eltsList:getElementIndex(editElt)
		
		if indexEltEditor<indexSelectedElt then
			for i=indexEltEditor, indexSelectedElt-1 do
				eltsList:downChild(editElt)
			end
		else
			for i=indexSelectedElt, indexEltEditor-2 do
				eltsList:upChild(editElt)
			end
		end

		editElt.active = true
		selectedElement.active = false

	-- cancel current selection 
	else
		local lastSelectedElement = r2:getSelectedEltUI(uiName)
		r2:setSelectedEltUIId(uiName, nil)
		
		upElement.active = false
		downElement.active = false
		orderElt.active = false

		local lastEltsList = lastSelectedElement.parent
		local editElt = lastEltsList:find("edit_element")
		assert(editElt)

		editElt.active = false
		lastSelectedElement.active = true
	end
end

------------------ SELECT SEQUENCE ---------------------------------------------------------
function r2:selectElementsSequence(uiName, index)
	local eltsWnd = getUI("ui:interface:"..uiName)
	assert(eltsWnd)

	local sequencesTab = eltsWnd:find("sequence_tabs")
	assert(sequencesTab)

	if (index>=0) and (sequencesTab.tabButtonNb > index) then
		sequencesTab.selection = tonumber(index)

		local repeatButton = eltsWnd:find("repeat_group"):find("repeat"):find("toggle_butt")
		assert(repeatButton)

		local sequenceUI = sequencesTab:getGroup(index)
		assert(sequenceUI)
		local sequenceInstId = sequenceUI.Env.sequenceId

		if sequenceInstId and r2:getInstanceFromId(sequenceInstId) then
			local sequenceInst = r2:getInstanceFromId(sequenceInstId)
			repeatButton.pushed = (sequenceInst.Repeating == 0)
		end
	end
end


---------------------------------------- Open element editor --------------------------------------
function r2:openElementEditor(uiName, title, baseWindowName)

	local elementEditor = r2:getSelectedSequ(uiName):find("edit_element")
	assert(elementEditor)

	local selectedElement = r2:getSelectedEltUI(uiName)
	assert(selectedElement)

	elementEditor.active = true
	selectedElement.active = false
end

----------------------------------- Remove elements sequence --------------------------------------
function r2:removeElementsSequence(uiName, elementsTable, sequName)

	local eltSequenceUI = getUI("ui:interface:"..uiName)
	assert(eltSequenceUI)

	local tab = eltSequenceUI:find("sequence_tabs")
	assert(tab)

	local activeLogicEntity = r2:getSelectedInstance()
	assert(activeLogicEntity)
	local activitySequences = activeLogicEntity:getBehavior()[elementsTable]
	
	--local seq = sequName

	--for i=tab.selection+1,(tab.tabButtonNb-1) do
	--	local buttonTab = tab:find("tab"..i)
	--	assert(buttonTab)
		
	--	if activitySequences[i].Name == seq..(i+1) then
	--		local newText = seq..(i)
	--		r2.requestSetNode(activitySequences[i].InstanceId, "Name", newText)
	--	end	
	--end

	local sequenceId = r2:getSelectedSequInstId(uiName)
	-- request erase node
	r2.requestEraseNode(sequenceId, "", -1)

	return sequenceId
end

function r2:removeElementsSequenceUI(tabIndex, uiName, elementsTable, sequName)

	local wndUI = getUI("ui:interface:"..uiName)
	assert(wndUI)

	local tab = wndUI:find("sequence_tabs")
	assert(tab)

	local activeLogicEntity = r2:getSelectedInstance()
	assert(activeLogicEntity)
	local activitySequences = activeLogicEntity:getBehavior()[elementsTable]
	
	for i=tabIndex+1,(tab.tabButtonNb-1) do
		local buttonTab = tab:find("tab"..i)
		assert(buttonTab)
		
		buttonTab.params_l = "r2:selectSequenceTab('"..uiName.."', "..tostring(i-1)..")"

		if buttonTab.hardtext == sequName..(i+1) then
			buttonTab.text = sequName..i
		end
	end

	-- recover name of the future "first sequence"
	local firstEltName 
	local indexName
	if tab.tabButtonNb > 1 then
		if tabIndex==0 then
			indexName = 1
		else
			indexName = 0
		end
		--if activitySequences[indexName].Name==sequName..(indexName+1) then
		if r2:getSequenceName(activitySequences[indexName])==sequName..(indexName+1) then
			firstEltName = sequName.."1"
		else
			--firstEltName = activitySequences[indexName].Name
			firstEltName = r2:getSequenceName(activitySequences[indexName])
		end
	else
		firstEltName = tostring(i18n.get("uiR2EDSequences"))
	end

	local selectedElt = r2:getSelectedEltUI(uiName)
	if selectedElt and selectedElt.parent.parent.parent.id == r2:getSelectedSequ(uiName).id then
		r2:setSelectedEltUIId(uiName, nil)
	end

	tab:removeTab(tabIndex)

	if tab.tabButtonNb == 0 then
		r2:cleanSequenceEditor(wndUI)
	end

	return firstEltName
end

function r2:cleanSequenceEditor(eltSequenceUI)

	local sepTop = eltSequenceUI:find("sep_top")
	assert(sepTop)

	local sepBottom = eltSequenceUI:find("sep_bottom")
	assert(sepBottom)

	local sepLeft = eltSequenceUI:find("sep_left")
	assert(sepLeft)

	local sepRight = eltSequenceUI:find("sep_right")
	assert(sepRight)

	local removeSequence = eltSequenceUI:find("remove_sequence_button")
	assert(removeSequence)

	local editSequence = eltSequenceUI:find("edit_sequence")
	assert(editSequence)

	sepTop.active = false
	sepBottom.active = false
	sepLeft.active= false
	sepRight.active= false
	removeSequence.active = false
	editSequence.active = false

	local repeatButtonGr = eltSequenceUI:find("repeat_group")
	repeatButtonGr.active = false
end

------------------ new elements sequence  -------------------------------------------------------------
function r2:newElementsSequence(uiName, templateParams, editorEltTemplate, instance, sequName)

	local eltSequenceUI = getUI("ui:interface:"..uiName)
	assert(eltSequenceUI)

	local menu = eltSequenceUI:find("sequence_menu")
	assert(menu)

	local tab = menu:find("sequence_tabs")
	assert(tab)

	local newTabNb = tab.tabButtonNb+1
	local posParent, posRef, id, hardText, group
	if newTabNb == 1 then
		posParent = "parent"
		posRef = "TL TL"
	else
		posParent = "tab"..(newTabNb-2)
		posRef = "TR TL"
	end

	id = "tab"..(newTabNb-1)
	local group = "sequence"..r2.sequencesNb

	r2.sequencesNb = r2.sequencesNb + 1

	local newTabGroup = createUIElement("sequence_elements_template", menu.id, {id=group,
		new_elt=templateParams.newElt, new_elt_text=templateParams.newEltText, 
		elt_order_text=templateParams.eltOrderText, up_elt=templateParams.upElt, 
		down_elt=templateParams.downElt, max_min_elts=templateParams.maxMinElts,
		down_up_color=templateParams.downUpColor})
	assert(newTabGroup)

	menu:addGroup(newTabGroup)

	newTabGroup.Env.sequenceId = instance.InstanceId
	
	local tabName
	if instance.Name~= "" then
		tabName = instance.Name
	else
		local comps = instance.Parent
		for i=0, comps.Size-1 do
			if comps[i].InstanceId == instance.InstanceId then
				tabName = sequName..(i+1)
				break
			end
		end
	end

	local newTab = createUIElement("sequence_tab_template", tab.id, 
		{id=id, posparent=posParent, posref=posRef, hardtext=tabName, group=group,
		 col_pushed =templateParams.colPushed, params_l=templateParams.paramsL})
	assert(newTab)
	
	tab:addTab(newTab)

	if r2.ownCreatedInstances[instance.InstanceId] == true then
		tab.selection = tab.tabButtonNb-1
		r2.ownCreatedInstances[instance.InstanceId] = nil

		--local repeatButton = eltSequenceUI:find("repeat_group"):find("repeat"):find("toggle_butt")
		--assert(repeatButton)
		--repeatButton.pushed = (instance.Repeating == 0)

		r2:selectElementsSequence(uiName, tab.tabButtonNb-1)
	end

	if tab.tabButtonNb == 1 then
		local sepTop = menu:find("sep_top")
		assert(sepTop)

		local sepBottom = menu:find("sep_bottom")
		assert(sepBottom)

		local sepLeft = menu:find("sep_left")
		assert(sepLeft)

		local sepRight = menu:find("sep_right")
		assert(sepRight)

		local removeSequence = eltSequenceUI:find("remove_sequence_button")
		assert(removeSequence)

		local editSequence = eltSequenceUI:find("edit_sequence")
		assert(editSequence)

		sepTop.active = true
		sepBottom.active = true
		sepLeft.active= true
		sepRight.active= true
		removeSequence.active = true
		editSequence.active = true

		if uiName == "r2ed_triggers" then   --TEMP TEMP TEMP
			local repeatButtonGr = eltSequenceUI:find("repeat_group")
			repeatButtonGr.active = true	
		end									--TEMP TEMP TEMP
	end

	local listElements = newTabGroup:find("elements_list")
	assert(listElements)
	listElements.Env.elementsCount = nil

	-- add element editor in list
	local newEditorElt = createGroupInstance(editorEltTemplate, listElements.id, {id="edit_element", active="false"})
	assert(newEditorElt)
	listElements:addChild(newEditorElt)
	listElements.parent:updateCoords()

	newEditorElt.Env.isEditor = true

	newEditorElt.active = false
	
	return newTabGroup
end

---------------------------- new element --------------------------------------------------------------
function r2:newTriggerElement(uiName, elementName, templateParams, sequenceUI, instanceId)

	if sequenceUI == nil then
		eltSequenceUI = getUI("ui:interface:"..uiName)
		assert(eltSequenceUI)

		local tab = eltSequenceUI:find("sequence_tabs")
		assert(tab)

		local sequenceUI = eltSequenceUI:find(tab.associatedGroupSelection)
	end
	assert(sequenceUI)

	local newElement = r2:newElement(sequenceUI, elementName, templateParams, true)

	newElement.Env.elementId = instanceId

	if r2.ownCreatedInstances[instanceId] == true then
		newElement:find("select").pushed = true 
		r2:selectTriggerElement(sequenceUI, uiName, newElement:find("select"))
		r2.ownCreatedInstances[instanceId] = nil

		if uiName == "r2ed_triggers" then
			r2:updateActivityEditor()
		elseif uiName == "r2ed_chat_sequence" then
			r2:updateChatEditor()
		end
	end

	r2:maximizeMinimizeElement(uiName, newElement)

	return newElement
end

---------------------------- new base element --------------------------------------------------------------
function r2:newElement(sequence, elementName, templateParams, eltOrder)

	local listElements = sequence:find("elements_list")
	assert(listElements)

	-- counter for element group id
	if listElements.Env.elementsCount == nil then
		listElements.Env.elementsCount = 0
		listElements.Env.elementsNb = 1
	else
		listElements.Env.elementsCount = listElements.Env.elementsCount+1
		listElements.Env.elementsNb = listElements.Env.elementsNb+1
	end

	local elementId = "elt"..listElements.Env.elementsCount

	local hardText = elementName.." "..listElements.Env.elementsNb.." : "

	-- create new element
	local newElement = createGroupInstance("element_template", listElements.id, 
		{id=elementId, posref="TL TL", x="0", y="0", sizeref="w", hardtext=hardText,
		 select_elt=templateParams.selectElt, open_elt_editor=templateParams.openEltEditor,
		 max_min_elt=templateParams.maxMinElt, remove_elt=templateParams.removeElt, open_chat=templateParams.openChat,
		 col_over=templateParams.colOver, col_pushed=templateParams.colPushed})

	-- add element to list
	listElements:addChild(newElement)
	listElements.parent:updateCoords()
	
	-- active global minimize / maximize button
	if listElements.childrenNb == 2 then
		local maxElts = sequence:find("maximize_elements")
		assert(maxElts)
		maxElts.active = true

		if eltOrder then
			
			local elementOrder = sequence:find("element_order")
			assert(elementOrder)
			elementOrder.active=true
		end
	end

	-- scroll goes down to new element
	local sequenceContent = newElement.parent.parent.parent
	assert(sequenceContent)

	local scrollBar = sequenceContent:find("scroll_objects")
	assert(scrollBar)
	scrollBar.trackPos = 0

	-- target sroll text
	local scroll = newElement:find("scroll_bar_text")
	assert(scroll)

	local scrollText = newElement:find("scroll_text_gr")
	assert(scrollText)
	scroll:setTarget(scrollText.id)

	return newElement
end

------------------ OPEN SEQUENCE EDITOR  --------------------------------------------------
function r2:openSequenceEditor(uiName, editorName)

	local editor = getUI("ui:interface:"..editorName)
	assert(editor)

	local eltsUI = getUI("ui:interface:"..uiName)
	assert(eltsUI)

	editor.x = eltsUI.x
	editor.y = eltsUI.y
	editor.active = true

	-- update edit box text with current sequence name
	local editName = editor:find("sequence_name"):find("edit_box_group")
	assert(editName)

	local tab = eltsUI:find("sequence_tabs")
	assert(tab)

	local buttonTab = tab:find("tab"..tab.selection)
	assert(buttonTab)

	editName.input_string = buttonTab.text
end

------------------ SET SEQUENCE NAME  -----------------------------------------------------
function r2:setSequenceName(uiName, editorName)

	local editor = getUI("ui:interface:"..editorName)
	assert(editor)

	local editName = editor:find("sequence_name"):find("edit_box_group")
	assert(editName)

	local name = editName.input_string

	local sequenceInstId = r2:getSelectedSequInstId(uiName)
	r2.requestSetNode(sequenceInstId, "Name", name)
end

function r2:updateSequenceName(uiName, instance)

	--local name = instance.Name
	local name = r2:getSequenceName(instance)
	local sequInstId = instance.InstanceId
	 
	local eltsUI = getUI("ui:interface:"..uiName)
	assert(eltsUI)

	local tab = eltsUI:find("sequence_tabs")
	assert(tab)

	local tabId
	for i=0, tab.tabButtonNb-1 do
		local sequenceUI = tab:getGroup(i)
		if sequenceUI.Env.sequenceId == sequInstId then
			tabId = i
			break
		end
	end

	local buttonTab = tab:find("tab"..tabId)
	assert(buttonTab)
	
	buttonTab.text = name

	if uiName == "r2ed_triggers" then
		r2:updateSequencesButtonBar(tabId, name)
	end
end

function r2:updateSequenceRepeatingOption(uiName, instance)

	local sequenceUI = r2:getSelectedSequ(uiName)

	if sequenceUI.Env.sequenceId == instance.InstanceId then

		local eltsUI = getUI("ui:interface:"..uiName)
		local repeatButton = eltsUI:find("repeat_group"):find("repeat"):find("toggle_butt")
		repeatButton.pushed = (instance.Repeating == 0)
	end
end


--------------------------------------------------------------------------------------------------
-------------------------- ACTIVE LOGIC ENTITY DisplayerProperties -----------------------------------------
--------------------------------------------------------------------------------------------------

local activeLogicEntityPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())

------------------------------------------------
function activeLogicEntityPropertySheetDisplayerTable:onPostCreate(instance)	
end
------------------------------------------------
function activeLogicEntityPropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function activeLogicEntityPropertySheetDisplayerTable:onPreHrcMove(instance)		
end
------------------------------------------------
function activeLogicEntityPropertySheetDisplayerTable:onPostHrcMove(instance)		
end
------------------------------------------------
function activeLogicEntityPropertySheetDisplayerTable:onFocus(instance, hasFocus)		
end

------------------------------------------------
r2.activitiesAndChatsUIUpdate = false
function activeLogicEntityPropertySheetDisplayerTable:onSelect(instance, isSelected)

	r2:logicEntityPropertySheetDisplayer():onSelect(instance, isSelected)
	
	local triggersUI = getUI("ui:interface:r2ed_triggers")
	assert(triggersUI)

	if not isSelected then
		triggersUI.active = false
		r2:closeMiniActivityView()
		r2:closeChatSequencesUI()

		r2:cleanActivitiesAndChatsUI()
		r2:cleanLogicEntityUI()
	else
		r2.activitiesAndChatsUIUpdate = false
	end
end

r2.callSetSaysWhat = true
------------------------------------------------
function r2:cleanActivitiesAndChatsUI()

	-- update chat sequence combo box
	local triggersUI = getUI("ui:interface:r2ed_triggers")
	assert(triggersUI)
	local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
	assert(chatSequencesUI)

	-- remove all tabs
	local sequenceMenu = triggersUI:find("sequence_menu")
	assert(sequenceMenu)

	local tabActivities = triggersUI:find("sequence_tabs")
	assert(tabActivities)

	for i=0, tabActivities.tabButtonNb-1 do
		local groupTab = tabActivities:getGroup(i)
		assert(groupTab)
		sequenceMenu:delGroup(groupTab)
	end

	tabActivities:removeAll()
	r2:setSelectedEltUIId("r2ed_triggers", nil)
	r2:cleanSequenceEditor(triggersUI)

	-- delete chat sequences
	sequenceMenu = chatSequencesUI:find("sequence_menu")
	assert(sequenceMenu)

	local tabChats = chatSequencesUI:find("sequence_tabs")
	assert(tabChats)

	for i=0, tabChats.tabButtonNb-1 do
		local groupTab = tabChats:getGroup(i)
		assert(groupTab)
		sequenceMenu:delGroup(groupTab)
	end

	tabChats:removeAll()
	r2:setSelectedEltUIId("r2ed_chat_sequence", nil)
	r2:cleanSequenceEditor(chatSequencesUI)
end

function r2:updateActivitiesAndChatsUI(instance)

	if r2.activitiesAndChatsUIUpdate==true then
		return
	end

	r2.activitiesAndChatsUIUpdate = true

	if r2.lastSelectedActivitySequence==nil then

		r2:cleanActivitiesAndChatsUI()

		-- update chat sequence combo box
		local triggersUI = getUI("ui:interface:r2ed_triggers")
		assert(triggersUI)
		local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
		assert(chatSequencesUI)

		-- remove all tabs
		local tabActivities = triggersUI:find("sequence_tabs")
		assert(tabActivities)

		-- delete chat sequences
		local tabChats = chatSequencesUI:find("sequence_tabs")
		assert(tabChats)


		local activitySequences = instance:getBehavior().Activities
		local chatSequences = instance:getBehavior().ChatSequences

		-- build sequences of selected NPC group
		local uiName = "r2ed_triggers"
		
		for s = 0, activitySequences.Size - 1 do
			local sequence = activitySequences[s]
			r2:newActivitiesSequence(false, sequence, true)
		end
		
		if tabActivities.tabButtonNb>1 then
			tabActivities.selection = 0
			r2:selectElementsSequence(uiName, 0)
		end
		for s=0, tabActivities.tabButtonNb-1 do 
			local sequenceUI = tabActivities:getGroup(s)
			assert(sequenceUI)
			
			local eltsList = sequenceUI:find("elements_list")
			assert(eltsList)
			if eltsList.childrenNb > 1 then
				local firstElt = eltsList:getChild(1)
				local selectedButton = firstElt:find("select")
				selectedButton.pushed = true
				
				r2:selectElement(sequenceUI, uiName, true, selectedButton)
				
				r2:updateActivityEditor()

				break
			end
		end

		uiName = "r2ed_chat_sequence"
		r2.callSetSaysWhat = false
		for s = 0, chatSequences.Size - 1 do
			local sequence = chatSequences[s]
			r2:newChatsSequence(false, sequence, true)
		end
		r2.callSetSaysWhat = true
		if tabChats.tabButtonNb>1 then
			tabChats.selection = 0
			r2:selectElementsSequence(uiName, 0)
		end
		for s=0, tabChats.tabButtonNb-1 do 
			local sequenceUI = tabChats:getGroup(s)
			assert(sequenceUI)

			local eltsList = sequenceUI:find("elements_list")
			assert(eltsList)
			if eltsList.childrenNb > 1 then
				local firstElt = eltsList:getChild(1)
				local selectedButton = firstElt:find("select")
				r2.callSetSaysWhat = false
				selectedButton.pushed = true
				
				r2:selectElement(sequenceUI, uiName, true, selectedButton)
			
				r2.callSetSaysWhat = true

				r2:updateChatEditor()
			end
		end
		
		triggersUI.title = tostring(i18n.get("uiR2EDActivitySequenceEditor")) .. r2:getSelectedInstance().Name
		chatSequencesUI.title = tostring(i18n.get("uiR2EDChatSequenceEditor")) .. r2:getSelectedInstance().Name
	end
end

------------------------------------------------
function activeLogicEntityPropertySheetDisplayerTable:onAttrModified(instance, attributeName)

	r2:logicEntityPropertySheetDisplayer():onAttrModified(instance, attributeName)

	if not r2.activitiesAndChatsUIUpdate or instance ~= r2:getSelectedInstance() then
		return
	end

	if attributeName == "Name" then

		local triggersUI = getUI("ui:interface:r2ed_triggers")
		assert(triggersUI)

		local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
		assert(chatSequencesUI)

		triggersUI.title = tostring(i18n.get("uiR2EDActivitySequenceEditor")) .. instance[attributeName]
		chatSequencesUI.title = tostring(i18n.get("uiR2EDChatSequenceEditor")) .. instance[attributeName]	
	end
end	

------------------------------------------------
function r2:activeLogicEntityPropertySheetDisplayer()	
	return activeLogicEntityPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end


--------------------------------------------------------------------------------------------------
-------------------------- NPC GROUP DisplayerProperties -----------------------------------------
--------------------------------------------------------------------------------------------------

local npcGroupPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())

------------------------------------------------
function npcGroupPropertySheetDisplayerTable:onPostCreate(instance)	
end
------------------------------------------------
function npcGroupPropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function npcGroupPropertySheetDisplayerTable:onPreHrcMove(instance)		
end
------------------------------------------------
function npcGroupPropertySheetDisplayerTable:onPostHrcMove(instance)		
end
------------------------------------------------
function npcGroupPropertySheetDisplayerTable:onFocus(instance, hasFocus)		
end

------------------------------------------------
function npcGroupPropertySheetDisplayerTable:onSelect(instance, isSelected)	
	r2:activeLogicEntityPropertySheetDisplayer():onSelect(instance, isSelected)
end

------------------------------------------------
function npcGroupPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
	r2:activeLogicEntityPropertySheetDisplayer():onAttrModified(instance, attributeName)
end	

------------------------------------------------
function r2:npcGroupPropertySheetDisplayer()	
	return npcGroupPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end

	




--------------------------------------------------------------------------------------------------
-------------------------------- ACTIVITY SEQUENCE DisplayerProperties ---------------------------
--------------------------------------------------------------------------------------------------
local activitySequencePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())

------------------------------------------------
function activitySequencePropertySheetDisplayerTable:onPostCreate(instance)	

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	r2:newActivitiesSequence(false, instance, false)
end
------------------------------------------------
function activitySequencePropertySheetDisplayerTable:onErase(instance)

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local triggersUI = getUI("ui:interface:r2ed_triggers")
	assert(triggersUI)

	local sequenceTabs = triggersUI:find("sequence_tabs")
	assert(sequenceTabs)

	local sequIndex
	for i=0,sequenceTabs.tabButtonNb-1 do
		local sequence = sequenceTabs:getGroup(i)
		if sequence.Env.sequenceId == instance.InstanceId then
			sequIndex = i
			break
		end
	end
	
	if sequIndex~=nil then
		r2:removeActivitiesSequenceUI(sequIndex)
	end
end
------------------------------------------------
function activitySequencePropertySheetDisplayerTable:onPreHrcMove(instance)		
end
------------------------------------------------
function activitySequencePropertySheetDisplayerTable:onPostHrcMove(instance)		
end
------------------------------------------------
function activitySequencePropertySheetDisplayerTable:onFocus(instance, hasFocus)		
end

------------------------------------------------
function activitySequencePropertySheetDisplayerTable:onSelect(instance, isSelected)	
end

------------------------------------------------
function activitySequencePropertySheetDisplayerTable:onAttrModified(instance, attributeName)

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	if attributeName == "Name" then
		r2:updateSequenceName("r2ed_triggers", instance)
	elseif attributeName == "Repeating" then
		r2:updateSequenceRepeatingOption("r2ed_triggers", instance)
	end			
end	

------------------------------------------------
function r2:activitySequencePropertySheetDisplayer()	
	return activitySequencePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end


--------------------------------------------------------------------------------------------------
-------------------------------- CHAT SEQUENCE DisplayerProperties ---------------------------
--------------------------------------------------------------------------------------------------
local chatSequencePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())

------------------------------------------------
function chatSequencePropertySheetDisplayerTable:onPostCreate(instance)	

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	r2:newChatsSequence(false, instance)
end
------------------------------------------------
function chatSequencePropertySheetDisplayerTable:onErase(instance)

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local chatsUI = getUI("ui:interface:r2ed_chat_sequence")
	assert(chatsUI)

	local sequenceTabs = chatsUI:find("sequence_tabs")
	assert(sequenceTabs)

	local sequIndex
	for i=0,sequenceTabs.tabButtonNb-1 do
		local sequence = sequenceTabs:getGroup(i)
		if sequence.Env.sequenceId == instance.InstanceId then
			sequIndex = i
			break
		end
	end
	
	if sequIndex~=nil then
		r2:removeChatsSequenceUI(sequIndex)
	end

	r2:updateMiniActivityView()
end
------------------------------------------------
function chatSequencePropertySheetDisplayerTable:onPreHrcMove(instance)		
end
------------------------------------------------
function chatSequencePropertySheetDisplayerTable:onPostHrcMove(instance)		
end
------------------------------------------------
function chatSequencePropertySheetDisplayerTable:onFocus(instance, hasFocus)		
end

------------------------------------------------
function chatSequencePropertySheetDisplayerTable:onSelect(instance, isSelected)	
end

------------------------------------------------
function chatSequencePropertySheetDisplayerTable:onAttrModified(instance, attributeName)

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	if attributeName == "Name" then
		r2:updateSequenceName("r2ed_chat_sequence", instance)
	elseif attributeName == "Repeating" then
		r2:updateSequenceRepeatingOption("r2ed_chat_sequence", instance)
	end			
end	

------------------------------------------------
function r2:chatSequencePropertySheetDisplayer()	
	return chatSequencePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end


--------------------------------------------------------------------------------------------------
-------------------------------- ACTIVITY STEP DisplayerProperties--------------------------------
--------------------------------------------------------------------------------------------------
local activityStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())

------------------------------------------------
function activityStepPropertySheetDisplayerTable:onPostCreate(instance)	

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local activitySequInst = instance.Parent.Parent

	local triggersUI = getUI("ui:interface:r2ed_triggers")
	assert(triggersUI)

	local sequenceTabs = triggersUI:find("sequence_tabs")
	assert(sequenceTabs)

	local sequenceUI
	for i=0,sequenceTabs.tabButtonNb-1 do
		local sequence = sequenceTabs:getGroup(i)
		if sequence.Env.sequenceId == activitySequInst.InstanceId then
			sequenceUI = sequence
			break
		end
	end

	r2:newActivity(false, nil, instance, sequenceUI)
end
------------------------------------------------
function activityStepPropertySheetDisplayerTable:onErase(instance)

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local sequenceUI, elementUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_triggers")

	if elementUI ~= nil then
		r2:removeActivityUI(sequenceUI, elementUI)
	end
end
------------------------------------------------
function activityStepPropertySheetDisplayerTable:onPreHrcMove(instance)		
end
------------------------------------------------
function activityStepPropertySheetDisplayerTable:onPostHrcMove(instance)

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local sequenceUI, activityStepUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_triggers")
	if activityStepUI then
		r2:downUpElement(activityStepUI, "r2ed_triggers")
	end	
end
------------------------------------------------
function activityStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)		
end

------------------------------------------------
function activityStepPropertySheetDisplayerTable:onSelect(instance, isSelected)	
end

------------------------------------------------
function activityStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
	
	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local sequenceUI, elementUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_triggers")
	if elementUI then
		r2:updateActivityChatSequence(elementUI)
	end
end	

------------------------------------------------
function activityStepPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)

	if refIdName == "ActivityZoneId" then
		r2.requestSetNode(instance.InstanceId, "Activity", "Stand Still")
		r2.requestSetNode(instance.InstanceId, "ActivityZoneId", r2.RefId(""))
		r2.requestSetNode(instance.InstanceId, "TimeLimit", "No Limit")
		r2.requestSetNode(instance.InstanceId, "TimeLimitValue", "")
	elseif refIdName == "Chat" then
		r2.requestSetNode(instance.InstanceId, "Chat", r2.RefId(""))
	end
end
------------------------------------------------
function activityStepPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)	
end

-------------------------------------------------
function r2:activityStepPropertySheetDisplayer()	
	return activityStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end



--------------------------------------------------------------------------------------------------
-------------------------------- CHAT STEP DisplayerProperties------------------------------------
--------------------------------------------------------------------------------------------------
local chatStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())

------------------------------------------------
function chatStepPropertySheetDisplayerTable:onPostCreate(instance)

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local chatSequInst = instance.Parent.Parent

	local chatsUI = getUI("ui:interface:r2ed_chat_sequence")
	assert(chatsUI)

	local sequenceTabs = chatsUI:find("sequence_tabs")
	assert(sequenceTabs)

	local sequenceUI
	for i=0,sequenceTabs.tabButtonNb-1 do
		local sequence = sequenceTabs:getGroup(i)
		if sequence.Env.sequenceId == chatSequInst.InstanceId then
			sequenceUI = sequence
			break
		end
	end

	r2:newChat(false, instance, sequenceUI)	
end
------------------------------------------------
function chatStepPropertySheetDisplayerTable:onErase(instance)

	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local sequenceUI, elementUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_chat_sequence")
	
	if elementUI ~= nil then
		local chatStepInst = r2:getInstanceFromId(elementUI.Env.elementId)
		assert(chatStepInst)
		r2:updateActivitiesWhithThisChatSequence(chatStepInst, true)
		r2:removeElementUI(sequenceUI, "r2ed_chat_sequence", elementUI)
	end
end
------------------------------------------------
function chatStepPropertySheetDisplayerTable:onPreHrcMove(instance)		
end
------------------------------------------------
function chatStepPropertySheetDisplayerTable:onPostHrcMove(instance)
	
	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	r2:updateActivitiesWhithThisChatSequence(instance, false)	

	local sequenceUI, chatStepUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_chat_sequence")
	if chatStepUI then
		r2:downUpElement(chatStepUI, "r2ed_chat_sequence")
	end
end
------------------------------------------------
function chatStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)		
end

------------------------------------------------
function chatStepPropertySheetDisplayerTable:onSelect(instance, isSelected)	
end

------------------------------------------------
function chatStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
	
	local activeLogicEntity = r2:getSelectedInstance()
	local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
	
	if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
		return
	end

	local sequenceUI, chatStepUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_chat_sequence")
	if chatStepUI then
		r2:updateChatText(chatStepUI)
	end
end	

function r2:findSequenceAndElementUIFromInstance(instance, uiName)

	local sequenceInst = instance.Parent.Parent

	local wndUI = getUI("ui:interface:"..uiName)
	assert(wndUI)

	local sequenceTabs = wndUI:find("sequence_tabs")
	assert(sequenceTabs)

	local sequenceUI
	for i=0,sequenceTabs.tabButtonNb-1 do
		local sequence = sequenceTabs:getGroup(i)
		if sequence.Env.sequenceId == sequenceInst.InstanceId then
			sequenceUI = sequence
			break
		end
	end

	if sequenceUI ~= nil then
		local eltsList = sequenceUI:find("elements_list")
		assert(eltsList)

		for i=0,eltsList.childrenNb-1 do
			local element = eltsList:getChild(i)
			if element.Env.elementId == instance.InstanceId then
				return sequenceUI, element
			end
		end
	end
end

--------------------------------------------------
function r2:chatStepPropertySheetDisplayer()	
	return chatStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end



--------------------------------------------------------------------------------------------------
-------------------------------- CHAT ACTION DisplayerProperties -----------------------
--------------------------------------------------------------------------------------------------
local chatActionPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())

------------------------------------------------
function chatActionPropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function chatActionPropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function chatActionPropertySheetDisplayerTable:onPreHrcMove(instance)		
end
------------------------------------------------
function chatActionPropertySheetDisplayerTable:onPostHrcMove(instance)		
end
------------------------------------------------
function chatActionPropertySheetDisplayerTable:onFocus(instance, hasFocus)		
end

------------------------------------------------
function chatActionPropertySheetDisplayerTable:onSelect(instance, isSelected)	
end

------------------------------------------------
function chatActionPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
end	

------------------------------------------------
function chatActionPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
	if refIdName == "Who" then
		r2.requestSetNode(instance.InstanceId, "Who", r2.RefId(""))
		r2.requestSetNode(instance.InstanceId, "Says", "")
		r2.requestSetNode(instance.InstanceId, "Emote", "")
		r2.requestSetNode(instance.InstanceId, "Facing", r2.RefId(""))
	elseif refIdName == "Facing" then
		r2.requestSetNode(instance.InstanceId, "Facing", r2.RefId(""))
	end
end
------------------------------------------------
function chatActionPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)	
end

------------------------------------------------
function r2:chatActionPropertySheetDisplayer()	
	return chatActionPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end











r2.lastSelectedActivitySequence = nil

r2.activityTexture = {	["Follow Route"]	= "r2_mini_activity_follow_road.tga",
						["Patrol"]			= "r2_mini_activity_patrol_road.tga",
						["Repeat Road"]		= "r2_mini_activity_repeat_road.tga",
						["Wander"]			= "r2_mini_activity_wander_zone.tga",
						["Stand Still"]		= "r2_mini_activity_stand_still.tga",
--						["Inactive"]		= "r2_mini_activity_inactive.tga"
					}

---------------------------------------------------------------------------------------------------------
-- Show the mini activity view for this instance
function r2:setupMiniActivityView(instance)	
	if instance and instance:isKindOf("ActiveLogicEntity") then
		local selectedTab = 0
		if r2.lastSelectedActivitySequence then
			selectedTab = r2.lastSelectedActivitySequence 
		end
		r2:selectActivitiesSequence(selectedTab)	
		r2:updateSequencesButtonBar(selectedTab)
	end
end

------------------ SELECT ACTIVITY SEQUENCE ---------------------------------------------------------
function r2:selectActivitiesSequence(index)
	r2:selectElementsSequence("r2ed_triggers", index)
	r2:openAndUpdateMiniActivityView(index)
end

------------------ UPDATE SEQUENCES BUTTON BAR ---------------------------------------------------------
function r2:updateSequencesButtonBar(index, sequenceName)

	local selectBar = getUI("ui:interface:r2ed_select_bar")
	assert(selectBar)

	local sequencesButton = selectBar:find("sequences")
	assert(sequencesButton)

	local activeLogicEntity = r2:getSelectedInstance()
	if activeLogicEntity then
		if sequenceName==nil and (index >=0) and (index < activeLogicEntity:getBehavior().Activities.Size) then
			local activitySequence = activeLogicEntity:getBehavior().Activities[index]
			assert(activitySequence)
			--sequencesButton.text = activitySequence.Name
			sequencesButton.text = r2:getSequenceName(activitySequence)
		elseif sequenceName~= nil then
			sequencesButton.text = sequenceName
		else
			sequencesButton.text = i18n.get("uiR2EDSequences")
		end
	end
end


function r2:newMiniActivitySequence()
	return r2:newActivitiesSequence(true)	
end

function r2:openAndUpdateMiniActivityView(index)
	r2:openMiniActivityView()
	-- update activities list

	r2:updateMiniActivityView(index)
end

function r2:openMiniActivityView()
	local triggersUI = getUI("ui:interface:r2ed_triggers")
	assert(triggersUI)

	local selectedInst = r2:getSelectedInstance()

	if selectedInst and not selectedInst:isBotObject() and not selectedInst:isPlant() and not triggersUI.active then
		local miniActivityView = getUI("ui:interface:r2ed_mini_activity_view")
		assert(miniActivityView)								
		miniActivityView.active = true		
	end
end


function r2:updateMiniActivityView(index)

	local miniActivityView = getUI("ui:interface:r2ed_mini_activity_view")
	assert(miniActivityView)

	local miniActivities = miniActivityView:find("mini_activities")
	assert(miniActivities)

	local noActivityLabel = miniActivityView:find("no_activity")
	assert(noActivityLabel)

	local startCount = 0
	local sequence 
	if index~=nil then
		local activities = r2:getSelectedInstance():getBehavior().Activities
		if index < activities.Size then
			sequence = activities[index]
		end
	else
		sequence = r2:getSelectedSequInst("r2ed_triggers")
	end
	
	if sequence~=nil then

		--label "No activity"
		if sequence.Components.Size == 0 then
			noActivityLabel.active = true
			noActivityLabel.text = tostring(i18n.get("uiR2EdNoActivity"))
		else
			noActivityLabel.active = false
		end

		for i=0, sequence.Components.Size-1 do

			local activityInst = sequence.Components[i]
			assert(activityInst)

			if activityInst then

				local activityIndex = i
				if afterEltEditor==true then activityIndex = i-1 end

				local miniActivity = miniActivities[tostring(activityIndex)]
				assert(miniActivity)

				miniActivity.active = true
				miniActivity.Env.id = activityIndex

				-- chat button
				local chatButton = miniActivity:find("chat_sequence"):find("button")
				assert(chatButton)
				if tostring(activityInst.Chat) ~= "" then
					local chatTexture = "r2_mini_activity_chat.tga"
					chatButton.texture = chatTexture
					chatButton.texture_pushed = chatTexture
					chatButton.texture_over = chatTexture
				else
					local chatTexture = "r2_mini_activity_empty_chat.tga"
					chatButton.texture = chatTexture
					chatButton.texture_pushed = chatTexture
					chatButton.texture_over = chatTexture
				end	

				-- activity type button
				local activityButton = miniActivity:find("activity"):find("button")
				assert(activityButton)
				local activityTexture = r2.activityTexture[activityInst.Activity]
				if activityTexture then
					activityButton.texture = activityTexture
					activityButton.texture_pushed = activityTexture
					activityButton.texture_over = activityTexture
				end

				-- activity type text
				local activityText = miniActivity:find("activity_name")
				assert(activityText)
				activityText.text = activityInst.Activity
			end
		end
		startCount = sequence.Components.Size 
	else
		noActivityLabel.active = true
		noActivityLabel.text = tostring(i18n.get("uiR2EdNoSequence"))
	end

	-- hide remaining mini activity templates
	for i=startCount, r2.maxActivities-1 do
		local miniActivity = miniActivities[tostring(i)]
		assert(miniActivity)
		miniActivity.active = false
	end
end


function r2:closeMiniActivityView()
	local miniActivityView = getUI("ui:interface:r2ed_mini_activity_view")
	assert(miniActivityView)
	miniActivityView.active = false
end

function r2:openActivitiesSequence()
	
	r2:updateActivitiesAndChatsUI(r2:getSelectedInstance())

	local triggersUI = getUI("ui:interface:r2ed_triggers")
	assert(triggersUI)

	triggersUI.active = true
	triggersUI:updateCoords()
	
	if triggersUI.Env.openFirst == nil then
		triggersUI:center()
		triggersUI.Env.openFirst = true
	end

	r2:closeMiniActivityView()
end


function r2:chooseOrOpenSelectedChatSequence()

	r2:updateActivitiesAndChatsUI(r2:getSelectedInstance())

	-- init menu
	local menuName = "ui:interface:r2ed_chat_sequences_menu"
	launchContextMenuInGame(menuName)
	local menu = getUI(menuName)

	local rootMenu = menu:getRootMenu()
	assert(rootMenu)
	rootMenu:reset()

	-- update menu
	local miniActivity = getUICaller().parent.parent.parent
	assert(miniActivity)

	local miniActivityNb = tonumber(miniActivity.Env.id)
	local activitySequence = r2:getSelectedSequInst("r2ed_triggers")
	assert(activitySequence)
	local activityInst = activitySequence.Components[miniActivityNb]

	local chatSequenceId = tostring(activityInst.Chat)

	local newLine = 3
	--title "Chat sequence"
	local chatSequence
	if chatSequenceId ~= "" then
		chatSequence = r2:getInstanceFromId(chatSequenceId)
		assert(chatSequence)
		--rootMenu:addLine(i18n.get("uiR2EDChatSequence").." " .. chatSequence.Name .." : ", "lua", "", "Title")
		rootMenu:addLine(i18n.get("uiR2EDChatSequence").." " .. r2:getSequenceName(chatSequence) .." : ", "lua", "", "Title")
	else
		rootMenu:addLine(i18n.get("uiR2EDChatSequence").." : ", "lua", "", "Title")
	end

	rootMenu:addSeparator()

	-- "Open chat sequence"
	if chatSequenceId ~= "" then
		--rootMenu:addLine(i18n.get("uiR2EDOpen").." "..chatSequence.Name, "lua", "r2:openMiniActivityChatSequence("..tostring(miniActivityNb)..")", "Open")
		rootMenu:addLine(i18n.get("uiR2EDOpen").." "..r2:getSequenceName(chatSequence), "lua", "r2:openMiniActivityChatSequence("..tostring(miniActivityNb)..")", "Open")
		newLine = newLine + 1
	end

	-- "Any chat sequence"
	rootMenu:addLine(i18n.get("uiR2EdNoChat"), "lua", "r2:setSequenceChatToMiniActivity("..tostring(miniActivityNb)..")", "None")


	-- "new chat sequence"
	rootMenu:addLine(i18n.get("uiR2EdNewChat").."...", "lua", "r2:newChatsSequenceAndSelect("..tostring(miniActivityNb)..")", "None")
	local menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2_icon_create.tga", size="14" })
	rootMenu:setUserGroupLeft(newLine, menuButton)

	rootMenu:addSeparator()

	local activeLogicEntity = r2:getSelectedInstance()
	assert(activeLogicEntity)

	for i=0, activeLogicEntity:getBehavior().ChatSequences.Size-1 do
		local sequence = activeLogicEntity:getBehavior().ChatSequences[i]
		assert(sequence)

		--rootMenu:addLine(sequence.Name, "lua", "r2:setSequenceChatToMiniActivity("..tostring(miniActivityNb)..", " .. tostring(i)..")", sequence.InstanceId)
		rootMenu:addLine(r2:getSequenceName(sequence), "lua", "r2:setSequenceChatToMiniActivity("..tostring(miniActivityNb)..", " .. tostring(i)..")", sequence.InstanceId)
	end

	-- display menu
	menu:updateCoords()	
	local ref = getUICaller()
	menu.y = ref.y_real - (menu.h - ref.h_real)
	menu.x = ref.x_real
	menu:updateCoords()	
end

function r2:openMiniActivityChatSequence(miniActivityNb, chatSequenceId)

	local activitySequence = r2:getSelectedSequInst("r2ed_triggers")
	assert(activitySequence)
	local activityInst = activitySequence.Components[miniActivityNb]

	if chatSequenceId == nil then
		chatSequenceId = tostring(activityInst.Chat)
	end

	r2:openChatSequence(chatSequenceId)
end

function r2:openChatSequence(chatSequenceId)

	if chatSequenceId == nil then
		chatSequenceId = r2:getSelectedEltInst("r2ed_triggers").Chat
	end

	local chatSequences = getUI("ui:interface:r2ed_chat_sequence")
	assert(chatSequences)

	local tab = chatSequences:find("sequence_tabs")
	assert(tab)

	local selectedTab
	local sequenceUI
	for i=0, tab.tabButtonNb-1 do
		sequence = tab:getGroup(i)
		assert(sequence)
		if sequence.Env.sequenceId == chatSequenceId then
			sequenceUI = sequence
			selectedTab = i
			break
		end
	end

	if selectedTab then 
		tab.selection = selectedTab 

		local repeatButton = chatSequences:find("repeat_group"):find("repeat"):find("toggle_butt")
		assert(repeatButton)

		local sequenceInstId = sequenceUI.Env.sequenceId
		local sequenceInst = r2:getInstanceFromId(sequenceInstId)

		repeatButton.pushed = (sequenceInst.Repeating == 0)
	end

	r2:openChatSequences()
end

function r2:newChatsSequenceAndSelect(miniActivityNb)
	local chatSequenceId = r2:newChatsSequence(true)
	
	if chatSequenceName ~= -1 then
		r2:setSequenceChatToMiniActivity(miniActivityNb, -1, chatSequenceId)
		r2:openMiniActivityChatSequence(miniActivityNb, chatSequenceId)
	end
end

function r2:setSequenceChatToMiniActivity(miniActivityNb, sequenceNb, chatSequenceId)

	local miniActivityView = getUI("ui:interface:r2ed_mini_activity_view")
	assert(miniActivityView)

	local miniActivities = miniActivityView:find("mini_activities")
	assert(miniActivities)

	local miniActivity = miniActivities[tostring(miniActivityNb)]
	assert(miniActivity)

	local activitySequence = r2:getSelectedSequInst("r2ed_triggers")
	assert(activitySequence)
	local activityInst = activitySequence.Components[miniActivityNb]

	local chatTexture

	if sequenceNb == nil then
		r2:selectChatSequence("None", activityInst.InstanceId)
		chatTexture = "r2_mini_activity_empty_chat.tga"
	else
		local activeLogicEntity = r2:getSelectedInstance()
		assert(activeLogicEntity)

		if chatSequenceId == nil then
			local chatSequence = activeLogicEntity:getBehavior().ChatSequences[tonumber(sequenceNb)]
			assert(chatSequence)
			chatSequenceId = chatSequence.InstanceId
		end

		r2:selectChatSequence(chatSequenceId, activityInst.InstanceId)

		chatTexture = "r2_mini_activity_chat.tga"
	end

	local chatButton = miniActivity:find("chat_sequence"):find("button")
	assert(chatButton)
	chatButton.texture = chatTexture
	chatButton.texture_pushed = chatTexture
	chatButton.texture_over = chatTexture
end

function r2:openActivity()

	r2:updateActivitiesAndChatsUI(r2:getSelectedInstance())

	local miniActivity = getUICaller().parent.parent.parent
	assert(miniActivity)

	local sequenceUI = r2:getSelectedSequ("r2ed_triggers")
	assert(sequenceUI)

	local activityList = sequenceUI:find("elements_list")
	assert(activityList)

	local eltEditor = activityList:find("edit_element")
	assert(eltEditor)
	local indexEltEditor = activityList:getElementIndex(eltEditor)
	
	local activityIndex = miniActivity.Env.id
	if indexEltEditor<=activityIndex then activityIndex=activityIndex+1 end

	local activityUI = activityList:getChild(activityIndex)
	assert(activityUI)

	local selectedButtonElt = activityUI:find("select")
	assert(selectedButtonElt)

	selectedButtonElt.pushed = true
	r2:selectTriggerElement(nil, "r2ed_triggers", selectedButtonElt)

	r2:updateActivityEditor()
	r2:openActivitiesSequence()
end

function r2:selectSequenceTab(uiName, index)

	if uiName == "r2ed_triggers" then
		r2:updateSequencesButtonBar(index)
	end

	local eltsUI = getUI("ui:interface:"..uiName)
	assert(eltsUI)

	local sequencesTab = eltsUI:find("sequence_tabs")
	assert(sequencesTab)

	local repeatButton = eltsUI:find("repeat_group"):find("repeat"):find("toggle_butt")
	assert(repeatButton)

	local sequenceUI = sequencesTab:getGroup(index)
	assert(sequenceUI)
	local sequenceInstId = sequenceUI.Env.sequenceId

	if sequenceInstId and r2:getInstanceFromId(sequenceInstId) then
		local sequenceInst = r2:getInstanceFromId(sequenceInstId)
		repeatButton.pushed = (sequenceInst.Repeating == 0)
	end
end



function r2:getSequenceName(sequenceInst)

	local name = sequenceInst.Name
	local index = -1
	if name == "" then
		local components = sequenceInst.Parent
		for i=0, components.Size-1 do
			if components[i].InstanceId == sequenceInst.InstanceId then
				index = i
				break
			end
		end

		if index >= 0 then
			local startName 
			if sequenceInst:isKindOf("ChatSequence") then
				startName = tostring(i18n.get("uiR2EdSequChat"))
			elseif sequenceInst:isKindOf("ActivitySequence") then
				startName = tostring(i18n.get("uiR2EdSeq"))
			end

			name = startName..(index+1)
		end
	end
	
	return name 
end





























