ryzom/common/data_common/r2/r2_ui_triggers.lua

   1 r2.maxActivities = 14
   2 r2.sequencesNb = 0
   3
   4 r2.TimeLimitsProp = {
   5                                                 [tostring(i18n.get("uiR2EdNoTimeLimit"))]="No Limit",
   6                                                 --["Until a certain time"]="Until",
   7                                                 [tostring(i18n.get("uiR2EdWhileChat"))]="Chat",
   8                                                 [tostring(i18n.get("uiR2EdForCertainTime"))]="Few Sec"
   9                                     }
  10 r2.TimeLimitsCB =   {
  11                                                 ["No Limit"]=tostring(i18n.get("uiR2EdNoTimeLimit")),
  12                                                 --["Until"]="Until a certain time",
  13                                                 ["Chat"]=tostring(i18n.get("uiR2EdWhileChat")),
  14                                                 ["Few Sec"]=tostring(i18n.get("uiR2EdForCertainTime")),
  15                                     }
  16
  17 r2.activityTypeMenu =   {
  18                                                         ["Inactive"]=tostring(i18n.get("uiR2EdInactive")),
  19                                                         ["Stand Still"]=tostring(i18n.get("uiR2EdStandStill")),
  20                                                         ["Follow Route"]=tostring(i18n.get("uiR2EdFollowRoad")),
  21                                                         ["Patrol"]=tostring(i18n.get("uiR2EdPatrol")),
  22                                                         ["Repeat Road"]=tostring(i18n.get("uiR2EdRepeatRoad")),
  23                                                         --["Deploy"]=tostring(i18n.get("uiR2EdDeploy")),
  24                                                         ["Wander"]=tostring(i18n.get("uiR2EdWander")),
  25                                                         ["Stand On Start Point"]=tostring(i18n.get("uiR2EdStandOnStartPoint")),
  26                                                         ["Go To Start Point"]=tostring(i18n.get("uiR2EdGoToStartPoint")),
  27                                                         ["Go To Zone"]=tostring(i18n.get("uiR2EdGoToZone")),
  28                                                         ["Sit Down"]=tostring(i18n.get("uiR2EdSitDown")),
  29                                                         ["Stand Up"]=tostring(i18n.get("uiR2EdStandUp")),
  30
  31                                                 }
  32
  33 r2.fromNPCNameToId = {}
  34 r2.fromEmoteIdToName = {}
  35
  36 r2.ownCreatedInstances = {}
  37
  38
  39 ------------------ INIT TRIGGERS EDITOR ----------------------------------------------------------------
  40 function r2:initTriggersEditor()
  41
  42         -- emote
  43         local menuName = "ui:interface:r2ed_triggers_menu"
  44         local emoteMenu = getUI(menuName)
  45         local emoteMenu = emoteMenu:getRootMenu()
  46         assert(emoteMenu)
  47         emoteMenu:reset()
  48
  49         local emoteTable = initEmotesMenu(menuName, "")
  50         for id, name in pairs(emoteTable) do
  51                 r2.fromEmoteIdToName[id] = name
  52         end
  53 end
  54
  55 ------------------ INIT TRIGGERS EDITOR ----------------------------------------------------------------
  56 function r2:initActivityEditor(activityEditor)
  57
  58         -- time limit
  59         local timeLimitCB = activityEditor:find("time_limit"):find("combo_box")
  60         assert(timeLimitCB)
  61         timeLimitCB:resetTexts()
  62         timeLimitCB:addText(ucstring(i18n.get("uiR2EdNoTimeLimit")))
  63         --timeLimitCB:addText(ucstring("Until a certain time"))
  64         timeLimitCB:addText(ucstring(i18n.get("uiR2EdForCertainTime")))
  65         timeLimitCB:addText(ucstring(i18n.get("uiR2EdWhileChat")))
  66 end
  67
  68 ----------------------------------------------------------------------------------------------------
  69 function r2:getSelectedEltUI(uiName)
  70         local id = r2:getSelectedEltUIId(uiName)
  71         if id then
  72                 return getUI(id)
  73         else
  74                 return nil
  75         end
  76 end
  77
  78 ----------------------------------------------------------------------------------------------------
  79 function r2:getSelectedEltUIId(uiName)
  80
  81         if uiName == nil then
  82                 dumpCallStack(1)
  83                 assert(false)
  84         end
  85         local windowUI = getUI("ui:interface:"..uiName)
  86         assert(windowUI)
  87
  88         return windowUI.Env.selectedElementId
  89 end
  90
  91 ----------------------------------------------------------------------------------------------------
  92 function r2:setSelectedEltUIId(uiName, eltUIId)
  93         local windowUI = getUI("ui:interface:"..uiName)
  94         assert(windowUI)
  95
  96         windowUI.Env.selectedElementId = eltUIId
  97 end
  98
  99 ----------------------------------------------------------------------------------------------------
 100 function r2:getSelectedEltInstId(uiName)
 101
 102         local element = r2:getSelectedEltUI(uiName)
 103         if element ~= nil then
 104                 return element.Env.elementId
 105         else
 106                 return nil
 107         end
 108 end
 109
 110 ----------------------------------------------------------------------------------------------------
 111 function r2:setSelectedEltInstId(uiName, instId)
 112         local element = r2:getSelectedEltUI(uiName)
 113         assert(element)
 114         element.Env.elementId = instId
 115 end
 116
 117 ----------------------------------------------------------------------------------------------------
 118 function r2:getSelectedEltInst(uiName)
 119         local id = r2:getSelectedEltInstId(uiName)
 120         if id then
 121                 return r2:getInstanceFromId(id)
 122         else
 123                 return nil
 124         end
 125 end
 126
 127 ----------------------------------------------------------------------------------------------------
 128 function r2:getSelectedSequInstId(uiName)
 129         local windowUI = getUI("ui:interface:"..uiName)
 130         assert(windowUI)
 131
 132         local tab = windowUI:find("sequence_tabs")
 133         assert(tab)
 134
 135         local sequence = windowUI:find(tab.associatedGroupSelection)
 136         assert(sequence)
 137
 138         if sequence.Env == nil then return nil end
 139
 140         return sequence.Env.sequenceId
 141 end
 142
 143 ----------------------------------------------------------------------------------------------------
 144 function r2:getSelectedSequInst(uiName)
 145         local id = r2:getSelectedSequInstId(uiName)
 146         if id then
 147                 return r2:getInstanceFromId(id)
 148         else
 149                 return nil
 150         end
 151 end
 152
 153 ----------------------------------------------------------------------------------------------------
 154 function r2:getSelectedSequ(uiName)
 155         local windowUI = getUI("ui:interface:"..uiName)
 156         assert(windowUI)
 157
 158         local tab = windowUI:find("sequence_tabs")
 159
 160         if tab~=nil then
 161                 local associatedGroup = tab.associatedGroupSelection
 162                 if associatedGroup == "" then
 163                         return nil
 164                 end
 165
 166                 local sequence = windowUI:find(associatedGroup)
 167                 assert(sequence)
 168
 169                 return sequence
 170         else
 171                 return windowUI:find("sequence_elts")
 172         end
 173 end
 174
 175 ----------------------------------------------------------------------------------------------------
 176 function r2:setSelectedSequInstId(uiName, instanceId)
 177
 178         local windowUI = getUI("ui:interface:"..uiName)
 179         assert(windowUI)
 180
 181         local tab = windowUI:find("sequence_tabs")
 182         assert(tab)
 183
 184         local sequence = windowUI:find(tab.associatedGroupSelection)
 185         assert(sequence)
 186
 187         sequence.Env.sequenceId = instanceId
 188 end
 189
 190 ------------------ CLOSE ALL UI --------------------------------------------------------------------
 191 function r2:closeActivitySequenceUI()
 192
 193         local window = getUI("ui:interface:r2ed_edit_activity_sequence")
 194         if window~=nil then
 195                 window.active = false
 196
 197                 r2:openAndUpdateMiniActivityView()
 198         end
 199 end
 200
 201 ------------------ NEW SEQUENCE --------------------------------------------------------------------
 202 function r2:newActivitiesSequence(firstRequest, activitySequence, reset)
 203
 204
 205         local triggersUI = getUI("ui:interface:r2ed_triggers")
 206         assert(triggersUI)
 207
 208         local tab = triggersUI:find("sequence_tabs")
 209         assert(tab)
 210
 211         if firstRequest and tab.tabButtonNb == 7 then return -1 end
 212
 213         if firstRequest == true then
 214                 activitySequence = r2.newComponent("ActivitySequence")
 215
 216                 --local name = tostring(i18n.get("uiR2EdSeq"))..tab.tabButtonNb+1
 217                 --activitySequence.Name = name
 218
 219                 local npcGroup = r2:getSelectedInstance()
 220                 assert(npcGroup)
 221
 222                 r2.requestInsertNode(npcGroup:getBehavior().InstanceId, "Activities", -1, "", activitySequence)
 223 --              r2.requestInsertNode(npcGroup.InstanceId,"ActivitiesId",-1,"",activitySequence.InstanceId)
 224 --              r2.requestInsertNode(r2:getCurrentAct().InstanceId,"ActivitiesIds",-1,"",activitySequence.InstanceId)
 225
 226                 r2.ownCreatedInstances[activitySequence.InstanceId] = true
 227
 228                 return activitySequence.InstanceId
 229         else
 230
 231                 local updateMiniActivityView = r2.ownCreatedInstances[activitySequence.InstanceId]
 232                 if reset then
 233                         r2.ownCreatedInstances[activitySequence.InstanceId] = true
 234                 end
 235
 236                 local templateParams = {
 237                                                                         newElt="r2:newActivity(true)",
 238                                                                         newEltText=tostring(i18n.get("uiR2EdNewActivity")),
 239                                                                         eltOrderText=tostring(i18n.get("uiR2EdActivityOrder")),
 240                                                                         upElt="r2:upActivity()",
 241                                                                         downElt="r2:downActivity()",
 242                                                                         maxMinElts="r2:maximizeMinimizeActivities()",
 243                                                                         downUpColor="200 120 80 255",
 244                                                                         colPushed = "200 80 80 255",
 245                                                                         paramsL= "r2:selectSequenceTab('r2ed_triggers', "..tostring(tab.tabButtonNb)..")"
 246                                                            }
 247
 248                 local editorEltTemplate = "template_edit_activity"
 249                 local sequence = r2:newElementsSequence("r2ed_triggers", templateParams, editorEltTemplate,
 250                         activitySequence, tostring(i18n.get("uiR2EdSeq")))
 251                 r2:initActivityEditor(sequence:find("edit_element"))
 252
 253                 local activities = activitySequence.Components
 254                 for a = 0, activities.Size - 1 do
 255                         r2:newActivity(false, nil, activities[a])
 256                 end
 257
 258                 -- new MiniActivity sequence
 259                 if updateMiniActivityView==true then
 260                         --r2:updateSequencesButtonBar(tab.tabButtonNb-1, activitySequence.Name)
 261                         r2:updateSequencesButtonBar(tab.tabButtonNb-1, r2:getSequenceName(activitySequence))
 262                         r2:openAndUpdateMiniActivityView()
 263                 end
 264         end
 265 end
 266
 267 ------------------ REMOVE SEQUENCE -----------------------------------------------------------------
 268 function r2:removeActivitiesSequence()
 269
 270         local sequenceId = r2:removeElementsSequence("r2ed_triggers", "Activities", tostring(i18n.get("uiR2EdSeq")))
 271
 272 --      local group = r2:getSelectedInstance()
 273 --      assert(group)
 274 --      local sequenceIndex = -1
 275 --      for i=0,group.ActivitiesId.Size-1 do
 276 --              if group.ActivitiesId[i] == sequenceId then
 277 --                      sequenceIndex = i
 278 --                      break
 279 --              end
 280 --      end
 281 --      if sequenceIndex ~= -1 then
 282 --              r2.requestEraseNode(group.InstanceId, "ActivitiesId", sequenceIndex)
 283 --      end
 284 --
 285 --      local currentAct = r2:getCurrentAct()
 286 --      sequenceIndex = -1
 287 --      for i=0,currentAct.ActivitiesIds.Size-1 do
 288 --              if currentAct.ActivitiesIds[i] == sequenceId then
 289 --                      sequenceIndex = i
 290 --                      break
 291 --              end
 292 --      end
 293 --      if sequenceIndex ~= -1 then
 294 --              r2.requestEraseNode(currentAct.InstanceId, "ActivitiesIds", sequenceIndex)
 295 --      end
 296 end
 297
 298 function r2:removeActivitiesSequenceUI(tabIndex)
 299         local firstEltName = r2:removeElementsSequenceUI(tabIndex, "r2ed_triggers", "Activities", tostring(i18n.get("uiR2EdSeq")))
 300
 301         r2:updateSequencesButtonBar(0, firstEltName)
 302 end
 303
 304 ------------------ SELECT ACTIVITY ------------------------------------------------------------------
 305 function r2:selectActivity()
 306         r2:selectTriggerElement(nil, "r2ed_triggers")
 307
 308         if getUICaller().pushed == true then
 309                 r2:updateActivityEditor()
 310         end
 311 end
 312
 313 ------------------ NEW ACTIVITY --------------------------------------------------------------------
 314 function r2:newActivity(firstRequest, tableInit, instanceElement, sequenceUI, sequenceInstId)
 315
 316
 317
 318         local uiName = "r2ed_triggers"
 319
 320         if sequenceUI == nil then
 321                 sequenceUI = r2:getSelectedSequ(uiName)
 322         end
 323         local activityList
 324         if sequenceUI~=nil then
 325                 activityList = sequenceUI:find("elements_list")
 326                 assert(activityList)
 327
 328                 if activityList.childrenNb-1 == r2.maxActivities then return false end
 329         end
 330
 331         if firstRequest == true then
 332
 333                 instanceElement = r2.newComponent("ActivityStep")
 334
 335                 if tableInit ~= nil then
 336                         instanceElement.Activity = tableInit.Activity
 337                         instanceElement.ActivityZoneId = r2.RefId(tableInit.ActivityZoneId)
 338                         instanceElement.TimeLimit = tableInit.TimeLimit
 339                         instanceElement.TimeLimitValue = tableInit.TimeLimitValue
 340                 else
 341                         instanceElement.TimeLimit = "No Limit"
 342                         instanceElement.Activity = "Stand Still"
 343                 end
 344
 345                 if sequenceInstId == nil then
 346                         sequenceInstId = r2:getSelectedSequInstId(uiName)
 347                 end
 348                 assert(sequenceInstId)
 349
 350                 r2.requestInsertNode(sequenceInstId, "Components", -1, "", instanceElement)
 351
 352                 r2.ownCreatedInstances[instanceElement.InstanceId] = true
 353         else
 354
 355                 local templateParams =  {
 356                                                                 selectElt="r2:selectActivity()",
 357                                                                 openEltEditor="r2:openActivityEditor()",
 358                                                                 maxMinElt="r2:maximizeMinimizeActivity()",
 359                                                                 removeElt="r2:removeActivity()",
 360                                                                 colOver="200 120 80 120",
 361                                                                 colPushed="200 120 80 255"
 362                                                                 }
 363
 364                 local element = r2:newTriggerElement(uiName, tostring(i18n.get("uiR2EdActivity")), templateParams, sequenceUI, instanceElement.InstanceId)
 365
 366                 r2:updateActivityChatSequence(element)
 367
 368                 -- active chat button if a chat sequence is associated to this activity
 369                 if instanceElement.Chat ~= "" then
 370
 371                         local activityEditor = sequenceUI:find("edit_element")
 372                         assert(activityEditor)
 373                         local chatButtonEditor = activityEditor:find("open_chat_sequence")
 374                         assert(chatButtonEditor)
 375
 376                         chatButtonEditor.active = true
 377                 end
 378         end
 379
 380         return true
 381 end
 382
 383
 384 function r2:buildActivityTitle(activityUI, erase)
 385
 386         local activityInst = r2:getInstanceFromId(activityUI.Env.elementId)
 387         assert(activityInst)
 388
 389         -- part1
 390         local index = r2:searchElementIndex(activityInst)
 391         if erase==true then index = index-1 end
 392         local part1 = tostring(i18n.get("uiR2EdActivity")).." "..index.." : "
 393
 394         -- part2
 395         if  not r2.activityTypeMenu[activityInst.Activity] then
 396                 debugInfo(colorTag(255,0,0).."The activity '".. activityInst.Activity.."' is not properly registred")
 397         end
 398
 399         local part2 = r2.activityTypeMenu[activityInst.Activity].." "
 400         if activityInst.ActivityZoneId~= "" then
 401                 local place = r2:getInstanceFromId(tostring(activityInst.ActivityZoneId))
 402                 if place~=nil then
 403                         part2 = part2.. place.Name .." "
 404                 end
 405         end
 406
 407         -- part3
 408         local part3 = ""
 409         if activityInst.TimeLimit == "Few Sec" then
 410
 411                 local hourNb, minNb, secNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
 412
 413                 local timeLimitText = tostring(i18n.get("uiR2EdFor")) .. " "
 414                 if hourNb ~= 0 then timeLimitText = timeLimitText .. hourNb .. tostring(i18n.get("uiR2EdShortHours")) .. " " end
 415                 if minNb ~= 0 then timeLimitText = timeLimitText .. minNb .. tostring(i18n.get("uiR2EdShortMinutes")) .. " " end
 416                 timeLimitText = timeLimitText .. secNb .. tostring(i18n.get("uiR2EdShortSeconds"))
 417
 418                 part3 = timeLimitText
 419
 420         elseif r2.TimeLimitsCB[activityInst.TimeLimit] ~= nil then
 421                 part3 = string.lower(r2.TimeLimitsCB[activityInst.TimeLimit])
 422         end
 423
 424         -- title
 425         local title = activityUI:find("title")
 426         assert(title)
 427         title.uc_hardtext= part1..part2..part3
 428 end
 429
 430 function r2:getActivityName(activityInst)
 431
 432         -- part1
 433         local index = r2:searchElementIndex(activityInst)
 434         if erase==true then index = index-1 end
 435         local part1 = tostring(i18n.get("uiR2EdActivity")).." "..index.." : "
 436
 437         -- part2
 438         if  not r2.activityTypeMenu[activityInst.Activity] then
 439                 debugInfo(colorTag(255,0,0).."The activity '".. activityInst.Activity.."' is not properly registred")
 440         end
 441
 442         local part2 = r2.activityTypeMenu[activityInst.Activity].." "
 443         if activityInst.ActivityZoneId~= "" then
 444                 local place = r2:getInstanceFromId(tostring(activityInst.ActivityZoneId))
 445                 if place~=nil then
 446                         part2 = part2.. place.Name .." "
 447                 end
 448         end
 449
 450         -- part3
 451         local part3 = ""
 452         if activityInst.TimeLimit == "Few Sec" then
 453
 454                 local hourNb, minNb, secNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
 455
 456                 local timeLimitText = tostring(i18n.get("uiR2EdFor")) .. " "
 457                 if hourNb ~= 0 then timeLimitText = timeLimitText .. hourNb .. tostring(i18n.get("uiR2EdShortHours")) .. " " end
 458                 if minNb ~= 0 then timeLimitText = timeLimitText .. minNb .. tostring(i18n.get("uiR2EdShortMinutes")) .. " " end
 459                 timeLimitText = timeLimitText .. secNb .. tostring(i18n.get("uiR2EdShortSeconds"))
 460
 461                 part3 = timeLimitText
 462
 463         elseif r2.TimeLimitsCB[activityInst.TimeLimit] ~= nil then
 464                 part3 = string.lower(r2.TimeLimitsCB[activityInst.TimeLimit])
 465         end
 466
 467         return part1..part2..part3
 468 end
 469
 470 function r2:getElementName(elementInst)
 471
 472         if elementInst:isKindOf("ActivityStep") then
 473                 return r2:getActivityName(elementInst)
 474         elseif elementInst:isKindOf("ChatStep") then
 475                 return r2:getChatName(elementInst)
 476         elseif elementInst:isKindOf("LogicEntityAction") then
 477                 return r2:getActionName(elementInst)
 478         elseif elementInst:isKindOf("LogicEntityReaction") then
 479                 return r2:getReactionName(elementInst)
 480         elseif elementInst:isKindOf("ChatSequence") or elementInst:isKindOf("ActivitySequence") then
 481                 return r2:getSequenceName(elementInst)
 482         end
 483
 484         return ""
 485 end
 486
 487 function r2:updateActivityChatSequence(elementUI, canceledChatStepId)
 488
 489         if elementUI == nil then
 490                 elementUI = r2:getSelectedEltUI("r2ed_triggers")
 491         end
 492         assert(elementUI)
 493
 494         local instance = r2:getInstanceFromId(elementUI.Env.elementId)
 495         assert(instance)
 496
 497         local chatSequence = r2:getInstanceFromId(tostring(instance.Chat))
 498
 499         local activityText = elementUI:find("text_list")
 500         assert(activityText)
 501
 502         local sep = elementUI:find("sep")
 503         assert(sep)
 504
 505         activityText:clear()
 506
 507         if chatSequence ~= nil then
 508                 local counterTime = 0
 509
 510                 if chatSequence.Components.Size > 0 then
 511
 512                         local emptyText = true
 513
 514                         activityText:addColoredTextChild("\n"..tostring(i18n.get("uiR2EdSequenceStart")), 255, 175, 135, 255)
 515
 516                         for c = 0, chatSequence.Components.Size - 1 do
 517                                 local chat = chatSequence.Components[c]
 518
 519                                 if chat.InstanceId ~= canceledChatStepId then
 520                                         counterTime = counterTime + tonumber(chat.Time)
 521
 522                                         local firstLine = true
 523
 524                                         local who = tostring(chat.Actions[0].Who)
 525                                         if who ~= "" then
 526
 527                                                 local facing = tostring(chat.Actions[0].Facing)
 528                                                 local emote = chat.Actions[0].Emote
 529                                                 local says = chat.Actions[0].Says
 530
 531                                                 local minNb, secNb = r2:calculMinSec(counterTime)
 532                                                 local countInfo = "*"
 533                                                 if minNb ~= 0 then
 534                                                         countInfo = countInfo..tostring(minNb)..tostring(i18n.get("uiR2EdShortMinutes"))
 535                                                 end
 536                                                 countInfo = countInfo.." "..tostring(secNb)..tostring(i18n.get("uiR2EdShortSeconds"))..":"
 537
 538                                                 if facing ~= "" then
 539                                                         facing = r2:getInstanceFromId(who).Name .. " "..tostring(i18n.get("uiR2EdFaces")).." " .. r2:getInstanceFromId(facing).Name
 540                                                         if firstLine then
 541                                                                 activityText:addColoredTextChild(countInfo, 220, 140, 100, 255)
 542                                                                 firstLine = false
 543                                                         end
 544                                                         activityText:addTextChild(ucstring(facing))
 545                                                         emptyText = false
 546                                                 end
 547                                                 if r2.fromEmoteIdToName[emote] ~= nil then
 548                                                         emote = r2:getInstanceFromId(who).Name .. " "..string.lower(tostring(i18n.get("uiR2EdEmote"))).." : " .. r2.fromEmoteIdToName[emote]
 549                                                         if firstLine then
 550                                                                 activityText:addColoredTextChild(countInfo, 220, 140, 100, 255)
 551                                                                 firstLine = false
 552                                                         end
 553                                                         activityText:addTextChild(ucstring(emote))
 554                                                         emptyText = false
 555                                                 end
 556                                                 if r2:getInstanceFromId(says)~=nil and r2:getInstanceFromId(says).Text ~= "" then
 557                                                         says = r2:getInstanceFromId(who).Name .. " "..tostring(i18n.get("uiR2EdSays")).." : " .. r2:getInstanceFromId(says).Text
 558                                                         if firstLine then
 559                                                                 activityText:addColoredTextChild(countInfo, 220, 140, 100, 255)
 560                                                                 firstLine = false
 561                                                         end
 562                                                         activityText:addTextChild(ucstring(says))
 563                                                         emptyText = false
 564                                                 end
 565                                         end
 566                                 end
 567                         end
 568
 569                         if emptyText == true then
 570                                 activityText:clear()
 571                                 sep.active = false
 572                         else
 573                                 sep.active = true
 574
 575                                 local hourNb, minNb, secNb = r2:calculHourMinSec(counterTime)
 576                                 local totalChatTime = ""
 577                                 if hourNb ~= 0 then
 578                                         totalChatTime = tostring(hourNb)..tostring(i18n.get("uiR2EdShortHours"))
 579                                 end
 580                                 if minNb ~= 0 then
 581                                         totalChatTime = totalChatTime.." "..tostring(minNb)..tostring(i18n.get("uiR2EdShortMinutes"))
 582                                 end
 583                                 totalChatTime = totalChatTime.." "..tostring(secNb)..tostring(i18n.get("uiR2EdShortSeconds"))
 584                                 activityText:addColoredTextChild(tostring(i18n.get("uiR2EdSequenceEnd")).." (".. totalChatTime ..")\n", 255, 175, 135, 255)
 585                         end
 586                 end
 587         else
 588                 sep.active = false
 589         end
 590
 591         --update title
 592         r2:buildActivityTitle(elementUI, false)
 593
 594         if r2:getSelectedEltInstId("r2ed_triggers") == instance.InstanceId then
 595                 local eltEditor = r2:getSelectedSequ("r2ed_triggers"):find("edit_element")
 596                 assert(eltEditor)
 597                 r2:updateActivityEditor()
 598         end
 599
 600         r2:updateMiniActivityView()
 601 end
 602
 603 function r2:updateActivitiesWhithThisChatSequence(chatStep, canceled)
 604
 605         local chatSequenceId = chatStep.Parent.Parent.InstanceId
 606
 607         local chatStepId = nil
 608         if canceled == true then chatStepId = chatStep.InstanceId end
 609
 610         local triggersUI = getUI("ui:interface:r2ed_triggers")
 611         assert(triggersUI)
 612
 613         local tab = triggersUI:find("sequence_tabs")
 614         assert(tab)
 615
 616         for s = 0,tab.tabButtonNb-1 do
 617                 local activitySequence = tab:getGroup(s)
 618                 assert(activitySequence)
 619
 620                 local activityList = activitySequence:find("elements_list")
 621                 assert(activityList)
 622
 623                 for a=0, activityList.childrenNb-1 do
 624                         local activity = activityList:getChild(a)
 625                         assert(activity)
 626
 627                         if activity.Env.elementId~=nil then
 628                                 local activityInst = r2:getInstanceFromId(activity.Env.elementId)
 629                                 assert(activityInst)
 630                                 if tostring(activityInst.Chat) == chatSequenceId then
 631                                         r2:updateActivityChatSequence(activity, chatStepId)
 632                                 end
 633                         end
 634                 end
 635         end
 636 end
 637
 638 ------------------ REMOVE ACTIVITY ------------------------------------------------------------------
 639 function r2:removeActivity()
 640         r2:removeTriggerElement("r2ed_triggers", tostring(i18n.get("uiR2EdActivity")))
 641 end
 642
 643 function r2:removeActivityUI(sequenceUI, elementUI)
 644
 645         r2:removeElementUI(sequenceUI, "r2ed_triggers", elementUI)
 646         r2:closeActivitySequenceUI()
 647
 648         local activityList = sequenceUI:find("elements_list")
 649         assert(activityList)
 650 end
 651
 652 ------------------ UP ACTIVITY -----------------------------------------------------------------------
 653 function r2:upActivity()
 654         r2:upTriggerElement("r2ed_triggers")
 655 end
 656
 657 ------------------ DOWN ACTIVITY ---------------------------------------------------------------------
 658 function r2:downActivity()
 659         r2:downTriggerElement("r2ed_triggers")
 660 end
 661
 662 ------------------ MAXIMIZE MINIMIZE ACTIVITIES ------------------------------------------------------
 663 function r2:maximizeMinimizeActivities()
 664         r2:maximizeMinimizeTriggerElements("r2ed_triggers")
 665 end
 666
 667 ------------------ MAXIMIZE MINIMIZE ACTIVITY ------------------------------------------------------
 668 function r2:maximizeMinimizeActivity()
 669         r2:maximizeMinimizeElement("r2ed_triggers")
 670 end
 671
 672 ------------------ OPEN ACTIVITY EDITOR ----------------------------------------------------------------
 673 function r2:openActivityEditor()
 674         r2:updateActivityEditor()
 675         r2:openElementEditor("r2ed_triggers", "uiR2EDActivityStepEditor")
 676 end
 677
 678 function r2:updateActivityEditor()
 679
 680         local uiName = "r2ed_triggers"
 681         local instanceActivity = r2:getSelectedEltInst(uiName)
 682
 683         local activityEditor = r2:getSelectedSequ(uiName):find("edit_element")
 684         assert(activityEditor)
 685
 686         -- activity name
 687         local activityName = activityEditor:find("name")
 688         assert(activityName)
 689
 690         -- activity type
 691         local activityButtonText = activityEditor:find("activity"):find("text")
 692         assert(activityButtonText)
 693
 694         -- time limit
 695         local comboBox = activityEditor:find("time_limit").combo_box
 696         assert(comboBox)
 697
 698         -- chat sequence
 699         local chatMenuButton = activityEditor:find("chat_script"):find("menu"):find("text")
 700         assert(chatMenuButton)
 701
 702         local chatButtonEditor = activityEditor:find("open_chat_sequence")
 703         assert(chatButtonEditor)
 704
 705         if instanceActivity then
 706
 707                 local index = r2:searchElementIndex(instanceActivity)
 708                 if index~= nil then
 709                         activityName.uc_hardtext = tostring(i18n.get("uiR2EdActivity")).." "..index.." : "
 710                 else
 711                         activityName.uc_hardtext = tostring(i18n.get("uiR2EdActivity")).." : "
 712                 end
 713
 714                 -- activity type
 715                 local activityText = r2.activityTypeMenu[instanceActivity.Activity]
 716                 if activityText then
 717                         activityButtonText.uc_hardtext = activityText
 718                 end
 719                 if instanceActivity.ActivityZoneId ~= "" then
 720                         local place = r2:getInstanceFromId(instanceActivity.ActivityZoneId)
 721                         assert(place)
 722
 723                         activityButtonText.uc_hardtext = activityButtonText.hardtext .. " " .. place.Name
 724                 end
 725
 726                 -- time limit
 727                 local timeLimit = instanceActivity.TimeLimit
 728
 729                 local certainTime = activityEditor:find("certain_time")
 730                 assert(certainTime)
 731
 732                 comboBox.Env.locked = true
 733                 if timeLimit == "Few Sec" then
 734                         local timeLimitValue = tonumber(instanceActivity.TimeLimitValue)
 735
 736                         if timeLimitValue ~= nil then
 737
 738                                 local hoursNb, minNb, secNb = r2:calculHourMinSec(timeLimitValue)
 739
 740                                 local timeLimitText = tostring(i18n.get("uiR2EdFor")) .. " "
 741                                 if hoursNb ~= 0 then timeLimitText = timeLimitText .. hoursNb .. tostring(i18n.get("uiR2EdShortHours")) .. " " end
 742                                 if minNb ~= 0 then timeLimitText = timeLimitText .. minNb .. tostring(i18n.get("uiR2EdShortMinutes")) .. " " end
 743                                 timeLimitText = timeLimitText .. secNb .. tostring(i18n.get("uiR2EdShortSeconds"))
 744
 745                                 certainTime.active = true
 746                                 local hoursMenu = certainTime:find("hours"):find("text")
 747                                 assert(hoursMenu)
 748                                 hoursMenu.uc_hardtext = tostring(hoursNb)
 749
 750                                 local minutesMenu = certainTime:find("minutes"):find("text")
 751                                 assert(minutesMenu)
 752                                 minutesMenu.uc_hardtext = tostring(minNb)
 753
 754                                 local secondsMenu = certainTime:find("seconds"):find("text")
 755                                 assert(secondsMenu)
 756                                 secondsMenu.uc_hardtext = tostring(secNb)
 757
 758                                 comboBox.view_text = timeLimitText
 759                         end
 760                 else
 761                         certainTime.active = false
 762                         timeLimit = r2.TimeLimitsCB[timeLimit]
 763                         if timeLimit~= nil then
 764                                 comboBox.selection_text = timeLimit
 765                         end
 766                 end
 767                 comboBox.Env.locked = false
 768
 769                 -- chat sequence  TEMP TEMP TEMP TEMP
 770                 local sequenceChat = r2:getInstanceFromId(tostring(instanceActivity.Chat))
 771                 local repeatLabelButton = activityEditor:find("repeat")
 772                 assert(repeatLabelButton)
 773
 774                 if sequenceChat ~= nil then
 775                         --chatMenuButton.uc_hardtext = sequenceChat.Name
 776                         chatMenuButton.uc_hardtext = r2:getSequenceName(sequenceChat)
 777
 778                         repeatLabelButton.active = true
 779                         local repeatButton = repeatLabelButton:find("toggle_butt")
 780                         assert(repeatButton)
 781                         repeatButton.pushed = not (instanceActivity.Type == "Repeating")
 782
 783                         chatButtonEditor.active = true
 784                 else
 785                         repeatLabelButton.active = false
 786                         chatMenuButton.uc_hardtext = i18n.get("uiR2EdNoElt")
 787
 788                         chatButtonEditor.active = false
 789                 end
 790                 -- TEMP TEMP TEMP
 791
 792         else
 793
 794                 local name = tostring(i18n.get("uiR2EdActivity")).." : "
 795                 activityName.uc_hardtext = name
 796
 797                 activityButtonText.uc_hardtext = i18n.get("uiR2EdStandStill")
 798                 comboBox.selection_text = i18n.get("uiR2EdNoTimeLimit")
 799                 chatMenuButton.uc_hardtext = i18n.get("uiR2EdNoElt")
 800
 801                 chatButtonEditor.active = false
 802         end
 803 end
 804
 805 ------------------ REPEAT ACTIVITY SEQUENCE -------------------------------------------------------------
 806 function r2:repeatActivitySequence()
 807         r2.requestNewAction(i18n.get("uiR2EDRepeatActivitySequenceAction"))
 808
 809         local sequenceInstId = r2:getSelectedSequInstId("r2ed_triggers")
 810         assert(sequenceInstId)
 811
 812         local sequenceType = not getUICaller().pushed
 813         if sequenceType==false then sequenceType=0 else sequenceType=1 end
 814
 815         r2.requestSetNode(sequenceInstId, "Repeating", sequenceType)
 816 end
 817
 818 ------------------ CLOSE ACTIVITY EDITOR ----------------------------------------------------------------
 819 function r2:closeChatSequencesUI()
 820
 821         local window = getUI("ui:interface:r2ed_chat_sequence")
 822         assert(window)
 823         window.active = false
 824
 825         window = getUI("ui:interface:r2ed_edit_chat_sequence")
 826         assert(window)
 827         window.active = false
 828 end
 829
 830 ------------------ OPEN ACTIVITY MENU -------------------------------------------------------------------
 831 function r2:openActivityMenu()
 832
 833         local menuName = "ui:interface:r2ed_triggers_menu"
 834         local activityMenu = getUI(menuName)
 835         local activityMenu = activityMenu:getRootMenu()
 836         assert(activityMenu)
 837         activityMenu:reset()
 838
 839         -- Inactive
 840 --      activityMenu:addLine(ucstring(i18n.get("uiR2EdInactive")), "lua", "r2:setActivity('Inactive')", "Inactive")
 841
 842         -- Stand still
 843         activityMenu:addLine(ucstring(i18n.get("uiR2EdStandStill")), "lua", "r2:setActivity('Stand Still')", "Stand Still")
 844
 845         -- Follow route
 846         activityMenu:addLine(ucstring(i18n.get("uiR2EdFollowRoad")), "", "", "Follow Route")
 847         local menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_road.tga", size="14" })
 848         activityMenu:setUserGroupLeft(1, menuButton)
 849         activityMenu:addSubMenu(1)
 850         local roadsMenu = activityMenu:getSubMenu(1)
 851         local roadsTable = r2.Scenario:getAllInstancesByType("Road")
 852         for key, road in pairs(roadsTable) do
 853                 roadsMenu:addLine(ucstring(road.Name), "lua", "r2:setActivity('Follow Route', '".. road.InstanceId .."')", road.InstanceId)
 854         end
 855         if table.getn(roadsTable) == 0 then
 856                 roadsMenu:addLine(ucstring(i18n.get("uiR2EdNoSelelection")), "lua", "r2:setActivity()", "")
 857         end
 858
 859         -- Patrol
 860         activityMenu:addLine(ucstring(i18n.get("uiR2EdPatrol")), "", "", "Patrol")
 861         menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_road.tga", size="14"})
 862         activityMenu:setUserGroupLeft(2, menuButton)
 863         activityMenu:addSubMenu(2)
 864         roadsMenu = activityMenu:getSubMenu(2)
 865         for key, road in pairs(roadsTable) do
 866                 roadsMenu:addLine(ucstring(road.Name), "lua", "r2:setActivity('Patrol', '".. road.InstanceId .."')", road.InstanceId)
 867         end
 868         if table.getn(roadsTable) == 0 then
 869                 roadsMenu:addLine(ucstring(i18n.get("uiR2EdNoSelelection")), "lua", "r2:setActivity()", "")
 870         end
 871
 872         -- Repeat Road
 873         activityMenu:addLine(ucstring(i18n.get("uiR2EdRepeatRoad")), "", "", "Repeat Road")
 874         menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_road.tga", size="14"})
 875         activityMenu:setUserGroupLeft(3, menuButton)
 876         activityMenu:addSubMenu(3)
 877         roadsMenu = activityMenu:getSubMenu(3)
 878         for key, road in pairs(roadsTable) do
 879                 roadsMenu:addLine(ucstring(road.Name), "lua", "r2:setActivity('Repeat Road', '".. road.InstanceId .."')", road.InstanceId)
 880         end
 881         if table.getn(roadsTable) == 0 then
 882                 roadsMenu:addLine(ucstring(i18n.get("uiR2EdNoSelelection")), "lua", "r2:setActivity()", "")
 883         end
 884
 885         -- Wander
 886         activityMenu:addLine(ucstring(i18n.get("uiR2EdWander")), "", "", "Wander")
 887         menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_region.tga", size="14"})
 888         activityMenu:setUserGroupLeft(4, menuButton)
 889         activityMenu:addSubMenu(4)
 890         local regionsMenu = activityMenu:getSubMenu(4)
 891         local regionsTable = r2.Scenario:getAllInstancesByType("Region")
 892         for key, region in pairs(regionsTable) do
 893                 regionsMenu:addLine(ucstring(region.Name), "lua", "r2:setActivity('Wander', '".. region.InstanceId .."')", region.InstanceId)
 894         end
 895         if table.getn(regionsTable) == 0 then
 896                 regionsMenu:addLine(ucstring(i18n.get("uiR2EdNoSelelection")), "lua", "r2:setActivity()", "")
 897         end
 898
 899         -- Deploy
 900 --      activityMenu:addLine(ucstring(i18n.get("uiR2EdDeploy")), "", "", "Deploy")
 901 --      menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2ed_icon_region.tga", size="14"})
 902 --      activityMenu:setUserGroupLeft(6, menuButton)
 903 --      activityMenu:addSubMenu(6)
 904 --      local regionsMenu = activityMenu:getSubMenu(6)
 905 --      local regionsTable = r2.Scenario:getAllInstancesByType("Region")
 906 --      for key, region in pairs(regionsTable) do
 907 --              regionsMenu:addLine(ucstring(region.Name), "lua", "r2:setActivity('Deploy', '".. region.InstanceId .."')", region.InstanceId)
 908 --      end
 909 --      if table.getn(regionsTable) == 0 then
 910 --              regionsMenu:addLine(ucstring(i18n.get("uiR2EdNoSelelection")), "lua", "r2:setActivity()", "")
 911 --      end
 912
 913         r2:openTriggersMenu(getUICaller())
 914 end
 915
 916 function r2:setActivity(activityType, placeId)
 917
 918
 919
 920         local activityInstId = r2:getSelectedEltInstId("r2ed_triggers")
 921         assert(activityInstId)
 922
 923         if activityType == nil then
 924                 return
 925         elseif placeId == nil then
 926                 r2.requestSetNode(activityInstId, "Activity", activityType)
 927                 r2.requestSetNode(activityInstId, "ActivityZoneId", r2.RefId(""))
 928         else
 929                 r2.requestSetNode(activityInstId, "Activity", activityType)
 930                 r2.requestSetNode(activityInstId, "ActivityZoneId", r2.RefId(placeId))
 931         end
 932 end
 933
 934 ------------------ SET TIME LIMIT --------------------------------------------------------------------
 935 function r2:setTimeLimit(timeLimit)
 936
 937         if timeLimit == nil then
 938                 timeLimit = getUICaller().selection_text
 939                 if getUICaller().Env.locked then return end
 940         end
 941
 942         local uiName = "r2ed_triggers"
 943         local activity = r2:getSelectedEltUI(uiName)
 944         if activity == nil then return end
 945
 946         local viewText
 947         local hasTimeLimitValue = false
 948
 949         if timeLimit == tostring(i18n.get("uiR2EdForCertainTime")) then
 950                 hasTimeLimitValue = true
 951                 viewText = tostring(i18n.get("uiR2EdFor")) ..  " 20" .. tostring(i18n.get("uiR2EdShortSeconds"))
 952
 953                 local eltEditor = r2:getSelectedSequ(uiName):find("edit_element")
 954                 assert(eltEditor)
 955                 local comboTime = eltEditor:find("time_limit"):find("combo_box")
 956                 assert(comboTime)
 957                 comboTime.view_text = viewText
 958         else
 959                 viewText = timeLimit
 960         end
 961
 962         timeLimit = r2.TimeLimitsProp[timeLimit]
 963
 964         local activityInstId = r2:getSelectedEltInstId(uiName)
 965         r2.requestSetNode(activityInstId, "TimeLimit", timeLimit)
 966
 967         if hasTimeLimitValue then
 968                 r2.requestSetNode(activityInstId, "TimeLimitValue", tostring(20))
 969         else
 970                 r2.requestSetNode(activityInstId, "TimeLimitValue", "")
 971         end
 972 end
 973
 974 function r2:calculHourMinSec(totalSecNb)
 975
 976         local minSecNb, hourNb = totalSecNb, 0
 977         while minSecNb > 3599 do
 978                 hourNb = hourNb+1
 979                 minSecNb = minSecNb - 3600
 980         end
 981
 982         local minNb, secNb = 0, minSecNb
 983         while secNb > 59 do
 984                 minNb = minNb+1
 985                 secNb = secNb - 60
 986         end
 987
 988         return hourNb, minNb, secNb
 989 end
 990
 991 function r2:calculMinSec(totalSecNb)
 992
 993         local minNb, secNb = 0, totalSecNb
 994         while secNb > 59 do
 995                 minNb = minNb+1
 996                 secNb = secNb - 60
 997         end
 998
 999         return minNb, secNb
1000 end
1001
1002 function r2:activityForHours(hourNb)
1003
1004         local activityInst = r2:getSelectedEltInst("r2ed_triggers")
1005         assert(activityInst)
1006
1007         local lastHourNb, minNb, secNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
1008
1009         r2:setLimitTimeValue(hourNb, minNb, secNb)
1010 end
1011
1012 function r2:activityForMinutes(minNb)
1013
1014         local activityInst = r2:getSelectedEltInst("r2ed_triggers")
1015         assert(activityInst)
1016
1017         local hoursNb, lastMinNb, secNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
1018
1019         r2:setLimitTimeValue(hoursNb, minNb, secNb)
1020 end
1021
1022 function r2:activityForSeconds(secNb)
1023
1024         local activityInst = r2:getSelectedEltInst("r2ed_triggers")
1025         assert(activityInst)
1026
1027         local hoursNb, minNb, lastSecNb = r2:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
1028
1029         r2:setLimitTimeValue(hoursNb, minNb, secNb)
1030 end
1031
1032 ------------------ SET LIMIT TIME VALUE -------------------------------------------------------------------
1033 function r2:setLimitTimeValue(hourNb, minNb, secNb)
1034
1035         local totalSec = tostring(hourNb*3600 + minNb*60 + secNb)
1036         r2.requestSetNode(r2:getSelectedEltInstId("r2ed_triggers"), "TimeLimitValue", totalSec)
1037 end
1038
1039
1040 ------------------ OPEN SELECT CHAT MENU -------------------------------------------------------------------
1041 function r2:openSelectChatMenu()
1042
1043         -- triggers menu initialization
1044         local chatMenu = getUI("ui:interface:r2ed_triggers_menu")
1045         assert(chatMenu)
1046
1047         local chatMenu = chatMenu:getRootMenu()
1048         assert(chatMenu)
1049
1050         chatMenu:reset()
1051
1052         -- first line "None"
1053         chatMenu:addLine(ucstring(i18n.get("uiR2EdNoElt")), "lua", "r2:selectChatSequence('None')", "None")
1054
1055         -- second line "More"
1056         chatMenu:addLine(ucstring(i18n.get("uiR2EdMore")), "lua", "r2:openChatSequences()", "More")
1057
1058         local entityInst = r2:getSelectedInstance()
1059         assert(entityInst)
1060
1061         -- list of avoidable chat sequences
1062         local chatSequences = entityInst:getBehavior().ChatSequences
1063         for i=0, chatSequences.Size-1 do
1064                 local chatS = chatSequences[i]
1065                 assert(chatS)
1066                 --chatMenu:addLine(ucstring(chatS.Name), "lua", "r2:selectChatSequence('" .. chatS.InstanceId .. "')", chatS.InstanceId)
1067                 chatMenu:addLine(ucstring(r2:getSequenceName(chatS)), "lua", "r2:selectChatSequence('" .. chatS.InstanceId .. "')", chatS.InstanceId)
1068         end
1069
1070         r2:openTriggersMenu(getUICaller())
1071 end
1072
1073 function r2:openChatSequences()
1074         local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
1075         assert(chatSequencesUI)
1076
1077         chatSequencesUI.active = true
1078         chatSequencesUI:updateCoords()
1079
1080         if chatSequencesUI.Env.openFirst == nil then
1081                 chatSequencesUI:center()
1082                 chatSequencesUI.Env.openFirst = true
1083         end
1084 end
1085
1086 -----------------------------------------------------------------------------------------------------------
1087 -- the commun "logic entity" menu is open
1088 function r2:openTriggersMenu(caller)
1089
1090         local menuName = "ui:interface:r2ed_triggers_menu"
1091         launchContextMenuInGame(menuName)
1092         local menu = getUI(menuName)
1093
1094         menu:updateCoords()
1095         menu.y = caller.y_real - (menu.h + 2)
1096         menu.x = caller.x_real
1097         menu:setMinW(caller.w)
1098         menu:updateCoords()
1099 end
1100
1101 ------------------ SELECT CHAT SEQUENCE  -------------------------------------------------------------
1102 function r2:selectChatSequence(choice, activityId)
1103
1104         local chatSequenceUI = getUI("ui:interface:r2ed_chat_sequence")
1105         assert(chatSequenceUI)
1106
1107         local uiName = "r2ed_triggers"
1108
1109         if activityId == nil then
1110                 activityId = r2:getSelectedEltInstId(uiName)
1111         end
1112
1113         local activityUI = r2:getSelectedEltUI(uiName)
1114         assert(activityUI)
1115
1116         if choice == "None" then
1117                 r2.requestSetNode(activityId, "Chat", r2.RefId(""))
1118                 local sep = activityUI:find("sep")
1119                 assert(sep)
1120                 sep.active = false
1121         elseif choice == "More" then
1122                 r2:openChatSequences()
1123         elseif choice then
1124                 local chatSId = choice
1125                 local activityInstId = r2:getSelectedEltInstId(uiName)
1126                 r2.requestSetNode(activityId, "Chat", r2.RefId(chatSId))
1127                 r2.requestSetNode(activityInstId, "Type", "Non Repeating")
1128         else
1129                 debugInfo("r2:selectChatSequence : unknown menu selection")
1130         end
1131 end
1132
1133 ------------------ REPEAT OR NOT CHAT SEQUENCE  ------------------------------------------------------
1134 function r2:repeatChatSequence()
1135
1136         local activityInstId = r2:getSelectedEltInstId("r2ed_triggers")
1137         assert(activityInstId)
1138
1139         local sequenceType = "Repeating"
1140         if getUICaller().pushed then sequenceType = "Non Repeating" end
1141
1142         r2.requestSetNode(activityInstId, "Type", sequenceType)
1143 end
1144
1145 ------------------ NEW CHAT SEQUENCE  -------------------------------------------------------------
1146 function r2:newChatsSequence(firstRequest, instanceSequence, reset)
1147
1148         local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
1149         assert(chatSequencesUI)
1150
1151         local tab = chatSequencesUI:find("sequence_tabs")
1152         assert(tab)
1153
1154         -- limit sequences number
1155         if firstRequest and tab.tabButtonNb == 7 then return -1 end
1156
1157         if firstRequest == true then
1158                 instanceSequence = r2.newComponent("ChatSequence")
1159
1160                 --local name = tostring(i18n.get("uiR2EdChat"))..tab.tabButtonNb+1
1161                 --instanceSequence.Name = name
1162
1163                 local npcGroup = r2:getSelectedInstance()
1164                 assert(npcGroup)
1165
1166                 r2.requestInsertNode(npcGroup:getBehavior().InstanceId, "ChatSequences", -1, "", instanceSequence)
1167
1168                 r2.ownCreatedInstances[instanceSequence.InstanceId] = true
1169         else
1170
1171                 local templateParams = {
1172                                                                         newElt="r2:newChat(true)",
1173                                                                         newEltText=tostring(i18n.get("uiR2EdNewChat")),
1174                                                                         eltOrderText=tostring(i18n.get("uiR2EdChatOrder")),
1175                                                                         upElt="r2:upChat()",
1176                                                                         downElt="r2:downChat()",
1177                                                                         maxMinElts="r2:maximizeMinimizeChats()",
1178                                                                         downUpColor="120 150 140 255",
1179                                                                         colPushed = "0 255 0 255",
1180                                                                         paramsL= "r2:selectSequenceTab('r2ed_chat_sequence', "..tostring(tab.tabButtonNb)..")"
1181                                                            }
1182
1183                 if reset == true then
1184                         r2.ownCreatedInstances[instanceSequence.InstanceId] = true
1185                 end
1186
1187                 local editorEltTemplate = "template_edit_chat"
1188                 local sequence = r2:newElementsSequence("r2ed_chat_sequence", templateParams, editorEltTemplate,
1189                         instanceSequence, tostring(i18n.get("uiR2EdSequChat")))
1190
1191                 local chats = instanceSequence.Components
1192                 for c = 0, chats.Size - 1 do
1193                         r2:newChat(false, chats[c])
1194                 end
1195
1196                 local eltEditor = sequence:find("edit_element")
1197                 assert(eltEditor)
1198
1199                 local editBox = eltEditor:find("edit_box_group")
1200                 assert(editBox)
1201
1202                 local scroll = sequence:find("edit_box_scroll_ed")
1203                 assert(scroll)
1204
1205                 scroll:setTarget(editBox.id)
1206         end
1207
1208         return instanceSequence.InstanceId
1209 end
1210
1211 ------------------- REMOVE CHATS SEQUENCE ---------------------------------------------------------
1212 function r2:removeChatsSequence()
1213
1214         -- remove sequence
1215         r2:removeElementsSequence("r2ed_chat_sequence", "ChatSequences", tostring(i18n.get("uiR2EdSequChat")))
1216 end
1217
1218 function r2:removeChatsSequenceUI(sequIndex)
1219
1220         r2:closeChatEditor()
1221
1222         -- remove sequence UI
1223         r2:removeElementsSequenceUI(sequIndex, "r2ed_chat_sequence", "ChatSequences", tostring(i18n.get("uiR2EdSequChat")))
1224 end
1225
1226 ------------------- SELECT CHAT -------------------------------------------------------------------
1227 function r2:selectChat()
1228         r2:selectTriggerElement(nil, "r2ed_chat_sequence")
1229
1230         if getUICaller().pushed == true then
1231                 r2:updateChatEditor()
1232         end
1233 end
1234
1235 ------------------- OPEN CHAT EDITOR --------------------------------------------------------------
1236 function r2:openChatEditor()
1237         r2:updateChatEditor()
1238         r2:openElementEditor("r2ed_chat_sequence", "uiR2EDChatStepEditor")
1239 end
1240
1241 function r2:updateChatEditor()
1242
1243         local instanceChat = r2:getSelectedEltInst("r2ed_chat_sequence")
1244
1245         local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
1246         assert(chatEditor)
1247
1248         -- chat name
1249         local chatName = chatEditor:find("name")
1250         assert(chatName)
1251
1252         -- time
1253         local minutesText = chatEditor:find("minutes"):find("text")
1254         assert(minutesText)
1255
1256         local secondsText = chatEditor:find("seconds"):find("text")
1257         assert(secondsText)
1258
1259         -- update NPC name lists
1260         local whoMenuText = chatEditor:find("whoMenu"):find("text")
1261         assert(whoMenuText)
1262
1263         local toWhoMenuText = chatEditor:find("toWhoMenu"):find("text")
1264         assert(toWhoMenuText)
1265
1266         local editBox = chatEditor:find("says"):find("edit_box_group")
1267         assert(editBox)
1268
1269         local emoteButtonText = chatEditor:find("emote"):find("menu"):find("text")
1270         assert(emoteButtonText)
1271
1272         if instanceChat then
1273
1274                 local index = r2:searchElementIndex(instanceChat)
1275                 if index~= nil then
1276                         chatName.uc_hardtext = tostring(i18n.get("uiR2EdChat")).." "..index.." : "
1277                 else
1278                         chatName.uc_hardtext = tostring(i18n.get("uiR2EdChat")).." : "
1279                 end
1280
1281                 -- after value
1282                 local time = instanceChat.Time
1283                 local minNb, secNb = r2:calculMinSec(time)
1284
1285                 minutesText.uc_hardtext = tostring(minNb)
1286                 secondsText.uc_hardtext = tostring(secNb)
1287
1288                 -- who
1289                 local whoInst = r2:getInstanceFromId(tostring(instanceChat.Actions[0].Who))
1290                 whoMenuText.uc_hardtext = whoInst.Name
1291
1292                 -- says what
1293                 local textID = instanceChat.Actions[0].Says
1294                 if textID ~= "" then
1295                         editBox.uc_input_string = r2:getInstanceFromId(textID).Text
1296                 else
1297                         editBox.uc_input_string = ""
1298                 end
1299
1300                 -- to who
1301                 local toWhoInst = r2:getInstanceFromId(tostring(instanceChat.Actions[0].Facing))
1302                 if toWhoInst then
1303                         toWhoMenuText.uc_hardtext = toWhoInst.Name
1304                 else
1305                         toWhoMenuText.uc_hardtext = tostring(i18n.get("uiR2EdNobody"))
1306                 end
1307
1308                 -- emote
1309                 local emoteName = r2.fromEmoteIdToName[instanceChat.Actions[0].Emote]
1310                 if emoteName then
1311                         emoteButtonText.uc_hardtext = emoteName
1312                 else
1313                         emoteButtonText.uc_hardtext = tostring(i18n.get("uiR2EdNoElt"))
1314                 end
1315
1316         else
1317
1318                 local name = tostring(i18n.get("uiR2EdChat")).." : "
1319                 chatName.uc_hardtext = name
1320
1321                 minutesText.uc_hardtext = tostring(0)
1322                 secondsText.uc_hardtext = tostring(0)
1323
1324                 whoMenuText.uc_hardtext = ""
1325
1326                 editBox.uc_input_string = ""
1327
1328                 toWhoMenuText.uc_hardtext = tostring(i18n.get("uiR2EdNobody"))
1329
1330                 emoteButtonText.uc_hardtext = tostring(i18n.get("uiR2EdNoElt"))
1331         end
1332 end
1333
1334 ------------------ OPEN CHAT SEQUENCE EDITOR  --------------------------------------------------
1335 function r2:openChatSequenceEditor()
1336
1337         local editor = getUI("ui:interface:r2ed_edit_chat_sequence")
1338         assert(editor)
1339
1340         local chatsUI = getUI("ui:interface:r2ed_chat_sequence")
1341         assert(chatsUI)
1342
1343         editor.x = chatsUI.x
1344         editor.y = chatsUI.y
1345         editor.active = true
1346 end
1347
1348 ------------------- MAX / MIN CHAT ----------------------------------------------------------------
1349 function r2:maximizeMinimizeChat()
1350         r2:maximizeMinimizeElement("r2ed_chat_sequence")
1351 end
1352
1353 -------------------- NEW CHAT ---------------------------------------------------------------------
1354 function r2:newChat(firstRequest, instanceElement, sequenceUI)
1355
1356         local uiName = "r2ed_chat_sequence"
1357
1358         if firstRequest == true then
1359                 instanceElement = r2.newComponent("ChatStep")
1360
1361                 instanceElement.Time = 3
1362
1363                 local who
1364                 local selectedInst = r2:getSelectedInstance()
1365                 assert(selectedInst)
1366
1367                 if selectedInst:isGrouped() then
1368                         who = r2:getLeader(selectedInst)
1369                 else
1370                         who = selectedInst
1371                 end
1372                 local chatAction = r2.newComponent("ChatAction")
1373                 chatAction.Who = who.InstanceId
1374                 table.insert(instanceElement.Actions, chatAction)
1375
1376                 local sequenceInstId = r2:getSelectedSequInstId(uiName)
1377
1378                 r2.requestInsertNode(sequenceInstId, "Components", -1, "", instanceElement)
1379
1380                 r2.ownCreatedInstances[instanceElement.InstanceId] = true
1381         else
1382
1383                 local templateParams =  {
1384                                                                         selectElt="r2:selectChat()",
1385                                                                         openEltEditor="r2:openChatEditor()",
1386                                                                         maxMinElt="r2:maximizeMinimizeChat()",
1387                                                                         removeElt="r2:removeChat()",
1388                                                                         colOver="120 150 140 100",
1389                                                                         colPushed="120 150 140 255"
1390                                                                 }
1391
1392                 if sequenceUI == nil then
1393                         sequenceUI = r2:getSelectedSequ(uiName)
1394                 end
1395                 local element = r2:newTriggerElement(uiName, tostring(i18n.get("uiR2EdChat")), templateParams, sequenceUI, instanceElement.InstanceId)
1396
1397                 r2:updateChatText(element)
1398         end
1399 end
1400
1401 function r2:searchElementIndex(eltInst)
1402
1403         local components = eltInst.Parent
1404         local index
1405         for i=0, components.Size-1 do
1406                 local elt = components[i]
1407                 if elt.InstanceId == eltInst.InstanceId then
1408                         return (i+1)
1409                 end
1410         end
1411 end
1412
1413 function r2:buildChatTitle(chatUI, erase)
1414
1415         local chatInst = r2:getInstanceFromId(chatUI.Env.elementId)
1416         assert(chatInst)
1417
1418         -- part1
1419         local index = r2:searchElementIndex(chatInst)
1420         if erase==true then index = index-1 end
1421         local part1 = tostring(i18n.get("uiR2EdChat")).." "..index.." : "
1422
1423         -- part2
1424         local minNb, secNb = r2:calculMinSec(chatInst.Time)
1425         local time = ""
1426         if minNb ~= 0 then
1427                 time = tostring(minNb)..tostring(i18n.get("uiR2EdShortMinutes"))
1428         end
1429         time = time.." " ..tostring(secNb)..tostring(i18n.get("uiR2EdShortSeconds"))
1430         local part2 = "(" ..tostring(i18n.get("uiR2EdAfter")).." ".. time..") "
1431
1432         -- part3
1433         local part3 = ""
1434         local action = chatInst.Actions[0]
1435         local who = action.Who
1436         if who ~= "" then
1437                 who = r2:getInstanceFromId(who)
1438                 assert(who)
1439                 part3 = who.Name .. " " ..tostring(i18n.get("uiR2EdSays")).. " "
1440
1441                 local says = action.Says
1442                 if says ~= "" then
1443                         says = r2:getInstanceFromId(says).Text
1444                         says = string.substr(says, 0, 4)
1445                 end
1446
1447                 part3 = part3 .. says .. "..."
1448         end
1449
1450         -- title
1451         local title = chatUI:find("title")
1452         assert(title)
1453         title.uc_hardtext= part1..part2..part3
1454 end
1455
1456 function r2:getChatName(chatInst)
1457
1458         -- part1
1459         local index = r2:searchElementIndex(chatInst)
1460         if erase==true then index = index-1 end
1461         local part1 = tostring(i18n.get("uiR2EdChat")).." "..index.." : "
1462
1463         -- part2
1464         local minNb, secNb = r2:calculMinSec(chatInst.Time)
1465         local time = ""
1466         if minNb ~= 0 then
1467                 time = tostring(minNb)..tostring(i18n.get("uiR2EdShortMinutes"))
1468         end
1469         time = time.." " ..tostring(secNb)..tostring(i18n.get("uiR2EdShortSeconds"))
1470         local part2 = "(" ..tostring(i18n.get("uiR2EdAfter")).." ".. time..") "
1471
1472         -- part3
1473         local part3 = ""
1474         local action = chatInst.Actions[0]
1475         local who = action.Who
1476         if who ~= "" then
1477                 who = r2:getInstanceFromId(who)
1478                 assert(who)
1479                 part3 = who.Name .. " " ..tostring(i18n.get("uiR2EdSays")).. " "
1480
1481                 local says = action.Says
1482                 if says ~= "" then
1483                         says = r2:getInstanceFromId(says).Text
1484                         says = string.sub(says, 1, 4)
1485                 end
1486
1487                 part3 = part3 .. says .. "..."
1488         end
1489
1490         return part1..part2..part3
1491
1492 end
1493
1494 function r2:updateChatText(elementUI)
1495
1496         if elementUI == nil then
1497                 elementUI = r2:getSelectedEltUI("r2ed_chat_sequence")
1498         end
1499         assert(elementUI)
1500
1501         local instance = r2:getInstanceFromId(elementUI.Env.elementId)
1502         assert(instance)
1503
1504         local chatText = elementUI:find("text_list")
1505         assert(chatText)
1506
1507         chatText:clear()
1508
1509         local who = tostring(instance.Actions[0].Who)
1510         if who ~= "" then
1511
1512                 local text = ""
1513                 local textEmpty = true
1514
1515                 local facing = tostring(instance.Actions[0].Facing)
1516                 local emote = instance.Actions[0].Emote
1517                 local says = instance.Actions[0].Says
1518
1519                 if facing ~= "" then
1520                         text = "\n"..r2:getInstanceFromId(who).Name .." "..tostring(i18n.get("uiR2EdFaces")).." ".. r2:getInstanceFromId(facing).Name
1521                         textEmpty = false
1522                 end
1523                 if r2.fromEmoteIdToName[emote] ~= nil then
1524                         text = text .. "\n" .. r2:getInstanceFromId(who).Name .. " "..string.lower(tostring(i18n.get("uiR2EdEmote"))).." : " .. r2.fromEmoteIdToName[emote]
1525                         textEmpty = false
1526                 end
1527                 if r2:getInstanceFromId(says)~=nil and r2:getInstanceFromId(says).Text ~= "" then
1528                         text = text.."\n"..r2:getInstanceFromId(who).Name .. " "..tostring(i18n.get("uiR2EdSays")).." : " .. r2:getInstanceFromId(says).Text
1529                         textEmpty = false
1530                 end
1531                 text = text.."\n"
1532
1533                 chatText:addTextChild(ucstring(text))
1534
1535                 local sep = elementUI:find("sep")
1536                 assert(sep)
1537                 if textEmpty == false then
1538                         sep.active = true
1539                 else
1540                         chatText:clear()
1541                         sep.active = false
1542                 end
1543         end
1544
1545         r2:buildChatTitle(elementUI, false)
1546
1547         local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
1548         assert(chatEditor)
1549
1550         if instance.InstanceId == r2:getSelectedEltInstId("r2ed_chat_sequence") then
1551                 r2:updateChatEditor()
1552         end
1553
1554         r2:updateActivitiesWhithThisChatSequence(instance, false)
1555 end
1556
1557
1558 -------------------- UP CHAT ----------------------------------------------------------------------
1559 function r2:upChat()
1560         r2:upTriggerElement("r2ed_chat_sequence")
1561 end
1562
1563 -------------------- DOWN CHAT --------------------------------------------------------------------
1564 function r2:downChat()
1565         r2:downTriggerElement("r2ed_chat_sequence")
1566 end
1567
1568 -------------------- MAX / MIN CHATS --------------------------------------------------------------
1569 function r2:maximizeMinimizeChats()
1570         r2:maximizeMinimizeTriggerElements("r2ed_chat_sequence")
1571 end
1572
1573 -------------------- REMOVE CHAT ------------------------------------------------------------------
1574 function r2:removeChat()
1575         r2:removeTriggerElement("r2ed_chat_sequence", tostring(i18n.get("uiR2EdChat")))
1576 end
1577
1578 -------------------- CHAT TIME --------------------------------------------------------------------
1579 function r2:setTime(minNb, secNb)
1580
1581         local chatSequenceId = r2:getSelectedEltInstId("r2ed_chat_sequence")
1582
1583         r2.requestSetNode(chatSequenceId, "Time", minNb*60+secNb)
1584 end
1585
1586 -------------------- INIT TIME MENU -----------------------------------------------------------------
1587 function r2:initTimeMenu(timeFunction, isHours)
1588
1589         local timeMenu = getUI("ui:interface:r2ed_triggers_menu")
1590         assert(timeMenu)
1591
1592         local timeMenu = timeMenu:getRootMenu()
1593         assert(timeMenu)
1594
1595         timeMenu:reset()
1596
1597         for i=0,9 do
1598                 timeMenu:addLine(ucstring(tostring(i)), "lua", timeFunction .. "(" .. tostring(i) .. ")", tostring(i))
1599         end
1600
1601         if isHours == true then
1602                 timeMenu:addLine(ucstring(tostring(10)), "lua", timeFunction .. "(" .. tostring(10) .. ")", tostring(10))
1603         else
1604
1605                 local lineNb = 9
1606                 for i=10, 50, 10 do
1607                         local lineStr = tostring(i).."/"..tostring(i+9)
1608                         timeMenu:addLine(ucstring(lineStr), "", "", tostring(i))
1609                         lineNb = lineNb+1
1610
1611                         timeMenu:addSubMenu(lineNb)
1612                         local subMenu = timeMenu:getSubMenu(lineNb)
1613
1614                         for s=0,9 do
1615                                 lineStr = tostring(i+s)
1616                                 subMenu:addLine(ucstring(lineStr), "lua", timeFunction .. "(" .. tostring(i+s) .. ")", lineStr)
1617                         end
1618                 end
1619         end
1620
1621         r2:openTriggersMenu(getUICaller())
1622 end
1623
1624 -------------------- CHAT SECONDS -----------------------------------------------------------------
1625 function r2:chatAfterSeconds(secNb)
1626
1627         local chatStepInst = r2:getSelectedEltInst("r2ed_chat_sequence")
1628
1629         local lastTime = chatStepInst.Time
1630
1631         local minNb = 0
1632         while  lastTime > 59 do
1633                 lastTime = lastTime - 60
1634                 minNb = minNb + 1
1635         end
1636
1637         r2:setTime(minNb, secNb)
1638
1639         -- recover "says what" (equiv change focus)
1640         local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
1641         assert(chatEditor)
1642
1643         local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
1644         if chatStepInst.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
1645                 r2:setSaysWhat(saysWhat)
1646         end
1647 end
1648
1649 -------------------- CHAT MINUTES -----------------------------------------------------------------
1650 function r2:chatAfterMinutes(minNb)
1651
1652         local chatStepInst = r2:getSelectedEltInst("r2ed_chat_sequence")
1653
1654         local lastTime = chatStepInst.Time
1655
1656         local secNb = lastTime
1657         while  secNb > 59 do
1658                 secNb = secNb - 60
1659         end
1660
1661         r2:setTime(minNb, secNb)
1662
1663         -- recover "says what" (equiv change focus)
1664         local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
1665         assert(chatEditor)
1666
1667         local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
1668         if chatStepInst.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
1669                 r2:setSaysWhat(saysWhat)
1670         end
1671 end
1672
1673 -------------------- WHO --------------------------------------------------------------------------
1674 function r2:setWho(who, chatStepInst)
1675
1676         if chatStepInst == nil then
1677                 chatStepInst = r2:getSelectedEltInst("r2ed_chat_sequence")
1678         end
1679         assert(chatStepInst)
1680
1681         r2.requestSetNode(chatStepInst.Actions[0].InstanceId, "Who", r2.RefId(who))
1682
1683         if who == chatStepInst.Actions[0].Facing then
1684                 r2:setToWho(tostring(i18n.get("uiR2EdNobody")))
1685         end
1686
1687         -- recover "says what" (equiv change focus)
1688         local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
1689         assert(chatEditor)
1690
1691         local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
1692         if chatStepInst.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
1693                 r2:setSaysWhat(saysWhat)
1694         end
1695 end
1696
1697 function r2:openWhoMenu(whoFunction, towho)
1698
1699         local menuName = "ui:interface:r2ed_triggers_menu"
1700
1701         local whoMenu = getUI(menuName)
1702         local whoMenu = whoMenu:getRootMenu()
1703         assert(whoMenu)
1704
1705         whoMenu:reset()
1706
1707         local npcTable = r2.Scenario:getAllInstancesByType("Npc")
1708
1709         if towho == true then
1710                 whoMenu:addLine(ucstring(i18n.get("uiR2EdNobody")), "lua", whoFunction.."('" ..tostring(i18n.get("uiR2EdNobody")).. "')", "Nobody")
1711         end
1712
1713         for key, npc in npcTable do
1714                 local addLine = true
1715                 if not npc:isBotObject() and not npc:isPlant() and not r2.isCreature(npc.InstanceId) then
1716                         if towho == true then
1717                                 local chatStepInst= r2:getSelectedEltInst("r2ed_chat_sequence")
1718                                 assert(chatStepInst)
1719
1720                                 local whoId = chatStepInst.Actions[0].Who
1721                                 if whoId~="" and whoId == npc.InstanceId then
1722                                         addLine = false
1723                                 end
1724                         end
1725                         if addLine then
1726                                 whoMenu:addLine(ucstring(npc.Name), "lua", whoFunction.."('" ..npc.InstanceId.. "')", npc.InstanceId)
1727                         end
1728                 end
1729         end
1730
1731         r2:openTriggersMenu(getUICaller())
1732 end
1733
1734 -------------------- SAYS WHAT --------------------------------------------------------------------
1735 function r2:setSaysWhat(what)
1736
1737         if what == nil then
1738                 what = getUICaller().input_string
1739         end
1740
1741         local says = what
1742
1743         local chatStep = r2:getSelectedEltInst("r2ed_chat_sequence")
1744         if chatStep ~= nil then
1745                 if what ~= "" then
1746                         what=r2.registerText(what).InstanceId
1747                 end
1748                 r2.requestSetNode(chatStep.Actions[0].InstanceId, "Says", what)
1749
1750                 local chatStepUI = r2:getSelectedEltUI("r2ed_chat_sequence")
1751                 assert(chatStepUI)
1752         end
1753 end
1754
1755 -------------------- CLOSE CHAT EDITOR ------------------------------------------------------------
1756 function r2:closeChatEditor(chatEditor)
1757
1758         if chatEditor == nil then
1759                 chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
1760         end
1761         assert(chatEditor)
1762
1763         local editSaysWhat = chatEditor:find("says"):find("edit_box_group")
1764         assert(editSaysWhat)
1765
1766         if r2.callSetSaysWhat == true then
1767                 r2:setSaysWhat(editSaysWhat.input_string)
1768         end
1769 end
1770
1771 -------------------- TO WHO -----------------------------------------------------------------------
1772 function r2:setToWho(toWho)
1773
1774         local chatSequence = r2:getSelectedEltInst("r2ed_chat_sequence")
1775         assert(chatSequence)
1776
1777         local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
1778         assert(chatEditor)
1779
1780         -- recover "says what" (equiv change focus)
1781         local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
1782         if chatSequence.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
1783                 r2:setSaysWhat(saysWhat)
1784         end
1785
1786         if toWho == tostring(i18n.get("uiR2EdNobody")) then toWho="" end
1787
1788         r2.requestSetNode(chatSequence.Actions[0].InstanceId, "Facing", r2.RefId(toWho))
1789 end
1790
1791 -------------------- EMOTE ------------------------------------------------------------------------
1792 function r2:openEmoteMenu()
1793
1794         local menuName = "ui:interface:r2ed_triggers_menu"
1795
1796         local emoteMenu = getUI(menuName)
1797         local emoteMenu = emoteMenu:getRootMenu()
1798         assert(emoteMenu)
1799
1800         emoteMenu:reset()
1801         initEmotesMenu(menuName, "r2:setEmote")
1802         r2:openTriggersMenu(getUICaller())
1803 end
1804
1805 function r2:setEmote(emoteId)
1806
1807         local chatSequence = r2:getSelectedEltInst("r2ed_chat_sequence")
1808         assert(chatSequence)
1809
1810         r2.requestSetNode(chatSequence.Actions[0].InstanceId, "Emote", emoteId)
1811
1812         -- recover "says what" (equiv change focus)
1813         local chatEditor = r2:getSelectedSequ("r2ed_chat_sequence"):find("edit_element")
1814         assert(chatEditor)
1815
1816         local saysWhat = chatEditor:find("says"):find("edit_box_group").input_string
1817         if chatSequence.Actions[0].Says ~= r2.registerText(saysWhat).InstanceId then
1818                 r2:setSaysWhat(saysWhat)
1819         end
1820 end
1821
1822 ------------------ SELECT CHAT SEQUENCE ---------------------------------------------------------
1823 function r2:selectChatsSequence(index)
1824         r2:selectElementsSequence("r2ed_chat_sequence", index)
1825         r2:updateMiniActivityView()
1826 end
1827
1828 ---------------------------------------------------------------------------------------------------
1829 ------------------------------  FACTORISATION  ----------------------------------------------------
1830 ---------------------------------------------------------------------------------------------------
1831
1832 ------------------------------  Remove element  ---------------------------------------------------
1833 function r2:removeTriggerElement(uiName, elementName)
1834
1835         local wndUI = getUI("ui:interface:"..uiName)
1836         assert(wndUI)
1837
1838         local tab = wndUI:find("sequence_tabs")
1839         assert(tab)
1840
1841         local sequenceUI = wndUI:find(tab.associatedGroupSelection)
1842         assert(sequenceUI)
1843
1844         r2:removeElement(sequenceUI, uiName, elementName)
1845 end
1846
1847 -----------------------------------------------------------------------------------------------------
1848 function r2:removeElement(sequence, uiName, elementName, removedElement)
1849
1850         local listElements = sequence:find("elements_list")
1851         assert(listElements)
1852
1853         local toErasedInstId
1854         if removedElement == nil then
1855                 toErasedInstId = r2:getSelectedEltInstId(uiName)
1856         else
1857                 toErasedInstId = removedElement.Env.elementId
1858         end
1859         assert(toErasedInstId)
1860
1861         -- request erase node
1862         if toErasedInstId ~= nil and r2:getInstanceFromId(toErasedInstId) ~= nil then
1863                 r2.requestEraseNode(toErasedInstId, "", -1)
1864         end
1865 end
1866
1867 function r2:removeElementUI(sequence, uiName, removedElement)
1868
1869         local listElements = sequence:find("elements_list")
1870         assert(listElements)
1871
1872         -- update follow elements number
1873         local removedIndex = listElements:getElementIndex(removedElement)
1874         for i = removedIndex+1, (listElements.childrenNb-1) do
1875                 local element = listElements:getChild(i)
1876                 assert(element)
1877
1878                 if not element.Env.isEditor then
1879                         r2:buildElementTitle(uiName, element, true)
1880                 end
1881         end
1882
1883         -- delete element and update coordinates of elements list
1884         if removedElement == r2:getSelectedEltUI(uiName) then
1885                 r2:setSelectedEltUIId(uiName, nil)
1886
1887                 -- inactive element editor
1888                 local eltEditor = listElements:find("edit_element")
1889                 assert(eltEditor)
1890                 eltEditor.active = false
1891
1892                 -- disactive up and down element buttons
1893                 local upElement = sequence:find("up_element")
1894                 assert(upElement)
1895                 local downElement = sequence:find("down_element")
1896                 assert(downElement)
1897                 local elementOrder = sequence:find("element_order")
1898                 assert(elementOrder)
1899
1900                 upElement.active = false
1901                 downElement.active = false
1902                 elementOrder.active = false
1903         end
1904         listElements.Env.elementsNb = listElements.Env.elementsNb - 1
1905
1906         listElements:delChild(removedElement)
1907         listElements.parent:invalidateCoords()
1908
1909         -- if any activity in list, disactive global minimize / maximize button
1910         if listElements.childrenNb == 1 then
1911                 local minElts = sequence:find("minimize_elements")
1912                 assert(minElts)
1913
1914                 local maxElts = sequence:find("maximize_elements")
1915                 assert(maxElts)
1916
1917                 minElts.active = false
1918                 maxElts.active = false
1919         end
1920 end
1921
1922 ------------------------------  Max / Min elements  -----------------------------------------------
1923 function r2:maximizeMinimizeTriggerElements(uiName)
1924
1925         local sequence = r2:getSelectedSequ(uiName)
1926         assert(sequence)
1927
1928         r2:maximizeMinimizeElements(sequence, uiName)
1929 end
1930
1931 ------------------------------  Max / Min elements  -----------------------------------------------
1932 function r2:maximizeMinimizeElements(sequence, uiName)
1933
1934         local elements = sequence:find("elements_list")
1935         assert(elements)
1936
1937         if elements.Env.minimize == nil then
1938                 elements.Env.minimize = true
1939         end
1940
1941         elements.Env.minimize = not elements.Env.minimize
1942
1943         for i = 0, elements.childrenNb-1 do
1944                 local element = elements:getChild(i)
1945                 assert(element)
1946
1947                 if element.Env.isEditor ~= true then
1948                         r2:maximizeMinimizeElement(uiName, element, elements.Env.minimize)
1949                 end
1950         end
1951
1952         local minElts = sequence:find("minimize_elements")
1953         assert(minElts)
1954         local maxElts = sequence:find("maximize_elements")
1955         assert(maxElts)
1956
1957         if elements.Env.minimize == true then
1958                 minElts.active = false
1959                 maxElts.active = true
1960         else
1961                 minElts.active = true
1962                 maxElts.active = false
1963         end
1964 end
1965
1966 ------------------------------  Max / Min element  ------------------------------------------------
1967 function r2:maximizeMinimizeElement(uiName, element, allMinimize)
1968
1969         if element == nil then
1970                 element = getUICaller().parent.parent.parent.parent.parent.parent
1971         end
1972         assert(element)
1973
1974         local eltText = element:find("element_text")
1975         assert(eltText)
1976
1977         local allMin, allMax = true, true
1978         if allMinimize ~= nil then
1979                 allMin = allMinimize
1980                 allMax = not allMin
1981         end
1982
1983         local maxButton = element:find("maximize_element")
1984         assert(maxButton)
1985         local minButton = element:find("minimize_element")
1986         assert(minButton)
1987
1988         -- maximize
1989         if allMax and eltText.active==false then
1990                 eltText.active = true
1991                 maxButton.active = false
1992                 minButton.active = true
1993
1994         -- minimize
1995         elseif allMin and eltText.active==true then
1996                 eltText.active = false
1997                 maxButton.active = true
1998                 minButton.active = false
1999         end
2000 end
2001
2002 ------------------------------------ Down element --------------------------------------------------
2003 function r2:downTriggerElement(uiName)
2004
2005         local eltSequenceUI = getUI("ui:interface:"..uiName)
2006         assert(eltSequenceUI)
2007
2008         local tab = eltSequenceUI:find("sequence_tabs")
2009         assert(tab)
2010
2011         local sequence = eltSequenceUI:find(tab.associatedGroupSelection)
2012         assert(sequence)
2013
2014         local listElements = sequence:find("elements_list")
2015         assert(listElements)
2016
2017         local selectedElement = r2:getSelectedEltUI(uiName)
2018         local index = listElements:getElementIndex(selectedElement)
2019
2020         local sequenceId = r2:getSelectedSequInstId(uiName)
2021         if index < r2:getInstanceFromId(sequenceId).Components.Size-1 then
2022                 r2.requestMoveNode(sequenceId, "Components", index+1,
2023                                                    sequenceId, "Components", index)
2024         end
2025 end
2026
2027 ------------------------------------ Down or up element UI ------------------------------------------
2028
2029 function r2:downUpElement(elementUI, uiName)
2030
2031         local listElements = elementUI.parent
2032         assert(listElements)
2033
2034         local eltEditor = listElements:find("edit_element")
2035         assert(eltEditor)
2036
2037         local index = listElements:getElementIndex(elementUI)
2038
2039         if index > 0 then
2040                 local previousElement = listElements:getChild(index - 1)
2041
2042                 local editorBetweenBothElts = false
2043                 if previousElement.Env.elementId==nil then
2044                         previousElement = listElements:getChild(index - 2)
2045                         editorBetweenBothElts = true
2046                 end
2047
2048                 listElements:upChild(elementUI)
2049                 if editorBetweenBothElts==true then
2050                         listElements:upChild(elementUI)
2051                 end
2052
2053                 local selectedEltUI = r2:getSelectedEltUI(uiName)
2054                 if selectedEltUI~=nil then
2055                         local selectedEltIndex = listElements:getElementIndex(selectedEltUI)
2056                         local eltEditorIndex = listElements:getElementIndex(eltEditor)
2057                         if eltEditorIndex~=selectedEltIndex+1 then
2058                                 if eltEditorIndex<selectedEltIndex then
2059                                         for i=eltEditorIndex, selectedEltIndex-1 do
2060                                                 listElements:downChild(eltEditor)
2061                                         end
2062                                 else
2063                                         for i=selectedEltIndex, eltEditorIndex-2 do
2064                                                 listElements:upChild(eltEditor)
2065                                         end
2066                                 end
2067
2068                         end
2069
2070                         if selectedEltUI==previousElement then
2071                                 previousElement.active = false
2072                         elseif selectedEltUI==elementUI then
2073                                 elementUI.active = false
2074                         end
2075
2076                         r2:updateElementEditor(uiName)
2077                 end
2078
2079                 r2:buildElementTitle(uiName, previousElement, false)
2080                 r2:buildElementTitle(uiName, elementUI, false)
2081         end
2082 end
2083
2084 function r2:updateElementEditor(uiName)
2085
2086         if uiName == "r2ed_triggers" then
2087                 r2:updateActivityEditor()
2088         elseif uiName == "r2ed_chat_sequence" then
2089                 r2:updateChatEditor()
2090         end
2091 end
2092
2093 function r2:buildElementTitle(uiName, elementUI, erase)
2094
2095         if uiName == "r2ed_triggers" then
2096                 r2:buildActivityTitle(elementUI, erase)
2097         elseif uiName == "r2ed_chat_sequence" then
2098                 r2:buildChatTitle(elementUI, erase)
2099         elseif uiName == r2.logicEntityUIPath.."actions" then
2100                 r2:buildActionTitle(elementUI, erase)
2101         elseif uiName == r2.logicEntityUIPath.."reactions" then
2102                 r2:buildReactionTitle(elementUI, erase)
2103         end
2104 end
2105
2106 ------------------------------------ Up element ------------------------------------------------------
2107 function r2:upTriggerElement(uiName)
2108
2109         local eltSequenceUI = getUI("ui:interface:"..uiName)
2110         assert(eltSequenceUI)
2111
2112         local tab = eltSequenceUI:find("sequence_tabs")
2113         assert(tab)
2114
2115         local sequence = eltSequenceUI:find(tab.associatedGroupSelection)
2116         assert(sequence)
2117
2118         local listElements = sequence:find("elements_list")
2119         assert(listElements)
2120
2121         local selectedElement = r2:getSelectedEltUI(uiName)
2122         local index = listElements:getElementIndex(selectedElement)
2123
2124         if index>0 then
2125                 local sequenceId = r2:getSelectedSequInstId(uiName)
2126                 r2.requestMoveNode(sequenceId, "Components", index,
2127                                                    sequenceId, "Components", index-1)
2128         end
2129 end
2130
2131 ---------------------------------------------------------------------------------------------------
2132 function r2:selectTriggerElement(sequenceUI, uiName, selectedButtonElt)
2133
2134         if sequenceUI == nil then
2135                 sequenceUI = r2:getSelectedSequ(uiName)
2136         end
2137         r2:selectElement(sequenceUI, uiName, true, selectedButtonElt)
2138 end
2139
2140 ---------------------------------------------------------------------------------------------------
2141 function r2:closeElementEditor(uiName)
2142
2143         if uiName == "r2ed_chat_sequence" then
2144                 r2:closeChatEditor(getUICaller())
2145         end
2146
2147         local sequenceUI = r2:getSelectedSequ(uiName)
2148         assert(sequenceUI)
2149
2150         local selectedEltUI = r2:getSelectedEltUI(uiName)
2151         assert(selectedEltUI)
2152
2153         local selectedEltButton = selectedEltUI:find("select")
2154         assert(selectedEltButton)
2155
2156         selectedEltButton.pushed = false
2157
2158         r2:selectElement(sequenceUI, uiName, false, selectedEltButton)
2159 end
2160
2161 ---------------- SELECT ELEMENT -------------------------------------------------------------------
2162 function r2:selectElement(sequence, uiName, eltOrder, selectedButtonElt)
2163
2164         local upElement = sequence:find("up_element")
2165         assert(upElement)
2166         local downElement = sequence:find("down_element")
2167         assert(downElement)
2168         local orderElt = sequence:find("element_order")
2169
2170         if selectedButtonElt == nil then
2171                 selectedButtonElt = getUICaller()
2172         end
2173
2174         -- new selected element
2175         if selectedButtonElt.pushed == true then
2176
2177                 if r2:getSelectedEltUIId(uiName) then
2178
2179                         local lastSelectedElement = r2:getSelectedEltUI(uiName)
2180                         assert(lastSelectedElement)
2181
2182                         local lastEltsList = lastSelectedElement.parent
2183                         local editElt = lastEltsList:find("edit_element")
2184                         assert(editElt)
2185
2186                         if r2:getSelectedEltUIId(uiName) == selectedButtonElt.parent.parent.parent.id then
2187                                 return
2188                         end
2189
2190                         lastSelectedElement.active = true
2191                         lastSelectedElement:find("select").pushed = false
2192
2193                         editElt.active = false
2194                 end
2195
2196                 r2:setSelectedEltUIId(uiName, selectedButtonElt.parent.parent.parent.id)
2197
2198                 local selectedElement = selectedButtonElt.parent.parent.parent
2199                 assert(selectedElement)
2200
2201                 if eltOrder then
2202                         upElement.active = true
2203                         downElement.active = true
2204                         orderElt.active = true
2205                 end
2206
2207                 -- update element editor position in list
2208                 local eltsList = sequence:find("elements_list")
2209                 assert(eltsList)
2210                 local editElt = eltsList:find("edit_element")
2211                 assert(editElt)
2212
2213                 local indexSelectedElt = eltsList:getElementIndex(selectedElement)
2214                 local indexEltEditor = eltsList:getElementIndex(editElt)
2215
2216                 if indexEltEditor<indexSelectedElt then
2217                         for i=indexEltEditor, indexSelectedElt-1 do
2218                                 eltsList:downChild(editElt)
2219                         end
2220                 else
2221                         for i=indexSelectedElt, indexEltEditor-2 do
2222                                 eltsList:upChild(editElt)
2223                         end
2224                 end
2225
2226                 editElt.active = true
2227                 selectedElement.active = false
2228
2229         -- cancel current selection
2230         else
2231                 local lastSelectedElement = r2:getSelectedEltUI(uiName)
2232                 r2:setSelectedEltUIId(uiName, nil)
2233
2234                 upElement.active = false
2235                 downElement.active = false
2236                 orderElt.active = false
2237
2238                 local lastEltsList = lastSelectedElement.parent
2239                 local editElt = lastEltsList:find("edit_element")
2240                 assert(editElt)
2241
2242                 editElt.active = false
2243                 lastSelectedElement.active = true
2244         end
2245 end
2246
2247 ------------------ SELECT SEQUENCE ---------------------------------------------------------
2248 function r2:selectElementsSequence(uiName, index)
2249         local eltsWnd = getUI("ui:interface:"..uiName)
2250         assert(eltsWnd)
2251
2252         local sequencesTab = eltsWnd:find("sequence_tabs")
2253         assert(sequencesTab)
2254
2255         if (index>=0) and (sequencesTab.tabButtonNb > index) then
2256                 sequencesTab.selection = tonumber(index)
2257
2258                 local repeatButton = eltsWnd:find("repeat_group"):find("repeat"):find("toggle_butt")
2259                 assert(repeatButton)
2260
2261                 local sequenceUI = sequencesTab:getGroup(index)
2262                 assert(sequenceUI)
2263                 local sequenceInstId = sequenceUI.Env.sequenceId
2264
2265                 if sequenceInstId and r2:getInstanceFromId(sequenceInstId) then
2266                         local sequenceInst = r2:getInstanceFromId(sequenceInstId)
2267                         repeatButton.pushed = (sequenceInst.Repeating == 0)
2268                 end
2269         end
2270 end
2271
2272
2273 ---------------------------------------- Open element editor --------------------------------------
2274 function r2:openElementEditor(uiName, title, baseWindowName)
2275
2276         local elementEditor = r2:getSelectedSequ(uiName):find("edit_element")
2277         assert(elementEditor)
2278
2279         local selectedElement = r2:getSelectedEltUI(uiName)
2280         assert(selectedElement)
2281
2282         elementEditor.active = true
2283         selectedElement.active = false
2284 end
2285
2286 ----------------------------------- Remove elements sequence --------------------------------------
2287 function r2:removeElementsSequence(uiName, elementsTable, sequName)
2288
2289         local eltSequenceUI = getUI("ui:interface:"..uiName)
2290         assert(eltSequenceUI)
2291
2292         local tab = eltSequenceUI:find("sequence_tabs")
2293         assert(tab)
2294
2295         local activeLogicEntity = r2:getSelectedInstance()
2296         assert(activeLogicEntity)
2297         local activitySequences = activeLogicEntity:getBehavior()[elementsTable]
2298
2299         --local seq = sequName
2300
2301         --for i=tab.selection+1,(tab.tabButtonNb-1) do
2302         --      local buttonTab = tab:find("tab"..i)
2303         --      assert(buttonTab)
2304
2305         --      if activitySequences[i].Name == seq..(i+1) then
2306         --              local newText = seq..(i)
2307         --              r2.requestSetNode(activitySequences[i].InstanceId, "Name", newText)
2308         --      end
2309         --end
2310
2311         local sequenceId = r2:getSelectedSequInstId(uiName)
2312         -- request erase node
2313         r2.requestEraseNode(sequenceId, "", -1)
2314
2315         return sequenceId
2316 end
2317
2318 function r2:removeElementsSequenceUI(tabIndex, uiName, elementsTable, sequName)
2319
2320         local wndUI = getUI("ui:interface:"..uiName)
2321         assert(wndUI)
2322
2323         local tab = wndUI:find("sequence_tabs")
2324         assert(tab)
2325
2326         local activeLogicEntity = r2:getSelectedInstance()
2327         assert(activeLogicEntity)
2328         local activitySequences = activeLogicEntity:getBehavior()[elementsTable]
2329
2330         for i=tabIndex+1,(tab.tabButtonNb-1) do
2331                 local buttonTab = tab:find("tab"..i)
2332                 assert(buttonTab)
2333
2334                 buttonTab.params_l = "r2:selectSequenceTab('"..uiName.."', "..tostring(i-1)..")"
2335
2336                 if buttonTab.hardtext == sequName..(i+1) then
2337                         buttonTab.uc_hardtext = sequName..i
2338                 end
2339         end
2340
2341         -- recover name of the future "first sequence"
2342         local firstEltName
2343         local indexName
2344         if tab.tabButtonNb > 1 then
2345                 if tabIndex==0 then
2346                         indexName = 1
2347                 else
2348                         indexName = 0
2349                 end
2350                 --if activitySequences[indexName].Name==sequName..(indexName+1) then
2351                 if r2:getSequenceName(activitySequences[indexName])==sequName..(indexName+1) then
2352                         firstEltName = sequName.."1"
2353                 else
2354                         --firstEltName = activitySequences[indexName].Name
2355                         firstEltName = r2:getSequenceName(activitySequences[indexName])
2356                 end
2357         else
2358                 firstEltName = tostring(i18n.get("uiR2EDSequences"))
2359         end
2360
2361         local selectedElt = r2:getSelectedEltUI(uiName)
2362         if selectedElt and selectedElt.parent.parent.parent.id == r2:getSelectedSequ(uiName).id then
2363                 r2:setSelectedEltUIId(uiName, nil)
2364         end
2365
2366         tab:removeTab(tabIndex)
2367
2368         if tab.tabButtonNb == 0 then
2369                 r2:cleanSequenceEditor(wndUI)
2370         end
2371
2372         return firstEltName
2373 end
2374
2375 function r2:cleanSequenceEditor(eltSequenceUI)
2376
2377         local sepTop = eltSequenceUI:find("sep_top")
2378         assert(sepTop)
2379
2380         local sepBottom = eltSequenceUI:find("sep_bottom")
2381         assert(sepBottom)
2382
2383         local sepLeft = eltSequenceUI:find("sep_left")
2384         assert(sepLeft)
2385
2386         local sepRight = eltSequenceUI:find("sep_right")
2387         assert(sepRight)
2388
2389         local removeSequence = eltSequenceUI:find("remove_sequence_button")
2390         assert(removeSequence)
2391
2392         local editSequence = eltSequenceUI:find("edit_sequence")
2393         assert(editSequence)
2394
2395         sepTop.active = false
2396         sepBottom.active = false
2397         sepLeft.active= false
2398         sepRight.active= false
2399         removeSequence.active = false
2400         editSequence.active = false
2401
2402         local repeatButtonGr = eltSequenceUI:find("repeat_group")
2403         repeatButtonGr.active = false
2404 end
2405
2406 ------------------ new elements sequence  -------------------------------------------------------------
2407 function r2:newElementsSequence(uiName, templateParams, editorEltTemplate, instance, sequName)
2408
2409         local eltSequenceUI = getUI("ui:interface:"..uiName)
2410         assert(eltSequenceUI)
2411
2412         local menu = eltSequenceUI:find("sequence_menu")
2413         assert(menu)
2414
2415         local tab = menu:find("sequence_tabs")
2416         assert(tab)
2417
2418         local newTabNb = tab.tabButtonNb+1
2419         local posParent, posRef, id, hardText, group
2420         if newTabNb == 1 then
2421                 posParent = "parent"
2422                 posRef = "TL TL"
2423         else
2424                 posParent = "tab"..(newTabNb-2)
2425                 posRef = "TR TL"
2426         end
2427
2428         id = "tab"..(newTabNb-1)
2429         local group = "sequence"..r2.sequencesNb
2430
2431         r2.sequencesNb = r2.sequencesNb + 1
2432
2433         local newTabGroup = createUIElement("sequence_elements_template", menu.id, {id=group,
2434                 new_elt=templateParams.newElt, new_elt_text=templateParams.newEltText,
2435                 elt_order_text=templateParams.eltOrderText, up_elt=templateParams.upElt,
2436                 down_elt=templateParams.downElt, max_min_elts=templateParams.maxMinElts,
2437                 down_up_color=templateParams.downUpColor})
2438         assert(newTabGroup)
2439
2440         menu:addGroup(newTabGroup)
2441
2442         newTabGroup.Env.sequenceId = instance.InstanceId
2443
2444         local tabName
2445         if instance.Name~= "" then
2446                 tabName = instance.Name
2447         else
2448                 local comps = instance.Parent
2449                 for i=0, comps.Size-1 do
2450                         if comps[i].InstanceId == instance.InstanceId then
2451                                 tabName = sequName..(i+1)
2452                                 break
2453                         end
2454                 end
2455         end
2456
2457         local newTab = createUIElement("sequence_tab_template", tab.id,
2458                 {id=id, posparent=posParent, posref=posRef, hardtext=tabName, group=group,
2459                  col_pushed =templateParams.colPushed, params_l=templateParams.paramsL})
2460         assert(newTab)
2461
2462         tab:addTab(newTab)
2463
2464         if r2.ownCreatedInstances[instance.InstanceId] == true then
2465                 tab.selection = tab.tabButtonNb-1
2466                 r2.ownCreatedInstances[instance.InstanceId] = nil
2467
2468                 --local repeatButton = eltSequenceUI:find("repeat_group"):find("repeat"):find("toggle_butt")
2469                 --assert(repeatButton)
2470                 --repeatButton.pushed = (instance.Repeating == 0)
2471
2472                 r2:selectElementsSequence(uiName, tab.tabButtonNb-1)
2473         end
2474
2475         if tab.tabButtonNb == 1 then
2476                 local sepTop = menu:find("sep_top")
2477                 assert(sepTop)
2478
2479                 local sepBottom = menu:find("sep_bottom")
2480                 assert(sepBottom)
2481
2482                 local sepLeft = menu:find("sep_left")
2483                 assert(sepLeft)
2484
2485                 local sepRight = menu:find("sep_right")
2486                 assert(sepRight)
2487
2488                 local removeSequence = eltSequenceUI:find("remove_sequence_button")
2489                 assert(removeSequence)
2490
2491                 local editSequence = eltSequenceUI:find("edit_sequence")
2492                 assert(editSequence)
2493
2494                 sepTop.active = true
2495                 sepBottom.active = true
2496                 sepLeft.active= true
2497                 sepRight.active= true
2498                 removeSequence.active = true
2499                 editSequence.active = true
2500
2501                 if uiName == "r2ed_triggers" then   --TEMP TEMP TEMP
2502                         local repeatButtonGr = eltSequenceUI:find("repeat_group")
2503                         repeatButtonGr.active = true
2504                 end                                                                     --TEMP TEMP TEMP
2505         end
2506
2507         local listElements = newTabGroup:find("elements_list")
2508         assert(listElements)
2509         listElements.Env.elementsCount = nil
2510
2511         -- add element editor in list
2512         local newEditorElt = createGroupInstance(editorEltTemplate, listElements.id, {id="edit_element", active="false"})
2513         assert(newEditorElt)
2514         listElements:addChild(newEditorElt)
2515         listElements.parent:updateCoords()
2516
2517         newEditorElt.Env.isEditor = true
2518
2519         newEditorElt.active = false
2520
2521         return newTabGroup
2522 end
2523
2524 ---------------------------- new element --------------------------------------------------------------
2525 function r2:newTriggerElement(uiName, elementName, templateParams, sequenceUI, instanceId)
2526
2527         if sequenceUI == nil then
2528                 eltSequenceUI = getUI("ui:interface:"..uiName)
2529                 assert(eltSequenceUI)
2530
2531                 local tab = eltSequenceUI:find("sequence_tabs")
2532                 assert(tab)
2533
2534                 local sequenceUI = eltSequenceUI:find(tab.associatedGroupSelection)
2535         end
2536         assert(sequenceUI)
2537
2538         local newElement = r2:newElement(sequenceUI, elementName, templateParams, true)
2539
2540         newElement.Env.elementId = instanceId
2541
2542         if r2.ownCreatedInstances[instanceId] == true then
2543                 newElement:find("select").pushed = true
2544                 r2:selectTriggerElement(sequenceUI, uiName, newElement:find("select"))
2545                 r2.ownCreatedInstances[instanceId] = nil
2546
2547                 if uiName == "r2ed_triggers" then
2548                         r2:updateActivityEditor()
2549                 elseif uiName == "r2ed_chat_sequence" then
2550                         r2:updateChatEditor()
2551                 end
2552         end
2553
2554         r2:maximizeMinimizeElement(uiName, newElement)
2555
2556         return newElement
2557 end
2558
2559 ---------------------------- new base element --------------------------------------------------------------
2560 function r2:newElement(sequence, elementName, templateParams, eltOrder)
2561
2562         local listElements = sequence:find("elements_list")
2563         assert(listElements)
2564
2565         -- counter for element group id
2566         if listElements.Env.elementsCount == nil then
2567                 listElements.Env.elementsCount = 0
2568                 listElements.Env.elementsNb = 1
2569         else
2570                 listElements.Env.elementsCount = listElements.Env.elementsCount+1
2571                 listElements.Env.elementsNb = listElements.Env.elementsNb+1
2572         end
2573
2574         local elementId = "elt"..listElements.Env.elementsCount
2575
2576         local hardText = elementName.." "..listElements.Env.elementsNb.." : "
2577
2578         -- create new element
2579         local newElement = createGroupInstance("element_template", listElements.id,
2580                 {id=elementId, posref="TL TL", x="0", y="0", sizeref="w", hardtext=hardText,
2581                  select_elt=templateParams.selectElt, open_elt_editor=templateParams.openEltEditor,
2582                  max_min_elt=templateParams.maxMinElt, remove_elt=templateParams.removeElt, open_chat=templateParams.openChat,
2583                  col_over=templateParams.colOver, col_pushed=templateParams.colPushed})
2584
2585         -- add element to list
2586         listElements:addChild(newElement)
2587         listElements.parent:updateCoords()
2588
2589         -- active global minimize / maximize button
2590         if listElements.childrenNb == 2 then
2591                 local maxElts = sequence:find("maximize_elements")
2592                 assert(maxElts)
2593                 maxElts.active = true
2594
2595                 if eltOrder then
2596
2597                         local elementOrder = sequence:find("element_order")
2598                         assert(elementOrder)
2599                         elementOrder.active=true
2600                 end
2601         end
2602
2603         -- scroll goes down to new element
2604         local sequenceContent = newElement.parent.parent.parent
2605         assert(sequenceContent)
2606
2607         local scrollBar = sequenceContent:find("scroll_objects")
2608         assert(scrollBar)
2609         scrollBar.trackPos = 0
2610
2611         -- target sroll text
2612         local scroll = newElement:find("scroll_bar_text")
2613         assert(scroll)
2614
2615         local scrollText = newElement:find("scroll_text_gr")
2616         assert(scrollText)
2617         scroll:setTarget(scrollText.id)
2618
2619         return newElement
2620 end
2621
2622 ------------------ OPEN SEQUENCE EDITOR  --------------------------------------------------
2623 function r2:openSequenceEditor(uiName, editorName)
2624
2625         local editor = getUI("ui:interface:"..editorName)
2626         assert(editor)
2627
2628         local eltsUI = getUI("ui:interface:"..uiName)
2629         assert(eltsUI)
2630
2631         editor.x = eltsUI.x
2632         editor.y = eltsUI.y
2633         editor.active = true
2634
2635         -- update edit box text with current sequence name
2636         local editName = editor:find("sequence_name"):find("edit_box_group")
2637         assert(editName)
2638
2639         local tab = eltsUI:find("sequence_tabs")
2640         assert(tab)
2641
2642         local buttonTab = tab:find("tab"..tab.selection)
2643         assert(buttonTab)
2644
2645         editName.uc_input_string = buttonTab.uc_hardtext
2646 end
2647
2648 ------------------ SET SEQUENCE NAME  -----------------------------------------------------
2649 function r2:setSequenceName(uiName, editorName)
2650
2651         local editor = getUI("ui:interface:"..editorName)
2652         assert(editor)
2653
2654         local editName = editor:find("sequence_name"):find("edit_box_group")
2655         assert(editName)
2656
2657         local name = editName.input_string
2658
2659         local sequenceInstId = r2:getSelectedSequInstId(uiName)
2660         r2.requestSetNode(sequenceInstId, "Name", name)
2661 end
2662
2663 function r2:updateSequenceName(uiName, instance)
2664
2665         --local name = instance.Name
2666         local name = r2:getSequenceName(instance)
2667         local sequInstId = instance.InstanceId
2668
2669         local eltsUI = getUI("ui:interface:"..uiName)
2670         assert(eltsUI)
2671
2672         local tab = eltsUI:find("sequence_tabs")
2673         assert(tab)
2674
2675         local tabId
2676         for i=0, tab.tabButtonNb-1 do
2677                 local sequenceUI = tab:getGroup(i)
2678                 if sequenceUI.Env.sequenceId == sequInstId then
2679                         tabId = i
2680                         break
2681                 end
2682         end
2683
2684         local buttonTab = tab:find("tab"..tabId)
2685         assert(buttonTab)
2686
2687         buttonTab.uc_hardtext = name
2688
2689         if uiName == "r2ed_triggers" then
2690                 r2:updateSequencesButtonBar(tabId, name)
2691         end
2692 end
2693
2694 function r2:updateSequenceRepeatingOption(uiName, instance)
2695
2696         local sequenceUI = r2:getSelectedSequ(uiName)
2697
2698         if sequenceUI.Env.sequenceId == instance.InstanceId then
2699
2700                 local eltsUI = getUI("ui:interface:"..uiName)
2701                 local repeatButton = eltsUI:find("repeat_group"):find("repeat"):find("toggle_butt")
2702                 repeatButton.pushed = (instance.Repeating == 0)
2703         end
2704 end
2705
2706
2707 --------------------------------------------------------------------------------------------------
2708 -------------------------- ACTIVE LOGIC ENTITY DisplayerProperties -----------------------------------------
2709 --------------------------------------------------------------------------------------------------
2710
2711 local activeLogicEntityPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
2712
2713 ------------------------------------------------
2714 function activeLogicEntityPropertySheetDisplayerTable:onPostCreate(instance)
2715 end
2716 ------------------------------------------------
2717 function activeLogicEntityPropertySheetDisplayerTable:onErase(instance)
2718 end
2719 ------------------------------------------------
2720 function activeLogicEntityPropertySheetDisplayerTable:onPreHrcMove(instance)
2721 end
2722 ------------------------------------------------
2723 function activeLogicEntityPropertySheetDisplayerTable:onPostHrcMove(instance)
2724 end
2725 ------------------------------------------------
2726 function activeLogicEntityPropertySheetDisplayerTable:onFocus(instance, hasFocus)
2727 end
2728
2729 ------------------------------------------------
2730 r2.activitiesAndChatsUIUpdate = false
2731 function activeLogicEntityPropertySheetDisplayerTable:onSelect(instance, isSelected)
2732
2733         r2:logicEntityPropertySheetDisplayer():onSelect(instance, isSelected)
2734
2735         local triggersUI = getUI("ui:interface:r2ed_triggers")
2736         assert(triggersUI)
2737
2738         if not isSelected then
2739                 triggersUI.active = false
2740                 r2:closeMiniActivityView()
2741                 r2:closeChatSequencesUI()
2742
2743                 r2:cleanActivitiesAndChatsUI()
2744                 r2:cleanLogicEntityUI()
2745         else
2746                 r2.activitiesAndChatsUIUpdate = false
2747         end
2748 end
2749
2750 r2.callSetSaysWhat = true
2751 ------------------------------------------------
2752 function r2:cleanActivitiesAndChatsUI()
2753
2754         -- update chat sequence combo box
2755         local triggersUI = getUI("ui:interface:r2ed_triggers")
2756         assert(triggersUI)
2757         local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
2758         assert(chatSequencesUI)
2759
2760         -- remove all tabs
2761         local sequenceMenu = triggersUI:find("sequence_menu")
2762         assert(sequenceMenu)
2763
2764         local tabActivities = triggersUI:find("sequence_tabs")
2765         assert(tabActivities)
2766
2767         for i=0, tabActivities.tabButtonNb-1 do
2768                 local groupTab = tabActivities:getGroup(i)
2769                 assert(groupTab)
2770                 sequenceMenu:delGroup(groupTab)
2771         end
2772
2773         tabActivities:removeAll()
2774         r2:setSelectedEltUIId("r2ed_triggers", nil)
2775         r2:cleanSequenceEditor(triggersUI)
2776
2777         -- delete chat sequences
2778         sequenceMenu = chatSequencesUI:find("sequence_menu")
2779         assert(sequenceMenu)
2780
2781         local tabChats = chatSequencesUI:find("sequence_tabs")
2782         assert(tabChats)
2783
2784         for i=0, tabChats.tabButtonNb-1 do
2785                 local groupTab = tabChats:getGroup(i)
2786                 assert(groupTab)
2787                 sequenceMenu:delGroup(groupTab)
2788         end
2789
2790         tabChats:removeAll()
2791         r2:setSelectedEltUIId("r2ed_chat_sequence", nil)
2792         r2:cleanSequenceEditor(chatSequencesUI)
2793 end
2794
2795 function r2:updateActivitiesAndChatsUI(instance)
2796
2797         if r2.activitiesAndChatsUIUpdate==true then
2798                 return
2799         end
2800
2801         r2.activitiesAndChatsUIUpdate = true
2802
2803         if r2.lastSelectedActivitySequence==nil then
2804
2805                 r2:cleanActivitiesAndChatsUI()
2806
2807                 -- update chat sequence combo box
2808                 local triggersUI = getUI("ui:interface:r2ed_triggers")
2809                 assert(triggersUI)
2810                 local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
2811                 assert(chatSequencesUI)
2812
2813                 -- remove all tabs
2814                 local tabActivities = triggersUI:find("sequence_tabs")
2815                 assert(tabActivities)
2816
2817                 -- delete chat sequences
2818                 local tabChats = chatSequencesUI:find("sequence_tabs")
2819                 assert(tabChats)
2820
2821
2822                 local activitySequences = instance:getBehavior().Activities
2823                 local chatSequences = instance:getBehavior().ChatSequences
2824
2825                 -- build sequences of selected NPC group
2826                 local uiName = "r2ed_triggers"
2827
2828                 for s = 0, activitySequences.Size - 1 do
2829                         local sequence = activitySequences[s]
2830                         r2:newActivitiesSequence(false, sequence, true)
2831                 end
2832
2833                 if tabActivities.tabButtonNb>1 then
2834                         tabActivities.selection = 0
2835                         r2:selectElementsSequence(uiName, 0)
2836                 end
2837                 for s=0, tabActivities.tabButtonNb-1 do
2838                         local sequenceUI = tabActivities:getGroup(s)
2839                         assert(sequenceUI)
2840
2841                         local eltsList = sequenceUI:find("elements_list")
2842                         assert(eltsList)
2843                         if eltsList.childrenNb > 1 then
2844                                 local firstElt = eltsList:getChild(1)
2845                                 local selectedButton = firstElt:find("select")
2846                                 selectedButton.pushed = true
2847
2848                                 r2:selectElement(sequenceUI, uiName, true, selectedButton)
2849
2850                                 r2:updateActivityEditor()
2851
2852                                 break
2853                         end
2854                 end
2855
2856                 uiName = "r2ed_chat_sequence"
2857                 r2.callSetSaysWhat = false
2858                 for s = 0, chatSequences.Size - 1 do
2859                         local sequence = chatSequences[s]
2860                         r2:newChatsSequence(false, sequence, true)
2861                 end
2862                 r2.callSetSaysWhat = true
2863                 if tabChats.tabButtonNb>1 then
2864                         tabChats.selection = 0
2865                         r2:selectElementsSequence(uiName, 0)
2866                 end
2867                 for s=0, tabChats.tabButtonNb-1 do
2868                         local sequenceUI = tabChats:getGroup(s)
2869                         assert(sequenceUI)
2870
2871                         local eltsList = sequenceUI:find("elements_list")
2872                         assert(eltsList)
2873                         if eltsList.childrenNb > 1 then
2874                                 local firstElt = eltsList:getChild(1)
2875                                 local selectedButton = firstElt:find("select")
2876                                 r2.callSetSaysWhat = false
2877                                 selectedButton.pushed = true
2878
2879                                 r2:selectElement(sequenceUI, uiName, true, selectedButton)
2880
2881                                 r2.callSetSaysWhat = true
2882
2883                                 r2:updateChatEditor()
2884                         end
2885                 end
2886
2887                 triggersUI.uc_title = tostring(i18n.get("uiR2EDActivitySequenceEditor")) .. r2:getSelectedInstance().Name
2888                 chatSequencesUI.uc_title = tostring(i18n.get("uiR2EDChatSequenceEditor")) .. r2:getSelectedInstance().Name
2889         end
2890 end
2891
2892 ------------------------------------------------
2893 function activeLogicEntityPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
2894
2895         r2:logicEntityPropertySheetDisplayer():onAttrModified(instance, attributeName)
2896
2897         if not r2.activitiesAndChatsUIUpdate or instance ~= r2:getSelectedInstance() then
2898                 return
2899         end
2900
2901         if attributeName == "Name" then
2902
2903                 local triggersUI = getUI("ui:interface:r2ed_triggers")
2904                 assert(triggersUI)
2905
2906                 local chatSequencesUI = getUI("ui:interface:r2ed_chat_sequence")
2907                 assert(chatSequencesUI)
2908
2909                 triggersUI.uc_title = tostring(i18n.get("uiR2EDActivitySequenceEditor")) .. instance[attributeName]
2910                 chatSequencesUI.uc_title = tostring(i18n.get("uiR2EDChatSequenceEditor")) .. instance[attributeName]
2911         end
2912 end
2913
2914 ------------------------------------------------
2915 function r2:activeLogicEntityPropertySheetDisplayer()
2916         return activeLogicEntityPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
2917 end
2918
2919
2920 --------------------------------------------------------------------------------------------------
2921 -------------------------- NPC GROUP DisplayerProperties -----------------------------------------
2922 --------------------------------------------------------------------------------------------------
2923
2924 local npcGroupPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
2925
2926 ------------------------------------------------
2927 function npcGroupPropertySheetDisplayerTable:onPostCreate(instance)
2928 end
2929 ------------------------------------------------
2930 function npcGroupPropertySheetDisplayerTable:onErase(instance)
2931 end
2932 ------------------------------------------------
2933 function npcGroupPropertySheetDisplayerTable:onPreHrcMove(instance)
2934 end
2935 ------------------------------------------------
2936 function npcGroupPropertySheetDisplayerTable:onPostHrcMove(instance)
2937 end
2938 ------------------------------------------------
2939 function npcGroupPropertySheetDisplayerTable:onFocus(instance, hasFocus)
2940 end
2941
2942 ------------------------------------------------
2943 function npcGroupPropertySheetDisplayerTable:onSelect(instance, isSelected)
2944         r2:activeLogicEntityPropertySheetDisplayer():onSelect(instance, isSelected)
2945 end
2946
2947 ------------------------------------------------
2948 function npcGroupPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
2949         r2:activeLogicEntityPropertySheetDisplayer():onAttrModified(instance, attributeName)
2950 end
2951
2952 ------------------------------------------------
2953 function r2:npcGroupPropertySheetDisplayer()
2954         return npcGroupPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
2955 end
2956
2957
2958
2959
2960
2961
2962 --------------------------------------------------------------------------------------------------
2963 -------------------------------- ACTIVITY SEQUENCE DisplayerProperties ---------------------------
2964 --------------------------------------------------------------------------------------------------
2965 local activitySequencePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
2966
2967 ------------------------------------------------
2968 function activitySequencePropertySheetDisplayerTable:onPostCreate(instance)
2969
2970         local activeLogicEntity = r2:getSelectedInstance()
2971         local activeLogicEntityParent = instance.Parent.Parent.Parent
2972
2973         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
2974                 return
2975         end
2976
2977         r2:newActivitiesSequence(false, instance, false)
2978 end
2979 ------------------------------------------------
2980 function activitySequencePropertySheetDisplayerTable:onErase(instance)
2981
2982         local activeLogicEntity = r2:getSelectedInstance()
2983         local activeLogicEntityParent = instance.Parent.Parent.Parent
2984
2985         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
2986                 return
2987         end
2988
2989         local triggersUI = getUI("ui:interface:r2ed_triggers")
2990         assert(triggersUI)
2991
2992         local sequenceTabs = triggersUI:find("sequence_tabs")
2993         assert(sequenceTabs)
2994
2995         local sequIndex
2996         for i=0,sequenceTabs.tabButtonNb-1 do
2997                 local sequence = sequenceTabs:getGroup(i)
2998                 if sequence.Env.sequenceId == instance.InstanceId then
2999                         sequIndex = i
3000                         break
3001                 end
3002         end
3003
3004         if sequIndex~=nil then
3005                 r2:removeActivitiesSequenceUI(sequIndex)
3006         end
3007 end
3008 ------------------------------------------------
3009 function activitySequencePropertySheetDisplayerTable:onPreHrcMove(instance)
3010 end
3011 ------------------------------------------------
3012 function activitySequencePropertySheetDisplayerTable:onPostHrcMove(instance)
3013 end
3014 ------------------------------------------------
3015 function activitySequencePropertySheetDisplayerTable:onFocus(instance, hasFocus)
3016 end
3017
3018 ------------------------------------------------
3019 function activitySequencePropertySheetDisplayerTable:onSelect(instance, isSelected)
3020 end
3021
3022 ------------------------------------------------
3023 function activitySequencePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
3024
3025         local activeLogicEntity = r2:getSelectedInstance()
3026         local activeLogicEntityParent = instance.Parent.Parent.Parent
3027
3028         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3029                 return
3030         end
3031
3032         if attributeName == "Name" then
3033                 r2:updateSequenceName("r2ed_triggers", instance)
3034         elseif attributeName == "Repeating" then
3035                 r2:updateSequenceRepeatingOption("r2ed_triggers", instance)
3036         end
3037 end
3038
3039 ------------------------------------------------
3040 function r2:activitySequencePropertySheetDisplayer()
3041         return activitySequencePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
3042 end
3043
3044
3045 --------------------------------------------------------------------------------------------------
3046 -------------------------------- CHAT SEQUENCE DisplayerProperties ---------------------------
3047 --------------------------------------------------------------------------------------------------
3048 local chatSequencePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
3049
3050 ------------------------------------------------
3051 function chatSequencePropertySheetDisplayerTable:onPostCreate(instance)
3052
3053         local activeLogicEntity = r2:getSelectedInstance()
3054         local activeLogicEntityParent = instance.Parent.Parent.Parent
3055
3056         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3057                 return
3058         end
3059
3060         r2:newChatsSequence(false, instance)
3061 end
3062 ------------------------------------------------
3063 function chatSequencePropertySheetDisplayerTable:onErase(instance)
3064
3065         local activeLogicEntity = r2:getSelectedInstance()
3066         local activeLogicEntityParent = instance.Parent.Parent.Parent
3067
3068         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3069                 return
3070         end
3071
3072         local chatsUI = getUI("ui:interface:r2ed_chat_sequence")
3073         assert(chatsUI)
3074
3075         local sequenceTabs = chatsUI:find("sequence_tabs")
3076         assert(sequenceTabs)
3077
3078         local sequIndex
3079         for i=0,sequenceTabs.tabButtonNb-1 do
3080                 local sequence = sequenceTabs:getGroup(i)
3081                 if sequence.Env.sequenceId == instance.InstanceId then
3082                         sequIndex = i
3083                         break
3084                 end
3085         end
3086
3087         if sequIndex~=nil then
3088                 r2:removeChatsSequenceUI(sequIndex)
3089         end
3090
3091         r2:updateMiniActivityView()
3092 end
3093 ------------------------------------------------
3094 function chatSequencePropertySheetDisplayerTable:onPreHrcMove(instance)
3095 end
3096 ------------------------------------------------
3097 function chatSequencePropertySheetDisplayerTable:onPostHrcMove(instance)
3098 end
3099 ------------------------------------------------
3100 function chatSequencePropertySheetDisplayerTable:onFocus(instance, hasFocus)
3101 end
3102
3103 ------------------------------------------------
3104 function chatSequencePropertySheetDisplayerTable:onSelect(instance, isSelected)
3105 end
3106
3107 ------------------------------------------------
3108 function chatSequencePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
3109
3110         local activeLogicEntity = r2:getSelectedInstance()
3111         local activeLogicEntityParent = instance.Parent.Parent.Parent
3112
3113         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3114                 return
3115         end
3116
3117         if attributeName == "Name" then
3118                 r2:updateSequenceName("r2ed_chat_sequence", instance)
3119         elseif attributeName == "Repeating" then
3120                 r2:updateSequenceRepeatingOption("r2ed_chat_sequence", instance)
3121         end
3122 end
3123
3124 ------------------------------------------------
3125 function r2:chatSequencePropertySheetDisplayer()
3126         return chatSequencePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
3127 end
3128
3129
3130 --------------------------------------------------------------------------------------------------
3131 -------------------------------- ACTIVITY STEP DisplayerProperties--------------------------------
3132 --------------------------------------------------------------------------------------------------
3133 local activityStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
3134
3135 ------------------------------------------------
3136 function activityStepPropertySheetDisplayerTable:onPostCreate(instance)
3137
3138         local activeLogicEntity = r2:getSelectedInstance()
3139         local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
3140
3141         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3142                 return
3143         end
3144
3145         local activitySequInst = instance.Parent.Parent
3146
3147         local triggersUI = getUI("ui:interface:r2ed_triggers")
3148         assert(triggersUI)
3149
3150         local sequenceTabs = triggersUI:find("sequence_tabs")
3151         assert(sequenceTabs)
3152
3153         local sequenceUI
3154         for i=0,sequenceTabs.tabButtonNb-1 do
3155                 local sequence = sequenceTabs:getGroup(i)
3156                 if sequence.Env.sequenceId == activitySequInst.InstanceId then
3157                         sequenceUI = sequence
3158                         break
3159                 end
3160         end
3161
3162         r2:newActivity(false, nil, instance, sequenceUI)
3163 end
3164 ------------------------------------------------
3165 function activityStepPropertySheetDisplayerTable:onErase(instance)
3166
3167         local activeLogicEntity = r2:getSelectedInstance()
3168         local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
3169
3170         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3171                 return
3172         end
3173
3174         local sequenceUI, elementUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_triggers")
3175
3176         if elementUI ~= nil then
3177                 r2:removeActivityUI(sequenceUI, elementUI)
3178         end
3179 end
3180 ------------------------------------------------
3181 function activityStepPropertySheetDisplayerTable:onPreHrcMove(instance)
3182 end
3183 ------------------------------------------------
3184 function activityStepPropertySheetDisplayerTable:onPostHrcMove(instance)
3185
3186         local activeLogicEntity = r2:getSelectedInstance()
3187         local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
3188
3189         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3190                 return
3191         end
3192
3193         local sequenceUI, activityStepUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_triggers")
3194         if activityStepUI then
3195                 r2:downUpElement(activityStepUI, "r2ed_triggers")
3196         end
3197 end
3198 ------------------------------------------------
3199 function activityStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)
3200 end
3201
3202 ------------------------------------------------
3203 function activityStepPropertySheetDisplayerTable:onSelect(instance, isSelected)
3204 end
3205
3206 ------------------------------------------------
3207 function activityStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
3208
3209         local activeLogicEntity = r2:getSelectedInstance()
3210         local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
3211
3212         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3213                 return
3214         end
3215
3216         local sequenceUI, elementUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_triggers")
3217         if elementUI then
3218                 r2:updateActivityChatSequence(elementUI)
3219         end
3220 end
3221
3222 ------------------------------------------------
3223 function activityStepPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
3224
3225         if refIdName == "ActivityZoneId" then
3226                 r2.requestSetNode(instance.InstanceId, "Activity", "Stand Still")
3227                 r2.requestSetNode(instance.InstanceId, "ActivityZoneId", r2.RefId(""))
3228                 r2.requestSetNode(instance.InstanceId, "TimeLimit", "No Limit")
3229                 r2.requestSetNode(instance.InstanceId, "TimeLimitValue", "")
3230         elseif refIdName == "Chat" then
3231                 r2.requestSetNode(instance.InstanceId, "Chat", r2.RefId(""))
3232         end
3233 end
3234 ------------------------------------------------
3235 function activityStepPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
3236 end
3237
3238 -------------------------------------------------
3239 function r2:activityStepPropertySheetDisplayer()
3240         return activityStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
3241 end
3242
3243
3244
3245 --------------------------------------------------------------------------------------------------
3246 -------------------------------- CHAT STEP DisplayerProperties------------------------------------
3247 --------------------------------------------------------------------------------------------------
3248 local chatStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
3249
3250 ------------------------------------------------
3251 function chatStepPropertySheetDisplayerTable:onPostCreate(instance)
3252
3253         local activeLogicEntity = r2:getSelectedInstance()
3254         local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
3255
3256         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3257                 return
3258         end
3259
3260         local chatSequInst = instance.Parent.Parent
3261
3262         local chatsUI = getUI("ui:interface:r2ed_chat_sequence")
3263         assert(chatsUI)
3264
3265         local sequenceTabs = chatsUI:find("sequence_tabs")
3266         assert(sequenceTabs)
3267
3268         local sequenceUI
3269         for i=0,sequenceTabs.tabButtonNb-1 do
3270                 local sequence = sequenceTabs:getGroup(i)
3271                 if sequence.Env.sequenceId == chatSequInst.InstanceId then
3272                         sequenceUI = sequence
3273                         break
3274                 end
3275         end
3276
3277         r2:newChat(false, instance, sequenceUI)
3278 end
3279 ------------------------------------------------
3280 function chatStepPropertySheetDisplayerTable:onErase(instance)
3281
3282         local activeLogicEntity = r2:getSelectedInstance()
3283         local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
3284
3285         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3286                 return
3287         end
3288
3289         local sequenceUI, elementUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_chat_sequence")
3290
3291         if elementUI ~= nil then
3292                 local chatStepInst = r2:getInstanceFromId(elementUI.Env.elementId)
3293                 assert(chatStepInst)
3294                 r2:updateActivitiesWhithThisChatSequence(chatStepInst, true)
3295                 r2:removeElementUI(sequenceUI, "r2ed_chat_sequence", elementUI)
3296         end
3297 end
3298 ------------------------------------------------
3299 function chatStepPropertySheetDisplayerTable:onPreHrcMove(instance)
3300 end
3301 ------------------------------------------------
3302 function chatStepPropertySheetDisplayerTable:onPostHrcMove(instance)
3303
3304         local activeLogicEntity = r2:getSelectedInstance()
3305         local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
3306
3307         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3308                 return
3309         end
3310
3311         r2:updateActivitiesWhithThisChatSequence(instance, false)
3312
3313         local sequenceUI, chatStepUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_chat_sequence")
3314         if chatStepUI then
3315                 r2:downUpElement(chatStepUI, "r2ed_chat_sequence")
3316         end
3317 end
3318 ------------------------------------------------
3319 function chatStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)
3320 end
3321
3322 ------------------------------------------------
3323 function chatStepPropertySheetDisplayerTable:onSelect(instance, isSelected)
3324 end
3325
3326 ------------------------------------------------
3327 function chatStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
3328
3329         local activeLogicEntity = r2:getSelectedInstance()
3330         local activeLogicEntityParent = instance.Parent.Parent.Parent.Parent.Parent
3331
3332         if not r2.activitiesAndChatsUIUpdate or activeLogicEntity==nil or activeLogicEntity ~= activeLogicEntityParent then
3333                 return
3334         end
3335
3336         local sequenceUI, chatStepUI = r2:findSequenceAndElementUIFromInstance(instance, "r2ed_chat_sequence")
3337         if chatStepUI then
3338                 r2:updateChatText(chatStepUI)
3339         end
3340 end
3341
3342 function r2:findSequenceAndElementUIFromInstance(instance, uiName)
3343
3344         local sequenceInst = instance.Parent.Parent
3345
3346         local wndUI = getUI("ui:interface:"..uiName)
3347         assert(wndUI)
3348
3349         local sequenceTabs = wndUI:find("sequence_tabs")
3350         assert(sequenceTabs)
3351
3352         local sequenceUI
3353         for i=0,sequenceTabs.tabButtonNb-1 do
3354                 local sequence = sequenceTabs:getGroup(i)
3355                 if sequence.Env.sequenceId == sequenceInst.InstanceId then
3356                         sequenceUI = sequence
3357                         break
3358                 end
3359         end
3360
3361         if sequenceUI ~= nil then
3362                 local eltsList = sequenceUI:find("elements_list")
3363                 assert(eltsList)
3364
3365                 for i=0,eltsList.childrenNb-1 do
3366                         local element = eltsList:getChild(i)
3367                         if element.Env.elementId == instance.InstanceId then
3368                                 return sequenceUI, element
3369                         end
3370                 end
3371         end
3372 end
3373
3374 --------------------------------------------------
3375 function r2:chatStepPropertySheetDisplayer()
3376         return chatStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
3377 end
3378
3379
3380
3381 --------------------------------------------------------------------------------------------------
3382 -------------------------------- CHAT ACTION DisplayerProperties -----------------------
3383 --------------------------------------------------------------------------------------------------
3384 local chatActionPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
3385
3386 ------------------------------------------------
3387 function chatActionPropertySheetDisplayerTable:onPostCreate(instance)
3388 end
3389 ------------------------------------------------
3390 function chatActionPropertySheetDisplayerTable:onErase(instance)
3391 end
3392 ------------------------------------------------
3393 function chatActionPropertySheetDisplayerTable:onPreHrcMove(instance)
3394 end
3395 ------------------------------------------------
3396 function chatActionPropertySheetDisplayerTable:onPostHrcMove(instance)
3397 end
3398 ------------------------------------------------
3399 function chatActionPropertySheetDisplayerTable:onFocus(instance, hasFocus)
3400 end
3401
3402 ------------------------------------------------
3403 function chatActionPropertySheetDisplayerTable:onSelect(instance, isSelected)
3404 end
3405
3406 ------------------------------------------------
3407 function chatActionPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
3408 end
3409
3410 ------------------------------------------------
3411 function chatActionPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
3412         if refIdName == "Who" then
3413                 r2.requestSetNode(instance.InstanceId, "Who", r2.RefId(""))
3414                 r2.requestSetNode(instance.InstanceId, "Says", "")
3415                 r2.requestSetNode(instance.InstanceId, "Emote", "")
3416                 r2.requestSetNode(instance.InstanceId, "Facing", r2.RefId(""))
3417         elseif refIdName == "Facing" then
3418                 r2.requestSetNode(instance.InstanceId, "Facing", r2.RefId(""))
3419         end
3420 end
3421 ------------------------------------------------
3422 function chatActionPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
3423 end
3424
3425 ------------------------------------------------
3426 function r2:chatActionPropertySheetDisplayer()
3427         return chatActionPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
3428 end
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440 r2.lastSelectedActivitySequence = nil
3441
3442 r2.activityTexture = {  ["Follow Route"]        = "r2_mini_activity_follow_road.tga",
3443                                                 ["Patrol"]                      = "r2_mini_activity_patrol_road.tga",
3444                                                 ["Repeat Road"]         = "r2_mini_activity_repeat_road.tga",
3445                                                 ["Wander"]                      = "r2_mini_activity_wander_zone.tga",
3446                                                 ["Stand Still"]         = "r2_mini_activity_stand_still.tga",
3447 --                                              ["Inactive"]            = "r2_mini_activity_inactive.tga"
3448                                         }
3449
3450 ---------------------------------------------------------------------------------------------------------
3451 -- Show the mini activity view for this instance
3452 function r2:setupMiniActivityView(instance)
3453         if instance and instance:isKindOf("ActiveLogicEntity") then
3454                 local selectedTab = 0
3455                 if r2.lastSelectedActivitySequence then
3456                         selectedTab = r2.lastSelectedActivitySequence
3457                 end
3458                 r2:selectActivitiesSequence(selectedTab)
3459                 r2:updateSequencesButtonBar(selectedTab)
3460         end
3461 end
3462
3463 ------------------ SELECT ACTIVITY SEQUENCE ---------------------------------------------------------
3464 function r2:selectActivitiesSequence(index)
3465         r2:selectElementsSequence("r2ed_triggers", index)
3466         r2:openAndUpdateMiniActivityView(index)
3467 end
3468
3469 ------------------ UPDATE SEQUENCES BUTTON BAR ---------------------------------------------------------
3470 function r2:updateSequencesButtonBar(index, sequenceName)
3471
3472         local selectBar = getUI("ui:interface:r2ed_select_bar")
3473         assert(selectBar)
3474
3475         local sequencesButton = selectBar:find("sequences")
3476         assert(sequencesButton)
3477
3478         local activeLogicEntity = r2:getSelectedInstance()
3479         if activeLogicEntity then
3480                 if sequenceName==nil and (index >=0) and (index < activeLogicEntity:getBehavior().Activities.Size) then
3481                         local activitySequence = activeLogicEntity:getBehavior().Activities[index]
3482                         assert(activitySequence)
3483                         --sequencesButton.uc_hardtext = activitySequence.Name
3484                         sequencesButton.uc_hardtext = r2:getSequenceName(activitySequence)
3485                 elseif sequenceName~= nil then
3486                         sequencesButton.uc_hardtext = sequenceName
3487                 else
3488                         sequencesButton.uc_hardtext = i18n.get("uiR2EDSequences")
3489                 end
3490         end
3491 end
3492
3493
3494 function r2:newMiniActivitySequence()
3495         return r2:newActivitiesSequence(true)
3496 end
3497
3498 function r2:openAndUpdateMiniActivityView(index)
3499         r2:openMiniActivityView()
3500         -- update activities list
3501
3502         r2:updateMiniActivityView(index)
3503 end
3504
3505 function r2:openMiniActivityView()
3506         local triggersUI = getUI("ui:interface:r2ed_triggers")
3507         assert(triggersUI)
3508
3509         local selectedInst = r2:getSelectedInstance()
3510
3511         if selectedInst and not selectedInst:isBotObject() and not selectedInst:isPlant() and not triggersUI.active then
3512                 local miniActivityView = getUI("ui:interface:r2ed_mini_activity_view")
3513                 assert(miniActivityView)
3514                 miniActivityView.active = true
3515         end
3516 end
3517
3518
3519 function r2:updateMiniActivityView(index)
3520
3521         local miniActivityView = getUI("ui:interface:r2ed_mini_activity_view")
3522         assert(miniActivityView)
3523
3524         local miniActivities = miniActivityView:find("mini_activities")
3525         assert(miniActivities)
3526
3527         local noActivityLabel = miniActivityView:find("no_activity")
3528         assert(noActivityLabel)
3529
3530         local startCount = 0
3531         local sequence
3532         if index~=nil then
3533                 local activities = r2:getSelectedInstance():getBehavior().Activities
3534                 if index < activities.Size then
3535                         sequence = activities[index]
3536                 end
3537         else
3538                 sequence = r2:getSelectedSequInst("r2ed_triggers")
3539         end
3540
3541         if sequence~=nil then
3542
3543                 --label "No activity"
3544                 if sequence.Components.Size == 0 then
3545                         noActivityLabel.active = true
3546                         noActivityLabel.uc_hardtext = tostring(i18n.get("uiR2EdNoActivity"))
3547                 else
3548                         noActivityLabel.active = false
3549                 end
3550
3551                 for i=0, sequence.Components.Size-1 do
3552
3553                         local activityInst = sequence.Components[i]
3554                         assert(activityInst)
3555
3556                         if activityInst then
3557
3558                                 local activityIndex = i
3559                                 if afterEltEditor==true then activityIndex = i-1 end
3560
3561                                 local miniActivity = miniActivities[tostring(activityIndex)]
3562                                 assert(miniActivity)
3563
3564                                 miniActivity.active = true
3565                                 miniActivity.Env.id = activityIndex
3566
3567                                 -- chat button
3568                                 local chatButton = miniActivity:find("chat_sequence"):find("button")
3569                                 assert(chatButton)
3570                                 if tostring(activityInst.Chat) ~= "" then
3571                                         local chatTexture = "r2_mini_activity_chat.tga"
3572                                         chatButton.texture = chatTexture
3573                                         chatButton.texture_pushed = chatTexture
3574                                         chatButton.texture_over = chatTexture
3575                                 else
3576                                         local chatTexture = "r2_mini_activity_empty_chat.tga"
3577                                         chatButton.texture = chatTexture
3578                                         chatButton.texture_pushed = chatTexture
3579                                         chatButton.texture_over = chatTexture
3580                                 end
3581
3582                                 -- activity type button
3583                                 local activityButton = miniActivity:find("activity"):find("button")
3584                                 assert(activityButton)
3585                                 local activityTexture = r2.activityTexture[activityInst.Activity]
3586                                 if activityTexture then
3587                                         activityButton.texture = activityTexture
3588                                         activityButton.texture_pushed = activityTexture
3589                                         activityButton.texture_over = activityTexture
3590                                 end
3591
3592                                 -- activity type text
3593                                 local activityText = miniActivity:find("activity_name")
3594                                 assert(activityText)
3595                                 activityText.uc_hardtext = activityInst.Activity
3596                         end
3597                 end
3598                 startCount = sequence.Components.Size
3599         else
3600                 noActivityLabel.active = true
3601                 noActivityLabel.uc_hardtext = tostring(i18n.get("uiR2EdNoSequence"))
3602         end
3603
3604         -- hide remaining mini activity templates
3605         for i=startCount, r2.maxActivities-1 do
3606                 local miniActivity = miniActivities[tostring(i)]
3607                 assert(miniActivity)
3608                 miniActivity.active = false
3609         end
3610 end
3611
3612
3613 function r2:closeMiniActivityView()
3614         local miniActivityView = getUI("ui:interface:r2ed_mini_activity_view")
3615         assert(miniActivityView)
3616         miniActivityView.active = false
3617 end
3618
3619 function r2:openActivitiesSequence()
3620
3621         r2:updateActivitiesAndChatsUI(r2:getSelectedInstance())
3622
3623         local triggersUI = getUI("ui:interface:r2ed_triggers")
3624         assert(triggersUI)
3625
3626         triggersUI.active = true
3627         triggersUI:updateCoords()
3628
3629         if triggersUI.Env.openFirst == nil then
3630                 triggersUI:center()
3631                 triggersUI.Env.openFirst = true
3632         end
3633
3634         r2:closeMiniActivityView()
3635 end
3636
3637
3638 function r2:chooseOrOpenSelectedChatSequence()
3639
3640         r2:updateActivitiesAndChatsUI(r2:getSelectedInstance())
3641
3642         -- init menu
3643         local menuName = "ui:interface:r2ed_chat_sequences_menu"
3644         launchContextMenuInGame(menuName)
3645         local menu = getUI(menuName)
3646
3647         local rootMenu = menu:getRootMenu()
3648         assert(rootMenu)
3649         rootMenu:reset()
3650
3651         -- update menu
3652         local miniActivity = getUICaller().parent.parent.parent
3653         assert(miniActivity)
3654
3655         local miniActivityNb = tonumber(miniActivity.Env.id)
3656         local activitySequence = r2:getSelectedSequInst("r2ed_triggers")
3657         assert(activitySequence)
3658         local activityInst = activitySequence.Components[miniActivityNb]
3659
3660         local chatSequenceId = tostring(activityInst.Chat)
3661
3662         local newLine = 3
3663         --title "Chat sequence"
3664         local chatSequence
3665         if chatSequenceId ~= "" then
3666                 chatSequence = r2:getInstanceFromId(chatSequenceId)
3667                 assert(chatSequence)
3668                 --rootMenu:addLine(ucstring(tostring(i18n.get("uiR2EDChatSequence")).." " .. chatSequence.Name .." : "), "lua", "", "Title")
3669                 rootMenu:addLine(ucstring(tostring(i18n.get("uiR2EDChatSequence")).." " .. r2:getSequenceName(chatSequence) .." : "), "lua", "", "Title")
3670         else
3671                 rootMenu:addLine(ucstring(tostring(i18n.get("uiR2EDChatSequence")).." : "), "lua", "", "Title")
3672         end
3673
3674         rootMenu:addSeparator()
3675
3676         -- "Open chat sequence"
3677         if chatSequenceId ~= "" then
3678                 --rootMenu:addLine(ucstring(tostring(i18n.get("uiR2EDOpen")).." "..chatSequence.Name), "lua", "r2:openMiniActivityChatSequence("..tostring(miniActivityNb)..")", "Open")
3679                 rootMenu:addLine(ucstring(tostring(i18n.get("uiR2EDOpen")).." "..r2:getSequenceName(chatSequence)), "lua", "r2:openMiniActivityChatSequence("..tostring(miniActivityNb)..")", "Open")
3680                 newLine = newLine + 1
3681         end
3682
3683         -- "Any chat sequence"
3684         rootMenu:addLine(ucstring(i18n.get("uiR2EdNoChat")), "lua", "r2:setSequenceChatToMiniActivity("..tostring(miniActivityNb)..")", "None")
3685
3686
3687         -- "new chat sequence"
3688         rootMenu:addLine(ucstring(tostring(i18n.get("uiR2EdNewChat")).."..."), "lua", "r2:newChatsSequenceAndSelect("..tostring(miniActivityNb)..")", "None")
3689         local menuButton = createGroupInstance("r2_menu_button", "", { bitmap = "r2_icon_create.tga", size="14" })
3690         rootMenu:setUserGroupLeft(newLine, menuButton)
3691
3692         rootMenu:addSeparator()
3693
3694         local activeLogicEntity = r2:getSelectedInstance()
3695         assert(activeLogicEntity)
3696
3697         for i=0, activeLogicEntity:getBehavior().ChatSequences.Size-1 do
3698                 local sequence = activeLogicEntity:getBehavior().ChatSequences[i]
3699                 assert(sequence)
3700
3701                 --rootMenu:addLine(ucstring(sequence.Name), "lua", "r2:setSequenceChatToMiniActivity("..tostring(miniActivityNb)..", " .. tostring(i)..")", sequence.InstanceId)
3702                 rootMenu:addLine(ucstring(r2:getSequenceName(sequence)), "lua", "r2:setSequenceChatToMiniActivity("..tostring(miniActivityNb)..", " .. tostring(i)..")", sequence.InstanceId)
3703         end
3704
3705         -- display menu
3706         menu:updateCoords()
3707         local ref = getUICaller()
3708         menu.y = ref.y_real - (menu.h - ref.h_real)
3709         menu.x = ref.x_real
3710         menu:updateCoords()
3711 end
3712
3713 function r2:openMiniActivityChatSequence(miniActivityNb, chatSequenceId)
3714
3715         local activitySequence = r2:getSelectedSequInst("r2ed_triggers")
3716         assert(activitySequence)
3717         local activityInst = activitySequence.Components[miniActivityNb]
3718
3719         if chatSequenceId == nil then
3720                 chatSequenceId = tostring(activityInst.Chat)
3721         end
3722
3723         r2:openChatSequence(chatSequenceId)
3724 end
3725
3726 function r2:openChatSequence(chatSequenceId)
3727
3728         if chatSequenceId == nil then
3729                 chatSequenceId = r2:getSelectedEltInst("r2ed_triggers").Chat
3730         end
3731
3732         local chatSequences = getUI("ui:interface:r2ed_chat_sequence")
3733         assert(chatSequences)
3734
3735         local tab = chatSequences:find("sequence_tabs")
3736         assert(tab)
3737
3738         local selectedTab
3739         local sequenceUI
3740         for i=0, tab.tabButtonNb-1 do
3741                 sequence = tab:getGroup(i)
3742                 assert(sequence)
3743                 if sequence.Env.sequenceId == chatSequenceId then
3744                         sequenceUI = sequence
3745                         selectedTab = i
3746                         break
3747                 end
3748         end
3749
3750         if selectedTab then
3751                 tab.selection = selectedTab
3752
3753                 local repeatButton = chatSequences:find("repeat_group"):find("repeat"):find("toggle_butt")
3754                 assert(repeatButton)
3755
3756                 local sequenceInstId = sequenceUI.Env.sequenceId
3757                 local sequenceInst = r2:getInstanceFromId(sequenceInstId)
3758
3759                 repeatButton.pushed = (sequenceInst.Repeating == 0)
3760         end
3761
3762         r2:openChatSequences()
3763 end
3764
3765 function r2:newChatsSequenceAndSelect(miniActivityNb)
3766         local chatSequenceId = r2:newChatsSequence(true)
3767
3768         if chatSequenceName ~= -1 then
3769                 r2:setSequenceChatToMiniActivity(miniActivityNb, -1, chatSequenceId)
3770                 r2:openMiniActivityChatSequence(miniActivityNb, chatSequenceId)
3771         end
3772 end
3773
3774 function r2:setSequenceChatToMiniActivity(miniActivityNb, sequenceNb, chatSequenceId)
3775
3776         local miniActivityView = getUI("ui:interface:r2ed_mini_activity_view")
3777         assert(miniActivityView)
3778
3779         local miniActivities = miniActivityView:find("mini_activities")
3780         assert(miniActivities)
3781
3782         local miniActivity = miniActivities[tostring(miniActivityNb)]
3783         assert(miniActivity)
3784
3785         local activitySequence = r2:getSelectedSequInst("r2ed_triggers")
3786         assert(activitySequence)
3787         local activityInst = activitySequence.Components[miniActivityNb]
3788
3789         local chatTexture
3790
3791         if sequenceNb == nil then
3792                 r2:selectChatSequence("None", activityInst.InstanceId)
3793                 chatTexture = "r2_mini_activity_empty_chat.tga"
3794         else
3795                 local activeLogicEntity = r2:getSelectedInstance()
3796                 assert(activeLogicEntity)
3797
3798                 if chatSequenceId == nil then
3799                         local chatSequence = activeLogicEntity:getBehavior().ChatSequences[tonumber(sequenceNb)]
3800                         assert(chatSequence)
3801                         chatSequenceId = chatSequence.InstanceId
3802                 end
3803
3804                 r2:selectChatSequence(chatSequenceId, activityInst.InstanceId)
3805
3806                 chatTexture = "r2_mini_activity_chat.tga"
3807         end
3808
3809         local chatButton = miniActivity:find("chat_sequence"):find("button")
3810         assert(chatButton)
3811         chatButton.texture = chatTexture
3812         chatButton.texture_pushed = chatTexture
3813         chatButton.texture_over = chatTexture
3814 end
3815
3816 function r2:openActivity()
3817
3818         r2:updateActivitiesAndChatsUI(r2:getSelectedInstance())
3819
3820         local miniActivity = getUICaller().parent.parent.parent
3821         assert(miniActivity)
3822
3823         local sequenceUI = r2:getSelectedSequ("r2ed_triggers")
3824         assert(sequenceUI)
3825
3826         local activityList = sequenceUI:find("elements_list")
3827         assert(activityList)
3828
3829         local eltEditor = activityList:find("edit_element")
3830         assert(eltEditor)
3831         local indexEltEditor = activityList:getElementIndex(eltEditor)
3832
3833         local activityIndex = miniActivity.Env.id
3834         if indexEltEditor<=activityIndex then activityIndex=activityIndex+1 end
3835
3836         local activityUI = activityList:getChild(activityIndex)
3837         assert(activityUI)
3838
3839         local selectedButtonElt = activityUI:find("select")
3840         assert(selectedButtonElt)
3841
3842         selectedButtonElt.pushed = true
3843         r2:selectTriggerElement(nil, "r2ed_triggers", selectedButtonElt)
3844
3845         r2:updateActivityEditor()
3846         r2:openActivitiesSequence()
3847 end
3848
3849 function r2:selectSequenceTab(uiName, index)
3850
3851         if uiName == "r2ed_triggers" then
3852                 r2:updateSequencesButtonBar(index)
3853         end
3854
3855         local eltsUI = getUI("ui:interface:"..uiName)
3856         assert(eltsUI)
3857
3858         local sequencesTab = eltsUI:find("sequence_tabs")
3859         assert(sequencesTab)
3860
3861         local repeatButton = eltsUI:find("repeat_group"):find("repeat"):find("toggle_butt")
3862         assert(repeatButton)
3863
3864         local sequenceUI = sequencesTab:getGroup(index)
3865         assert(sequenceUI)
3866         local sequenceInstId = sequenceUI.Env.sequenceId
3867
3868         if sequenceInstId and r2:getInstanceFromId(sequenceInstId) then
3869                 local sequenceInst = r2:getInstanceFromId(sequenceInstId)
3870                 repeatButton.pushed = (sequenceInst.Repeating == 0)
3871         end
3872 end
3873
3874
3875
3876 function r2:getSequenceName(sequenceInst)
3877
3878         local name = sequenceInst.Name
3879         local index = -1
3880         if name == "" then
3881                 local components = sequenceInst.Parent
3882                 for i=0, components.Size-1 do
3883                         if components[i].InstanceId == sequenceInst.InstanceId then
3884                                 index = i
3885                                 break
3886                         end
3887                 end
3888
3889                 if index >= 0 then
3890                         local startName
3891                         if sequenceInst:isKindOf("ChatSequence") then
3892                                 startName = tostring(i18n.get("uiR2EdSequChat"))
3893                         elseif sequenceInst:isKindOf("ActivitySequence") then
3894                                 startName = tostring(i18n.get("uiR2EdSeq"))
3895                         end
3896
3897                         name = startName..(index+1)
3898                 end
3899         end
3900
3901         return name
3902 end
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931