ryzom/common/data_common/r2/r2_activities.lua

   1 r2.activities = {
   2
   3 uiId = "ui:interface:r2ed_activities",
   4 sequenceEditorId = "ui:interface:r2ed_edit_activity_sequence",
   5 ownCreatedInstances = {},
   6 openFirst = nil,
   7 elementsIdCounter = 0,
   8 sequencesNb = 0,
   9 sequencesIdCounter = 0,
  10 elementOrder = true,
  11 maxAndMin = false,
  12 eltTemplateParams =     {
  13                                                 selectElt="r2.activities.selectElement()",
  14                                                 openEltEditor="",
  15                                                 maxMinElt="",
  16                                                 removeElt="r2.activities.removeElementInst()",
  17                                                 colOver="200 120 80 120",
  18                                                 colPushed="200 120 80 255",
  19                                                 multiMaxLine="3"
  20                                         },
  21 elementEditorTemplate = "template_edit_activity",
  22 elementInitialName=i18n.get("uiR2EdActivity"):toUtf8(),
  23 sequenceInitialName=i18n.get("uiR2EdSeq"):toUtf8(),
  24
  25 isInitialized = false,
  26
  27 maxSequences = 7,
  28 maxElements = 14,
  29
  30 firstSequence = {},
  31
  32 -- element ---------------------------------------------------
  33 currentEltUIID = nil, -- initialisé quand l'editeur est ouvert ou fermé
  34
  35 updatedSequUIID = nil,  -- creation of sequence or of one of this elements
  36 updatedEltUIID = nil,   -- creation or update of element
  37
  38
  39 activityTypeTranslation =   {
  40                                                 ["Stand Still"]                         ={trans=i18n.get("uiR2EdStandStill"):toUtf8(),                  zone=""},
  41                                                 ["Follow Route"]                        ={trans=i18n.get("uiR2EdFollowRoad"):toUtf8(),                  zone="Road"},
  42                                                 ["Patrol"]                                      ={trans=i18n.get("uiR2EdPatrol"):toUtf8(),                              zone="Road"},
  43                                                 ["Repeat Road"]                         ={trans=i18n.get("uiR2EdRepeatRoad"):toUtf8(),                  zone="Road"},
  44                                                 ["Wander"]                                      ={trans=i18n.get("uiR2EdWander"):toUtf8(),                              zone="Region"},
  45                                                 ["Stand On Start Point"]        ={trans=i18n.get("uiR2EdStandOnStartPoint"):toUtf8(),   zone=""},
  46                                                 ["Go To Start Point"]           ={trans=i18n.get("uiR2EdGoToStartPoint"):toUtf8(),              zone=""},
  47                                                 ["Go To Zone"]                          ={trans=i18n.get("uiR2EdGoToZone"):toUtf8(),                    zone="Region"},
  48                                                 ["Sit Down"]                            ={trans=i18n.get("uiR2EdSitDown"):toUtf8(),                             zone=""},
  49                                                 ["Stand Up"]                            ={trans=i18n.get("uiR2EdStandUp"):toUtf8(),                             zone=""},
  50                                                 ["Rest In Zone"]                        ={trans=i18n.get("uiR2EDRest"):toUtf8(),                                zone="Region"},
  51                                                 ["Feed In Zone"]                        ={trans=i18n.get("uiR2EDFeed"):toUtf8(),                                zone="Region"},
  52                                                 ["Work In Zone"]                        ={trans=i18n.get("uiR2EDWork"):toUtf8(),                                zone="Region"},
  53                                                 ["Hunt In Zone"]                        ={trans=i18n.get("uiR2EDHunt"):toUtf8(),                                zone="Region"},
  54                                                 ["Guard Zone"]                          ={trans=i18n.get("uiR2EDGuard"):toUtf8(),                               zone="Region"},
  55                                         },
  56
  57 timeLimitsTranslation = {
  58                                                         ["No Limit"]    =i18n.get("uiR2EdNoTimeLimit"):toUtf8(),
  59                                                         ["Chat"]                =i18n.get("uiR2EdWhileChat"):toUtf8(),
  60                                                         ["Few Sec"]             =i18n.get("uiR2EdForCertainTime"):toUtf8(),
  61                                                 },
  62
  63 timeLimitsProperties = {
  64                                                         [i18n.get("uiR2EdNoTimeLimit"):toUtf8()]        ="No Limit",
  65                                                         [i18n.get("uiR2EdWhileChat"):toUtf8()]          ="Chat",
  66                                                         [i18n.get("uiR2EdForCertainTime"):toUtf8()]     ="Few Sec"
  67                                                 },
  68 }
  69
  70
  71 -- sequence --------------------------------------------------
  72 function r2.activities:currentSequUI()
  73         local ui = getUI(self.uiId)
  74         local tab = ui:find("sequence_tabs")
  75         assert(tab)
  76
  77         local sequenceUI = tab:getGroup(tab.selection)
  78
  79         return sequenceUI
  80 end
  81
  82 function r2.activities:currentSequInstId()
  83         if self:currentSequUI() then
  84                 return self:currentSequUI().Env.InstanceId
  85         end
  86         return nil
  87 end
  88
  89 --initialisé quand selection sequence dans tab ou dans barre menu
  90 function r2.activities:setSequUIInstId(sequUI, id)
  91         sequUI.Env.InstanceId = id
  92 end
  93
  94 function r2.activities:currentSequInst()
  95         if self:currentSequInstId() then
  96                 return r2:getInstanceFromId(self:currentSequInstId())
  97         end
  98         return nil
  99 end
 100
 101 -- element ---------------------------------------------------
 102
 103 function r2.activities:currentEltUIId()
 104         return self.currentEltUIID
 105 end
 106
 107 function r2.activities:currentEltUI()
 108         if self.currentEltUIID then
 109                 return getUI(self.currentEltUIID)
 110         end
 111         return nil
 112 end
 113
 114 function r2.activities:setCurrentEltUIId(id)
 115         self.currentEltUIID = id
 116 end
 117
 118 function r2.activities:currentEltInstId()
 119         if self.currentEltUIID then
 120                 return self:currentEltUI().Env.InstanceId
 121         end
 122         return nil
 123 end
 124
 125 function r2.activities:currentEltInst()
 126         if self.currentEltUIID and self:currentEltInstId() then
 127                 return r2:getInstanceFromId(self:currentEltInstId())
 128         end
 129         return nil
 130 end
 131
 132 -- updated element and/or sequence (not necessary the same as current sequence or element)
 133 function r2.activities:updatedSequUI()
 134         if self.updatedSequUIID then
 135                 return getUI(self.updatedSequUIID)
 136         end
 137         return nil
 138 end
 139
 140 function r2.activities:setUpdatedSequUIId(sequUIId)
 141         self.updatedSequUIID = sequUIId
 142 end
 143
 144 function r2.activities:updatedEltUI()
 145         if self.updatedEltUIID then
 146                 return getUI(self.updatedEltUIID)
 147         end
 148         return nil
 149 end
 150
 151 function r2.activities:setUpdatedEltUIId(eltUIId)
 152         self.updatedEltUIID = eltUIId
 153 end
 154
 155
 156
 157
 158
 159
 160
 161 ------------------ INIT ACTIVITIES EDITOR --------------------------------------
 162 function r2.activities:initEditor()
 163
 164 end
 165
 166 function r2.activities:initEditorAfterFirstCall()
 167
 168         if not self.isInitialized then
 169
 170                 self:cleanEditor()
 171
 172                 -- create sequences UI for selected entity
 173                 local entity = r2:getSelectedInstance()
 174                 assert(entity)
 175                 local activitySequences = entity:getBehavior().Activities
 176
 177                 local selectedSequenceIndex = entity:getSelectedSequenceIndex()
 178
 179                 for s = 0, activitySequences.Size - 1 do
 180                         r2.activities:newSequenceUI(activitySequences[s])
 181                 end
 182
 183                 --
 184                 local ui = getUI(self.uiId)
 185                 assert(ui)
 186
 187                 local tabActivities = ui:find("sequence_tabs")
 188                 assert(tabActivities)
 189                 tabActivities.selection = -1
 190
 191                 if activitySequences.Size>0 then
 192                         self:triggerSelectSequence(activitySequences[selectedSequenceIndex].InstanceId)
 193                 end
 194
 195                 local uc_title = ucstring()
 196                 uc_title:fromUtf8(i18n.get("uiR2EDActivitySequenceEditor"):toUtf8() .. entity.Name)
 197                 ui.uc_title = uc_title
 198
 199                 self.isInitialized = true
 200         end
 201 end
 202
 203 ------ OPEN EDITOR ---------------------------------------------------------------
 204 function r2.activities:openEditor()
 205
 206         local ui = getUI(self.uiId)
 207
 208         if not ui.active then
 209
 210                 self:initEditorAfterFirstCall()
 211
 212                 -- active editor
 213                 ui.active = true
 214                 ui:updateCoords()
 215
 216                 if self.openFirst == nil then
 217                         self.openFirst = true
 218                         ui:center()
 219                 end
 220         else
 221                 setTopWindow(ui)
 222                 ui:blink(1)
 223         end
 224 end
 225
 226 ------ OPEN SEQUENCE EDITOR ---------------------------------------------------------------
 227 function r2.activities:openSequenceEditor()
 228
 229         local sequenceEditor = getUI(self.sequenceEditorId)
 230         assert(sequenceEditor)
 231         sequenceEditor.active = false
 232
 233         local ui = getUI(self.uiId)
 234         assert(ui)
 235
 236         sequenceEditor.x = ui.x
 237         sequenceEditor.y = ui.y
 238         sequenceEditor.active = true
 239
 240         -- update edit box text with current sequence name
 241         local editName = sequenceEditor:find("sequence_name"):find("edit_box_group")
 242         assert(editName)
 243
 244         local tab = ui:find("sequence_tabs")
 245         assert(tab)
 246
 247         local sequInstId = r2.logicUI:getSequUIInstId(ui:find(tab.associatedGroupSelection))
 248         assert(sequInstId)
 249         local activitySequence = r2:getInstanceFromId(sequInstId)
 250         assert(activitySequence)
 251         local tabName
 252         if activitySequence.Name~= "" then
 253                 tabName = activitySequence.Name
 254         else
 255                 local comps = activitySequence.Parent
 256                 for i=0, comps.Size-1 do
 257                         if comps[i].InstanceId == activitySequence.InstanceId then
 258                                 tabName = self.sequenceInitialName..(i+1)
 259                                 break
 260                         end
 261                 end
 262         end
 263
 264         local uc_sequ = ucstring()
 265         uc_sequ:fromUtf8(tabName)
 266         editName.uc_input_string = uc_sequ
 267 end
 268
 269
 270 ------ SET SEQUENCE NAME ---------------------------------------------------------------
 271 function r2.activities:setSequenceName()
 272
 273         r2.requestNewAction(i18n.get("uiR2EDSetSequenceNameAction"))
 274
 275         local sequenceEditor = getUI(self.sequenceEditorId)
 276         assert(sequenceEditor)
 277
 278         local editName = sequenceEditor:find("sequence_name"):find("edit_box_group")
 279         assert(editName)
 280
 281         local sequenceInstId = self:currentSequInstId()
 282         r2.requestSetNode(sequenceInstId, "Name", editName.uc_input_string:toUtf8())
 283
 284         sequenceEditor.active = false
 285 end
 286
 287
 288 ------ NEW SEQUENCE INST -------------------------------------------------------------
 289 function r2.activities:newSequenceInst()
 290
 291         r2.requestNewAction(i18n.get("uiR2EDNewSequenceListAction"))
 292
 293         local ui = getUI(self.uiId)
 294         assert(ui)
 295
 296         local tab = ui:find("sequence_tabs")
 297         assert(tab)
 298
 299         --if tab.tabButtonNb == self.maxSequences then return end
 300
 301         local entity = r2:getSelectedInstance()
 302         assert(entity)
 303
 304         local activitySequence = r2.newComponent("ActivitySequence")
 305
 306         r2.requestInsertNode(entity:getBehavior().InstanceId, "Activities", -1, "", activitySequence)
 307         self.ownCreatedInstances[activitySequence.InstanceId] = true
 308
 309         if entity:getBehavior().Activities.Size == 0 then
 310                 self.firstSequence[entity.InstanceId] = activitySequence.InstanceId
 311         end
 312
 313         return activitySequence.InstanceId
 314 end
 315
 316 ------ NEW SEQUENCE UI --------------------------------------------------------------
 317 function r2.activities:newSequenceUI(activitySequence)
 318
 319         local templateParams = {
 320                                                                 newElt="r2.activities:newElementInst()",
 321                                                                 newEltText=i18n.get("uiR2EdNewActivity"):toUtf8(),
 322                                                                 eltOrderText=i18n.get("uiR2EdActivityOrder"):toUtf8(),
 323                                                                 upElt="r2.activities:upElementInst()",
 324                                                                 downElt="r2.activities:downElementInst()",
 325                                                                 maxMinElts="r2.activities:maximizeMinimizeElements()",
 326                                                                 downUpColor="220 140 100 255",
 327                                                                 overDownUpColor="255 180 170 255",
 328                                                                 colPushed = "220 140 100 255",
 329                                                                 paramsL= "r2.activities:selectSequence('"..activitySequence.InstanceId.."')"
 330                                                    }
 331
 332         local ui = getUI(self.uiId)
 333         assert(ui)
 334
 335         local menu = ui:find("sequence_menu")
 336         assert(menu)
 337
 338         local tab = menu:find("sequence_tabs")
 339         assert(tab)
 340
 341         -- NEW SEQUENCE GROUP --------------------------------------------
 342         local newTabNb = tab.tabButtonNb+1
 343         local posParent, posRef, id, group
 344         if newTabNb == 1 then
 345                 posParent = "parent"
 346                 posRef = "TL TL"
 347         else
 348                 posParent = "tab"..(newTabNb-2)
 349                 posRef = "TR TL"
 350         end
 351
 352         local id = "tab"..(newTabNb-1)
 353
 354         local groupId = "sequence"..self.sequencesIdCounter
 355         self.sequencesIdCounter = self.sequencesIdCounter+1
 356
 357         local newTabGroup = createUIElement("sequence_elements_template", menu.id, {id=groupId,
 358                 new_elt=templateParams.newElt, new_elt_text=templateParams.newEltText,
 359                 elt_order_text=templateParams.eltOrderText, up_elt=templateParams.upElt,
 360                 down_elt=templateParams.downElt, max_min_elts=templateParams.maxMinElts,
 361                 down_up_color=templateParams.downUpColor, over_down_up_color=templateParams.overDownUpColor})
 362         assert(newTabGroup)
 363
 364         menu:addGroup(newTabGroup)
 365
 366         r2.logicUI:setSequUIInstId(newTabGroup, activitySequence.InstanceId)
 367         self:setUpdatedSequUIId(newTabGroup.id)
 368
 369         -- NEW TAB ----------------------------------------------------
 370         local comps = activitySequence.Parent
 371         local sequIndex = -1
 372         for i=0, comps.Size-1 do
 373                 if comps[i].InstanceId == activitySequence.InstanceId then
 374                         sequIndex = i
 375                         break
 376                 end
 377         end
 378
 379         local newTab = createUIElement("sequence_tab_template", tab.id,
 380                 {id=id, posparent=posParent, posref=posRef, group=groupId,
 381                  col_pushed =templateParams.colPushed, params_l=templateParams.paramsL})
 382         assert(newTab)
 383
 384         tab:addTabWithOrder(newTab, sequIndex)
 385
 386         local viewText = newTab:getViewText()
 387         assert(viewText)
 388         viewText.overExtendViewText = true
 389         viewText.overExtendViewTextUseParentRect = false
 390         viewText:setLineMaxW(40)
 391
 392         newTab:updateCoords()
 393
 394         -- if it's the first sequence, active all separators and buttons around it
 395         if tab.tabButtonNb == 1 then
 396                 self:updateUI(true)
 397         end
 398
 399         -- create element editor of new sequence
 400         self:createElementEditor()
 401
 402         -- create all elements ui of new sequence
 403         for a = 0, activitySequence.Components.Size - 1 do
 404                 self:newElementUI(activitySequence.Components[a])
 405         end
 406
 407         -- if YOU just called creation of this sequence (or undo/redo request), it becomes current
 408         -- selected sequence
 409         if self.ownCreatedInstances[activitySequence.InstanceId] == true
 410                 or r2.logicComponents.undoRedoInstances[activitySequence.InstanceId]==true then
 411
 412                 -- right and left buttons to decal showed sequences
 413                 self:triggerSelectSequence(activitySequence.InstanceId)
 414                 self.ownCreatedInstances[activitySequence.InstanceId] = nil
 415
 416                 r2.logicComponents.undoRedoInstances[activitySequence.InstanceId] = nil
 417         end
 418
 419         -- update next sequences UI names
 420         for i=sequIndex, tab.tabButtonNb-1 do
 421
 422                 local tabButton = tab:getTabButton(i)
 423                 assert(tabButton)
 424                 local sequenceUI = tab:getGroup(i)
 425                 assert(sequenceUI)
 426                 local sequInst = r2:getInstanceFromId(r2.logicUI:getSequUIInstId(sequenceUI))
 427                 assert(sequInst)
 428
 429                 sequName=""
 430                 if sequInst.Name~= "" then
 431                         sequName = sequInst.Name
 432                 else
 433                         sequName = self.sequenceInitialName .. (i+1)
 434                 end
 435
 436                 local uc_name = ucstring()
 437                 uc_name:fromUtf8(sequName)
 438                 tabButton.uc_hardtext = uc_name
 439         end
 440 end
 441
 442 ---- REMOVE SEQUENCE INSTANCE ---------------------------------------------
 443 function r2.activities:removeSequenceInst()
 444         r2.requestNewAction(i18n.get("uiR2EDRemoveSequenceListAction"))
 445         local sequenceInstId = self:currentSequInstId()
 446         assert(sequenceInstId)
 447         r2.requestEraseNode(sequenceInstId, "", -1)
 448 end
 449
 450 ---- REMOVE SEQUENCE UI --------------------------------------------------
 451 function r2.activities:removeSequenceUI(instance)
 452
 453         -- if sequenceUI to delete is the current sequenceUI, no current elementUI anymore
 454         local selectedElt = self:currentEltUI()
 455         if (selectedElt and selectedElt.parent.parent.parent == self:updatedSequUI()) then
 456                 self:setCurrentEltUIId(nil)
 457         end
 458         local deleteCurrentSequUI = (self:updatedSequUI() == self:currentSequUI())
 459
 460         -- rename sequences which have default name and are after the removed sequence in list
 461         local ui = getUI(self.uiId)
 462         assert(ui)
 463         local tab = ui:find("sequence_tabs")
 464         assert(tab)
 465
 466         local selection = tab.selection
 467
 468         local removedIndex = tab.tabButtonNb
 469         for i=0, tab.tabButtonNb-1 do
 470                 local sequenceUI = tab:getGroup(i)
 471                 assert(sequenceUI)
 472                 if r2.logicUI:getSequUIInstId(sequenceUI) == instance.InstanceId then
 473                         removedIndex = i
 474                 end
 475                 if i>removedIndex then
 476                         local buttonTab = tab:find("tab"..i)
 477                         assert(buttonTab)
 478                         if buttonTab.hardtext == self.sequenceInitialName..(i+1) then
 479                                 buttonTab.uc_hardtext = self.sequenceInitialName..i
 480                         end
 481                 end
 482         end
 483
 484         if removedIndex < selection then
 485                 selection = selection-1
 486         end
 487
 488         -- remove tab of the tab list
 489         tab:removeTab(removedIndex)
 490
 491         local firstIndex
 492         for i=0, tab.tabButtonNb-1 do
 493                 local tabButton = tab:getTabButton(i)
 494                 if tabButton.active then
 495                         firstIndex = i
 496                         break
 497                 end
 498         end
 499
 500         -- if no sequence anymore, hide separators, buttons...
 501         if tab.tabButtonNb == 0 then
 502                 self:updateUI(false)
 503         end
 504 end
 505
 506 ----- REPEAT SEQUENCE -------------------------------------------
 507 function r2.activities:repeatSequence()
 508
 509         r2.requestNewAction(i18n.get("uiR2EDSetSequenceRepeatFlagAction"))
 510
 511
 512         local sequenceInst = self:currentSequInst()
 513         if sequenceInst==nil then return end
 514
 515         local sequenceType = 1
 516         if getUICaller().pushed==true then sequenceType = 0 end
 517
 518         r2.requestSetNode(sequenceInst.InstanceId, "Repeating", sequenceType)
 519 end
 520
 521 ------ UPDATE SEQUENCE UI ------------------------------------------------------
 522 function r2.activities:updateSequenceUI(instance, attributeName)
 523
 524         local ui = getUI(self.uiId)
 525         assert(ui)
 526
 527         if attributeName=="Name" then
 528
 529                 local name = instance:getName()
 530
 531                 local tab = ui:find("sequence_tabs")
 532                 assert(tab)
 533
 534                 local tabId
 535                 for i=0, tab.tabButtonNb-1 do
 536                         local sequenceUI = tab:getGroup(i)
 537                         if r2.logicUI:getSequUIInstId(sequenceUI) == instance.InstanceId then
 538                                 tabId = i
 539                                 break
 540                         end
 541                 end
 542
 543                 if tabId then
 544                         local buttonTab = tab:find("tab"..tabId)
 545                         assert(buttonTab)
 546
 547                         local uc_name = ucstring()
 548                         uc_name:fromUtf8(name)
 549                         buttonTab.uc_hardtext = uc_name
 550
 551                         local viewText = buttonTab:getViewText()
 552                         assert(viewText)
 553                 end
 554
 555 --              r2.miniActivities:updateSequenceButtonBar()
 556
 557         elseif attributeName=="Repeating" then
 558                 local sequenceUI = self:updatedSequUI()
 559                 assert(sequenceUI)
 560
 561                 local repeatButton = ui:find("repeat_group"):find("repeat"):find("toggle_butt")
 562                 repeatButton.pushed = (instance.Repeating == 0)
 563         end
 564 end
 565
 566 ------  DECAL TO RIGHT SEQUENCES IN EDITOR ------------------------------
 567 function r2.activities:rightSequenceUI()
 568
 569         local ui = getUI(self.uiId)
 570         assert(ui)
 571
 572         local tabGr = ui:find("sequence_tabs")
 573         assert(tabGr)
 574
 575         local lastTab = tabGr.lastTabButton
 576         tabGr:showTabButton(lastTab+1);
 577 end
 578
 579 ------  DECAL TO LEFT SEQUENCES IN EDITOR -------------------------------
 580 function r2.activities:leftSequenceUI()
 581
 582         local ui = getUI(self.uiId)
 583         assert(ui)
 584
 585         local tabGr = ui:find("sequence_tabs")
 586         assert(tabGr)
 587
 588         local firstTab = tabGr.firstTabButton
 589         tabGr:showTabButton(firstTab-1);
 590 end
 591
 592 function r2.activities:showSequencesUI()
 593
 594         local ui = getUI(self.uiId)
 595         assert(ui)
 596
 597         local tabGr = ui:find("sequence_tabs")
 598         assert(tabGr)
 599
 600         local leftTabsButton = ui:find("left_sequences")
 601         assert(leftTabsButton)
 602
 603         local rightTabsButton = ui:find("right_sequences")
 604         assert(rightTabsButton)
 605
 606         local firstTab
 607         local lastTab
 608         for i=0, tabGr.tabButtonNb-1 do
 609                 local tab = tabGr:getTabButton(i)
 610                 assert(tab)
 611                 if tab.active then
 612                         if not firstTab then
 613                                 firstTab = i
 614                         end
 615                         lastTab = i
 616                 elseif firstTab~=nil then
 617                         break
 618                 end
 619         end
 620
 621         if firstTab and lastTab then
 622                 leftTabsButton.active = (firstTab~=0)
 623                 rightTabsButton.active = (lastTab~=tabGr.tabButtonNb-1)
 624         end
 625 end
 626
 627 ------ CLOSE EDITOR ------------------------------------------------------
 628 function r2.activities:closeEditor()
 629
 630         local ui = getUI(self.uiId)
 631         assert(ui)
 632         if ui.active then
 633                 ui.active = false
 634         end
 635
 636         local sequenceEditor = getUI(self.sequenceEditorId)
 637         assert(sequenceEditor)
 638         sequenceEditor.active = false
 639
 640         self.isInitialized = false
 641 end
 642
 643 ------ CLEAN EDITOR -------------------------------------------------------
 644 function r2.activities:cleanEditor()
 645
 646         self:setCurrentEltUIId(nil)
 647         self:setUpdatedSequUIId(nil)
 648         self:setUpdatedEltUIId(nil)
 649         self.elementsIdCounter = 0
 650         self.sequencesNb = 0
 651         self.sequencesIdCounter = 0
 652
 653         local ui = getUI(self.uiId)
 654         assert(ui)
 655
 656         -- remove all tabs and associated groups
 657         local sequenceMenu = ui:find("sequence_menu")
 658         assert(sequenceMenu)
 659
 660         local tabActivities = ui:find("sequence_tabs")
 661         assert(tabActivities)
 662
 663         tabActivities:removeAll()
 664
 665         -- hide separators and buttons around
 666         self:updateUI(false)
 667 end
 668
 669 ------ SELECT ELEMENT --------------------------------------------------
 670 function r2.activities:selectElement(selectedButtonElt, sequInstId)
 671         if sequInstId then
 672                 self:triggerSelectSequence(sequInstId)
 673         end
 674         r2.logicComponents:selectElement(r2.activities, selectedButtonElt)
 675 end
 676
 677 ------ SELECT SEQUENCE -----------------------------------------------
 678 function r2.activities:triggerSelectSequence(sequInstId)
 679
 680         local ui = getUI(self.uiId)
 681         assert(ui)
 682
 683         local tabActivities = ui:find("sequence_tabs")
 684         assert(tabActivities)
 685
 686         local sequInst = r2:getInstanceFromId(sequInstId)
 687         assert(sequInst)
 688         local tabNb = r2.logicComponents:searchElementIndex(sequInst)-1
 689
 690         local sequenceUI = tabActivities:getGroup(tabNb)
 691         if sequenceUI and r2.logicUI:getSequUIInstId(sequenceUI)==sequInstId then
 692
 693                 -- triggers call of r2.activities:selectSequence
 694                 tabActivities.selection = tonumber(tabNb)
 695         end
 696 end
 697
 698 function r2.activities:selectSequence(sequInstId)
 699
 700         r2.logicComponents:selectSequence(r2.activities)
 701
 702         local ui = getUI(self.uiId)
 703         assert(ui)
 704
 705         local sequInst = r2:getInstanceFromId(sequInstId)
 706         assert(sequInst)
 707
 708         -- repeat sequence ?
 709         local repeatButton = ui:find("repeat_group"):find("repeat"):find("toggle_butt")
 710         repeatButton.pushed = (sequInst.Repeating == 0)
 711
 712         -- update sequence button bar
 713         r2.miniActivities:updateSequenceButtonBar()
 714
 715         -- update mini activities view
 716         r2.miniActivities:updateMiniActivityView()
 717
 718         -- set the sequence in activity owner
 719         local owner = sequInst.ParentInstance.ParentInstance
 720
 721         owner.User.SelectedSequence = sequInst.IndexInParent
 722 end
 723
 724 ------ CREATE EDITOR -------------------------------------------------------
 725 function r2.activities:createElementEditor()
 726
 727         local activityEditor = r2.logicComponents:createElementEditor(r2.activities)
 728         assert(activityEditor)
 729
 730         -- time limit
 731         local timeLimitCB = activityEditor:find("time_limit"):find("combo_box")
 732         assert(timeLimitCB)
 733         timeLimitCB:resetTexts()
 734         timeLimitCB:addText(i18n.get("uiR2EdNoTimeLimit"))
 735         timeLimitCB:addText(i18n.get("uiR2EdForCertainTime"))
 736
 737         do
 738                 local cb = activityEditor:find("road_count_limit"):find("combo_box")
 739                 assert(cb)
 740                 cb:resetTexts()
 741                 cb:addText(i18n.get("uiR2EdNoRoadCountLimit"))
 742                 local i = 0
 743                 while i < 20 do
 744                         i = i + 1
 745                         cb:addText(ucstring(tostring(i)))
 746                 end
 747
 748         end
 749
 750 end
 751
 752 ------ OPEN ELEMENT EDITOR -----------------------------------------------
 753 function r2.activities:updateElementEditor()
 754
 755         local instanceActivity = self:currentEltInst()
 756         if instanceActivity==nil then return end
 757
 758         local sequenceUI = self:currentSequUI()
 759         assert(sequenceUI)
 760
 761         local activityEditor = sequenceUI:find("edit_element")
 762         assert(activityEditor)
 763
 764         -- activity name
 765         local activityName = activityEditor:find("name")
 766         assert(activityName)
 767
 768         -- activity type
 769         local activityButtonText = activityEditor:find("activity"):find("text")
 770         assert(activityButtonText)
 771
 772         -- patrol / repeat road special casefalse
 773         do
 774                 local grp = activityEditor:find("road_count_group")
 775                 if instanceActivity.Activity == "Patrol" or instanceActivity.Activity == "Repeat Road" then
 776                         grp.active = true
 777                 else
 778                         grp.active = false
 779                 end
 780
 781
 782                 -- time limit
 783                 local comboBox = activityEditor:find("road_count_limit").combo_box
 784                 assert(comboBox)
 785                 local value = select(instanceActivity.RoadCountLimit, instanceActivity.RoadCountLimit, "0")
 786                 if value == "0" then
 787                         value = i18n.get("uiR2EdNoRoadCountLimit"):toUtf8()
 788                 end
 789                 comboBox.Env.locked = true
 790                 comboBox.selection_text = value
 791                 comboBox.Env.locked = false
 792
 793         end
 794
 795         -- time limit
 796         local comboBox = activityEditor:find("time_limit").combo_box
 797         assert(comboBox)
 798
 799         local index = r2.logicComponents:searchElementIndex(instanceActivity)
 800         local uc_activityName = ucstring(self.elementInitialName.." : ")
 801         if index~= nil then
 802                 uc_activityName:fromUtf8(self.elementInitialName.." "..index.." : ")
 803         end
 804         activityName.uc_hardtext = uc_activityName
 805
 806         -- activity type
 807         local activityText = instanceActivity:getVerb()
 808         if instanceActivity.ActivityZoneId ~= "" then
 809                 local place = r2:getInstanceFromId(instanceActivity.ActivityZoneId)
 810                 assert(place)
 811
 812                 activityText = activityText .. " " .. place.Name
 813         end
 814         if activityText then
 815                 local uc_activityText = ucstring()
 816                 uc_activityText:fromUtf8(activityText)
 817                 activityButtonText.uc_hardtext = uc_activityText
 818         end
 819
 820         -- time limit
 821         local timeLimit = instanceActivity.TimeLimit
 822
 823         local certainTime = activityEditor:find("certain_time")
 824         assert(certainTime)
 825
 826         comboBox.Env.locked = true
 827         if timeLimit == "Few Sec" then
 828
 829                 local timeLimitValue = tonumber(instanceActivity.TimeLimitValue)
 830
 831                 if timeLimitValue ~= nil then
 832
 833                         local hoursNb, minNb, secNb = r2.logicComponents:calculHourMinSec(timeLimitValue)
 834
 835                         local timeLimitText = i18n.get("uiR2EdFor"):toUtf8() .. " "
 836                         if hoursNb ~= 0 then timeLimitText = timeLimitText .. hoursNb .. i18n.get("uiR2EdShortHours"):toUtf8() .. " " end
 837                         if minNb ~= 0 then timeLimitText = timeLimitText .. minNb .. i18n.get("uiR2EdShortMinutes"):toUtf8() .. " " end
 838                         timeLimitText = timeLimitText .. secNb .. i18n.get("uiR2EdShortSeconds"):toUtf8()
 839
 840                         certainTime.active = true
 841                         local hoursMenu = certainTime:find("hours"):find("text")
 842                         assert(hoursMenu)
 843                         hoursMenu.uc_hardtext = tostring(hoursNb)
 844
 845                         local minutesMenu = certainTime:find("minutes"):find("text")
 846                         assert(minutesMenu)
 847                         minutesMenu.uc_hardtext = tostring(minNb)
 848
 849                         local secondsMenu = certainTime:find("seconds"):find("text")
 850                         assert(secondsMenu)
 851                         secondsMenu.uc_hardtext = tostring(secNb)
 852
 853                         local uc_time = ucstring()
 854                         uc_time:fromUtf8(timeLimitText)
 855                         comboBox.view_text = uc_time
 856                 end
 857         else
 858                 certainTime.active = false
 859                 timeLimit = self.timeLimitsTranslation[timeLimit]
 860                 if timeLimit~= nil then
 861                         comboBox.selection_text = timeLimit
 862                 end
 863         end
 864         comboBox.Env.locked = false
 865 end
 866
 867 ----- CLOSE ELEMENT EDITOR --------------------------------------------------------
 868 function r2.activities:closeElementEditor()
 869
 870         r2.logicComponents:closeElementEditor(r2.activities)
 871 end
 872
 873 ------ NEW ELEMENT INST ----------------------------------------------------------
 874 function r2.activities:newElementInst(tableInit)
 875
 876         local sequenceUI = self:currentSequUI()
 877         if sequenceUI then
 878                 local eltsList = sequenceUI :find("elements_list")
 879                 assert(eltsList)
 880
 881                 if eltsList.childrenNb >= self.maxElements then return end
 882         end
 883
 884         local sequenceInstId = self:currentSequInstId()
 885         -- when no sequences, we create the first
 886         local selectedInst = r2:getSelectedInstance()
 887         assert(selectedInst)
 888         local selectedInstId = selectedInst.InstanceId
 889         if sequenceInstId == nil then
 890                 if self.firstSequence[selectedInstId] then
 891                         sequenceInstId = self.firstSequence[selectedInstId]
 892                 else
 893                         sequenceInstId = self:newSequenceInst()
 894                 end
 895         end
 896
 897         local instanceElement = r2.newComponent("ActivityStep")
 898
 899         local existZone = false
 900         local actionToInitDefaultActivity = ""
 901
 902         if tableInit ~= nil then
 903                 instanceElement.Activity = tableInit.Activity
 904                 instanceElement.ActivityZoneId = r2.RefId(tableInit.ActivityZoneId)
 905                 instanceElement.TimeLimit = tableInit.TimeLimit
 906                 instanceElement.TimeLimitValue = tableInit.TimeLimitValue
 907
 908                 if tableInit.RoadCountLimit then instanceElement.RoadCountLimit = tableInit.RoadCountLimit end
 909         else
 910                 instanceElement.TimeLimit = "No Limit"
 911
 912                 local activitiesTable = {}
 913                 selectedInst:getAvailableActivities(activitiesTable)
 914                 local standStillAct = false
 915                 local roadAct = false
 916                 local regionAct = false
 917                 local activityZone
 918                 for k, activity in pairs(activitiesTable) do
 919                         if activity=="Stand Still" then
 920                                 standStillAct=true
 921                                 break
 922                         elseif self.activityTypeTranslation[activity].zone=="Road" then
 923                                 roadAct = true
 924                                 activityZone = activity
 925                         elseif self.activityTypeTranslation[activity].zone=="Region" then
 926                                 regionAct = true
 927                                 activityZone = activity
 928                         end
 929                 end
 930
 931                 if standStillAct then
 932                         instanceElement.Activity = "Stand Still"
 933                 elseif roadAct then
 934                         local roadsTable = r2.Scenario:getAllInstancesByType("Road")
 935                         if table.getn(roadsTable) > 0 then
 936                                 instanceElement.Activity = activityZone
 937                                 local zoneId
 938                                 for k, v in pairs(roadsTable) do
 939                                         zoneId = v.InstanceId
 940                                         break
 941                                 end
 942                                 instanceElement.ActivityZoneId = zoneId
 943                                 existZone = true
 944                         end
 945                 elseif regionAct then
 946                         local regionsTable = r2.Scenario:getAllInstancesByType("Region")
 947                         if table.getn(regionsTable) > 0 then
 948                                 instanceElement.Activity = activityZone
 949                                 local zoneId
 950                                 for k, v in pairs(regionsTable) do
 951                                         zoneId = v.InstanceId
 952                                         break
 953                                 end
 954                                 instanceElement.ActivityZoneId = zoneId
 955                                 existZone = true
 956                         end
 957                 else
 958                         debugInfo("No activity type to initialize default activity step")
 959                 end
 960
 961                 if roadAct then
 962                         actionToInitDefaultActivity = i18n.get("uiR2EdRoad"):toUtf8() .. " "
 963                 end
 964
 965                 if regionAct then
 966                         if actionToInitDefaultActivity~="" then
 967                                 actionToInitDefaultActivity = actionToInitDefaultActivity .. i18n.get("uiR2EdOr"):toUtf8().. " "
 968                         end
 969                         actionToInitDefaultActivity = actionToInitDefaultActivity .. i18n.get("uiR2EdRegion"):toUtf8() .. " "
 970                 end
 971         end
 972
 973         if instanceElement.Activity~="" then
 974                 r2.requestNewAction(i18n.get("uiR2EDNewSequenceElementAction"))
 975                 r2.requestInsertNode(sequenceInstId, "Components", -1, "", instanceElement)
 976                 self.ownCreatedInstances[instanceElement.InstanceId] = true
 977
 978                 r2.logicComponents:newElementInst(r2.activities)
 979
 980         elseif not existZone then
 981                 local message = i18n.get("uiR2EdCreateZone"):toUtf8() .. actionToInitDefaultActivity .. i18n.get("uiR2EdFor"):toUtf8() .. " " .. selectedInst.Name
 982                 local uc_message = ucstring()
 983                 uc_message:fromUtf8(message)
 984                 messageBox(uc_message)
 985         end
 986         r2.requestForceEndMultiAction()
 987 end
 988
 989 ------ NEW ELEMENT UI -------------------------------------------------------------
 990 function r2.activities:newElementUI(newInst)
 991         r2.logicUI:newElementUI(r2.activities, newInst, true)
 992 end
 993
 994 ------ REMOVE ELEMENT INST --------------------------------------------------------
 995 function r2.activities:removeElementInst()
 996         r2.requestNewAction(i18n.get("uiR2EDRemoveLogicElementAction"))
 997         r2.logicComponents:removeElementInst(r2.activities)
 998         r2.requestEndAction()
 999 end
1000
1001 ------ REMOVE ELEMENT UI ---------------------------------------------------------
1002 function r2.activities:removeElementUI(removedEltUI)
1003         r2.logicUI:removeElementUI(r2.activities, removedEltUI)
1004 end
1005
1006 ------ UP ELEMENT INST ------------------------------------------------------------
1007 function r2.activities:upElementInst()
1008         r2.logicComponents:upElementInst(r2.activities)
1009 end
1010
1011 ------ DOWN ELEMENT INST ---------------------------------------------------------
1012 function r2.activities:downElementInst()
1013         r2.logicComponents:downElementInst(r2.activities)
1014 end
1015
1016 ------ MAX/MIN ELEMENTS UI --------------------------------------------------------
1017 function r2.activities:maximizeMinimizeElements()
1018         r2.logicUI:maximizeMinimizeElements(r2.activities)
1019 end
1020
1021 ------ MAX/MIN ELEMENT UI ------------------------------------------------------------
1022 function r2.activities:maximizeMinimizeElement(element, allMinimize)
1023
1024         r2.logicUI:maximizeMinimizeElement(element, allMinimize)
1025 end
1026
1027 ------ DOWN/UP ELEMENT UI -----------------------------------------------------------
1028 function r2.activities:downUpElementUI(elementUI, instance)
1029         r2.logicUI:downUpElementUI(r2.activities, elementUI, instance)
1030 end
1031
1032 ------ UPDATE ELEMENT UI -------------------------------------------------------------
1033 function r2.activities:updateElementUI(elementUI)
1034
1035         r2.logicUI:updateElementUI(r2.activities, elementUI)
1036 end
1037
1038 ------ UPDATE ELEMENT TITLE -----------------------------------------------------------
1039 function r2.activities:updateElementTitle(activityUI)
1040
1041         r2.logicComponents:updateElementTitle(r2.activities, activityUI, true)
1042 end
1043
1044 ------ INIT ACTIVITY MENU -------------------------------------------------------------------
1045 function r2.activities:initActivityMenu()
1046
1047         local menuName = "ui:interface:r2ed_triggers_menu"
1048         local activityMenu = getUI(menuName)
1049         local activityMenu = activityMenu:getRootMenu()
1050         assert(activityMenu)
1051         activityMenu:reset()
1052         local uc_activity = ucstring()
1053
1054         local activitiesTable = {}
1055         r2:getSelectedInstance():getAvailableActivities(activitiesTable)
1056
1057         local activitiesNb = 0
1058         for k, actType in pairs(activitiesTable) do
1059                 local uc_activity = ucstring()
1060                 local translation = self.activityTypeTranslation[actType].trans
1061                 uc_activity:fromUtf8(translation)
1062
1063                 local zone = self.activityTypeTranslation[actType].zone
1064                 if zone == "" then
1065                         activityMenu:addLine(uc_activity, "lua", "r2.activities:setActivityType('"..actType.."')", actType)
1066                 else
1067                         activityMenu:addLine(uc_activity, "", "", actType)
1068
1069                         local textureName = ""
1070                         if zone == "Road" then
1071                                 textureName = "r2ed_icon_road.tga"
1072                         elseif zone == "Region" then
1073                                 textureName = "r2ed_icon_region.tga"
1074                         end
1075
1076                         local menuButton = createGroupInstance("r2_menu_button", "", { bitmap = textureName, size="14" })
1077                         activityMenu:setUserGroupLeft(activitiesNb, menuButton)
1078                         activityMenu:addSubMenu(activitiesNb)
1079                         local zonesMenu = activityMenu:getSubMenu(activitiesNb)
1080                         local zonesTable = r2.Scenario:getAllInstancesByType(zone)
1081                         for key, z in pairs(zonesTable) do
1082                                 uc_activity:fromUtf8(z.Name)
1083                                 zonesMenu:addLine(uc_activity, "lua", "r2.activities:setActivityType('"..actType.."', '".. z.InstanceId .."')", z.InstanceId)
1084                         end
1085                         if table.getn(zonesTable) == 0 then
1086                                 zonesMenu:addLine(i18n.get("uiR2EdNoSelelection"), "lua", "r2.activities:setActivityType()", "")
1087                         end
1088                 end
1089
1090                 activitiesNb = activitiesNb+1
1091         end
1092
1093         r2.logicUI:openLogicMenu(getUICaller())
1094 end
1095
1096 --- SET ACTIVITY TYPE --------------------------------------------------------------------
1097 function r2.activities:setActivityType(activityType, placeId)
1098
1099         local activityInstId = self:currentEltInstId()
1100         assert(activityInstId)
1101
1102         if activityType == nil then
1103                 return
1104         elseif placeId == nil then
1105                 r2.requestNewAction(i18n.get("uiR2EDSetActivityTypeAction"))
1106                 r2.requestSetNode(activityInstId, "Activity", activityType)
1107                 r2.requestSetNode(activityInstId, "ActivityZoneId", r2.RefId(""))
1108         else
1109                 r2.requestNewAction(i18n.get("uiR2EDSetActivityTypeAction"))
1110                 r2.requestSetNode(activityInstId, "Activity", activityType)
1111                 r2.requestSetNode(activityInstId, "ActivityZoneId", r2.RefId(placeId))
1112         end
1113 end
1114
1115 --- SET TIME LIMIT --------------------------------------------------------------------
1116 function r2.activities:setTimeLimit(timeLimit)
1117
1118         r2.requestNewAction(i18n.get("uiR2EDSetActivityTimeLimitAction"))
1119
1120         if timeLimit == nil then
1121                 timeLimit = getUICaller().selection_text
1122                 if getUICaller().Env.locked then return end
1123         end
1124
1125         local activityInstId = self:currentEltInstId()
1126         assert(activityInstId)
1127
1128         -- TimeLimitValue
1129         if timeLimit == i18n.get("uiR2EdForCertainTime"):toUtf8() then
1130                 r2.requestSetNode(activityInstId, "TimeLimitValue", tostring(20))
1131         else
1132                 r2.requestSetNode(activityInstId, "TimeLimitValue", "")
1133         end
1134
1135         -- TimeLimit
1136         timeLimit = self.timeLimitsProperties[timeLimit]
1137         assert(timeLimit)
1138         r2.requestSetNode(activityInstId, "TimeLimit", timeLimit)
1139 end
1140
1141 --- SET TIME LIMIT --------------------------------------------------------------------
1142 function r2.activities:setRoadCountLimit(limit)
1143
1144         r2.requestNewAction(i18n.get("uiR2EDSetActivityRoadCountAction"))
1145
1146         if limit == nil then
1147                 timeLimit = getUICaller().selection_text
1148                 if getUICaller().Env.locked then return end
1149         end
1150
1151         local activityInstId = self:currentEltInstId()
1152         assert(activityInstId)
1153
1154         -- RoadCountLimit
1155         if limit == i18n.get("uiR2EdNoRoadCountLimit"):toUtf8() then
1156                 r2.requestSetNode(activityInstId, "RoadCountLimit", "0")
1157         else
1158                 r2.requestSetNode(activityInstId, "RoadCountLimit", timeLimit)
1159         end
1160 end
1161
1162 ------ INIT TIME MENU -----------------------------------------------------------------
1163 function r2.activities:initTimeMenu(timeFunction, isHours)
1164
1165         local timeMenu = getUI("ui:interface:r2ed_triggers_menu")
1166         assert(timeMenu)
1167
1168         local timeMenu = timeMenu:getRootMenu()
1169         assert(timeMenu)
1170
1171         timeMenu:reset()
1172
1173         for i=0,9 do
1174                 timeMenu:addLine(ucstring(tostring(i)), "lua", timeFunction .. "(" .. tostring(i) .. ")", tostring(i))
1175         end
1176
1177         if isHours == true then
1178                 timeMenu:addLine(ucstring(tostring(10)), "lua", timeFunction .. "(" .. tostring(10) .. ")", tostring(10))
1179         else
1180
1181                 local lineNb = 9
1182                 for i=10, 50, 10 do
1183                         local lineStr = tostring(i).."/"..tostring(i+9)
1184                         timeMenu:addLine(ucstring(lineStr), "", "", tostring(i))
1185                         lineNb = lineNb+1
1186
1187                         timeMenu:addSubMenu(lineNb)
1188                         local subMenu = timeMenu:getSubMenu(lineNb)
1189
1190                         for s=0,9 do
1191                                 lineStr = tostring(i+s)
1192                                 subMenu:addLine(ucstring(lineStr), "lua", timeFunction .. "(" .. tostring(i+s) .. ")", lineStr)
1193                         end
1194                 end
1195         end
1196
1197         r2.logicUI:openLogicMenu(getUICaller())
1198 end
1199
1200 ----- SET HOURS/MINUTES/SECONDS -----------------------------------------------------------------
1201 function r2.activities:activityForHours(hourNb)
1202
1203         local activityInst = self:currentEltInst()
1204         assert(activityInst)
1205
1206         local lastHourNb, minNb, secNb = r2.logicComponents:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
1207
1208         self:setLimitTimeValue(hourNb, minNb, secNb)
1209 end
1210
1211 function r2.activities:activityForMinutes(minNb)
1212
1213         local activityInst = self:currentEltInst()
1214         assert(activityInst)
1215
1216         local hoursNb, lastMinNb, secNb = r2.logicComponents:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
1217
1218         self:setLimitTimeValue(hoursNb, minNb, secNb)
1219 end
1220
1221 function r2.activities:activityForSeconds(secNb)
1222
1223         local activityInst = self:currentEltInst()
1224         assert(activityInst)
1225
1226         local hoursNb, minNb, lastSecNb = r2.logicComponents:calculHourMinSec(tonumber(activityInst.TimeLimitValue))
1227
1228         self:setLimitTimeValue(hoursNb, minNb, secNb)
1229 end
1230
1231 -------- SET LIMIT TIME VALUE -------------------------------------------------------------------
1232 function r2.activities:setLimitTimeValue(hourNb, minNb, secNb)
1233         r2.requestNewAction(i18n.get("uiR2EDSetActivityTimeLimitValueAction"))
1234
1235         local activityInstId = self:currentEltInstId()
1236         assert(activityInstId)
1237
1238         local totalSec = tostring(hourNb*3600 + minNb*60 + secNb)
1239         r2.requestSetNode(activityInstId, "TimeLimitValue", totalSec)
1240 end
1241
1242
1243 ----- UTILS ---------------------------------------------------------
1244
1245 function r2.activities:findSequenceUIFromInstance(instance)
1246
1247         local ui = getUI(r2.activities.uiId)
1248         assert(ui)
1249
1250         local sequenceTabs = ui:find("sequence_tabs")
1251         assert(sequenceTabs)
1252
1253         for i=0,sequenceTabs.tabButtonNb-1 do
1254                 local sequenceUI = sequenceTabs:getGroup(i)
1255                 if r2.logicUI:getSequUIInstId(sequenceUI) == instance.InstanceId then
1256                         r2.activities:setUpdatedSequUIId(sequenceUI.id)
1257                         return sequenceUI
1258                 end
1259         end
1260
1261         return nil
1262 end
1263
1264 function r2.activities:findElementUIInSequenceUI(sequenceUI, instance)
1265
1266         local eltsList = sequenceUI:find("elements_list")
1267         assert(eltsList)
1268
1269         for i=0,eltsList.childrenNb-1 do
1270                 local element = eltsList:getChild(i)
1271                 if r2.logicUI:getEltUIInstId(element) == instance.InstanceId then
1272                         return element
1273                 end
1274         end
1275
1276         return nil
1277 end
1278
1279 function r2.activities:updateUI(active)
1280
1281         local ui = getUI(self.uiId)
1282
1283         local sepTop = ui:find("sep_top")
1284         assert(sepTop)
1285         local sepBottom = ui:find("sep_bottom")
1286         assert(sepBottom)
1287         local sepLeft = ui:find("sep_left")
1288         assert(sepLeft)
1289         local sepRight = ui:find("sep_right")
1290         assert(sepRight)
1291         local removeSequence = ui:find("remove_sequence_button")
1292         assert(removeSequence)
1293         local editSequence = ui:find("edit_sequence")
1294         assert(editSequence)
1295         local repeatButtonGr = ui:find("repeat_group")
1296         assert(repeatButtonGr)
1297
1298         sepTop.active = active
1299         sepBottom.active = active
1300         sepLeft.active= active
1301         sepRight.active= active
1302         removeSequence.active = active
1303         editSequence.active = active
1304         repeatButtonGr.active = active
1305 end
1306
1307
1308
1309
1310
1311
1312
1313 --------------------------------------------------------------------------------------------------
1314 -------------------------------- ACTIVITY SEQUENCE DisplayerProperties ---------------------------
1315 --------------------------------------------------------------------------------------------------
1316 local activitySequencePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1317
1318 ------------------------------------------------
1319 function activitySequencePropertySheetDisplayerTable:onPostCreate(instance)
1320
1321         local activeLogicEntity = r2:getSelectedInstance()
1322         if activeLogicEntity and activeLogicEntity.isGrouped and (activeLogicEntity:isGrouped() or activeLogicEntity:isKindOf("NpcGrpFeature")) then
1323                 activeLogicEntity = r2:getLeader(activeLogicEntity)
1324         end
1325
1326         if activeLogicEntity ~= instance:getParentOfKind("LogicEntity") then return end
1327
1328         local activeLogicEntityParent = instance:getActiveLogicEntityParent()
1329
1330         if activeLogicEntity==nil or activeLogicEntity~=activeLogicEntityParent then
1331                 return
1332         end
1333
1334         if r2.activities.isInitialized then
1335                 r2.activities.firstSequence[activeLogicEntity.InstanceId] = nil
1336                 r2.activities:newSequenceUI(instance)
1337         end
1338
1339         r2.miniActivities:updateSequenceButtonBar()
1340 end
1341 ------------------------------------------------
1342 function activitySequencePropertySheetDisplayerTable:onErase(instance)
1343
1344         instance.User.Deleted = true
1345
1346         local activeLogicEntity = r2:getSelectedInstance()
1347         if activeLogicEntity and activeLogicEntity.isGrouped and (activeLogicEntity:isGrouped() or activeLogicEntity:isKindOf("NpcGrpFeature")) then
1348                 activeLogicEntity = r2:getLeader(activeLogicEntity)
1349         end
1350
1351         if activeLogicEntity ~= instance:getParentOfKind("LogicEntity") then return end
1352
1353         local activeLogicEntityParent = instance:getActiveLogicEntityParent()
1354
1355         if activeLogicEntity==nil or activeLogicEntity~=activeLogicEntityParent then
1356                 return
1357         end
1358
1359         if r2.activities.isInitialized and r2.activities:findSequenceUIFromInstance(instance) then
1360                 r2.activities:removeSequenceUI(instance)
1361         end
1362
1363         -- last sequence
1364         if instance.Parent.Size==1 then
1365                 r2.miniActivities:updateMiniActivityView()
1366                 r2.miniActivities:updateSequenceButtonBar()
1367         end
1368 end
1369 ------------------------------------------------
1370 function activitySequencePropertySheetDisplayerTable:onPreHrcMove(instance)
1371 end
1372 ------------------------------------------------
1373 function activitySequencePropertySheetDisplayerTable:onPostHrcMove(instance)
1374 end
1375 ------------------------------------------------
1376 function activitySequencePropertySheetDisplayerTable:onFocus(instance, hasFocus)
1377 end
1378
1379 ------------------------------------------------
1380 function activitySequencePropertySheetDisplayerTable:onSelect(instance, isSelected)
1381 end
1382
1383 ------------------------------------------------
1384 function activitySequencePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1385
1386         local activeLogicEntity = r2:getSelectedInstance()
1387         if activeLogicEntity and activeLogicEntity.isGrouped and (activeLogicEntity:isGrouped() or activeLogicEntity:isKindOf("NpcGrpFeature")) then
1388                 activeLogicEntity = r2:getLeader(activeLogicEntity)
1389         end
1390
1391         if activeLogicEntity ~= instance:getParentOfKind("LogicEntity") then return end
1392
1393         local activeLogicEntityParent = instance:getActiveLogicEntityParent()
1394
1395         if activeLogicEntity==nil or activeLogicEntity~=activeLogicEntityParent then
1396                 return
1397         end
1398
1399         if r2.activities.isInitialized and r2.activities:findSequenceUIFromInstance(instance) then
1400                 r2.activities:updateSequenceUI(instance, attributeName)
1401         end
1402
1403         if attributeName=="Name" then
1404                 r2.miniActivities:updateSequenceButtonBar()
1405         end
1406 end
1407
1408 ------------------------------------------------
1409 function r2:activitySequencePropertySheetDisplayer()
1410         return activitySequencePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1411 end
1412
1413
1414 --------------------------------------------------------------------------------------------------
1415 -------------------------------- ACTIVITY STEP DisplayerProperties--------------------------------
1416 --------------------------------------------------------------------------------------------------
1417 local activityStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1418
1419 ------------------------------------------------
1420 function activityStepPropertySheetDisplayerTable:onPostCreate(instance)
1421
1422         local activeLogicEntity = r2:getSelectedInstance()
1423         if activeLogicEntity and activeLogicEntity.isGrouped and (activeLogicEntity:isGrouped() or activeLogicEntity:isKindOf("NpcGrpFeature")) then
1424                 activeLogicEntity = r2:getLeader(activeLogicEntity)
1425         end
1426
1427         if activeLogicEntity ~= instance:getParentOfKind("LogicEntity") then return end
1428
1429         local activitySequInst = instance.Parent.Parent
1430         local activeLogicEntityParent = activitySequInst:getActiveLogicEntityParent()
1431
1432         if activeLogicEntity==nil or activeLogicEntity~=activeLogicEntityParent then
1433                 return
1434         end
1435
1436         if r2.activities.isInitialized and r2.activities:findSequenceUIFromInstance(activitySequInst) then
1437                 r2.activities:newElementUI(instance)
1438         end
1439
1440         -- update mini activities view
1441         r2.miniActivities:updateMiniActivityView()
1442 end
1443 ------------------------------------------------
1444 function activityStepPropertySheetDisplayerTable:onErase(instance)
1445
1446         instance.User.Deleted = true
1447
1448         local activeLogicEntity = r2:getSelectedInstance()
1449         if activeLogicEntity and activeLogicEntity.isGrouped and (activeLogicEntity:isGrouped() or activeLogicEntity:isKindOf("NpcGrpFeature")) then
1450                 activeLogicEntity = r2:getLeader(activeLogicEntity)
1451         end
1452
1453         if activeLogicEntity ~= instance:getParentOfKind("LogicEntity") then return end
1454
1455         local activitySequInst = instance.Parent.Parent
1456         local activeLogicEntityParent = activitySequInst:getActiveLogicEntityParent()
1457
1458         if activeLogicEntity==nil or activeLogicEntity~=activeLogicEntityParent then
1459                 return
1460         end
1461
1462         local sequenceUI = r2.activities:findSequenceUIFromInstance(activitySequInst)
1463         if r2.activities.isInitialized and sequenceUI then
1464                 local eltUI = r2.activities:findElementUIInSequenceUI(sequenceUI, instance)
1465                 if eltUI then
1466                         r2.activities:removeElementUI(eltUI)
1467                 end
1468         end
1469
1470         r2.miniActivities:updateMiniActivityView()
1471 end
1472 ------------------------------------------------
1473 function activityStepPropertySheetDisplayerTable:onPreHrcMove(instance)
1474 end
1475 ------------------------------------------------
1476 function activityStepPropertySheetDisplayerTable:onPostHrcMove(instance)
1477
1478         local activeLogicEntity = r2:getSelectedInstance()
1479         if activeLogicEntity and activeLogicEntity.isGrouped and (activeLogicEntity:isGrouped() or activeLogicEntity:isKindOf("NpcGrpFeature")) then
1480                 activeLogicEntity = r2:getLeader(activeLogicEntity)
1481         end
1482
1483         if activeLogicEntity ~= instance:getParentOfKind("LogicEntity") then return end
1484
1485         local activitySequInst = instance.Parent.Parent
1486         local activeLogicEntityParent = activitySequInst:getActiveLogicEntityParent()
1487
1488         if activeLogicEntity==nil or activeLogicEntity~=activeLogicEntityParent then
1489                 return
1490         end
1491
1492         local sequenceUI = r2.activities:findSequenceUIFromInstance(activitySequInst)
1493         if r2.activities.isInitialized and sequenceUI then
1494                 local eltUI = r2.activities:findElementUIInSequenceUI(sequenceUI, instance)
1495                 if eltUI then r2.activities:downUpElementUI(eltUI, instance) end
1496         end
1497
1498         r2.miniActivities:updateMiniActivityView()
1499 end
1500 ------------------------------------------------
1501 function activityStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)
1502 end
1503
1504 ------------------------------------------------
1505 function activityStepPropertySheetDisplayerTable:onSelect(instance, isSelected)
1506 end
1507
1508 ------------------------------------------------
1509 function activityStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1510
1511         local activeLogicEntity = r2:getSelectedInstance()
1512         if activeLogicEntity and activeLogicEntity.isGrouped and (activeLogicEntity:isGrouped() or activeLogicEntity:isKindOf("NpcGrpFeature")) then
1513                 activeLogicEntity = r2:getLeader(activeLogicEntity)
1514         end
1515
1516         if activeLogicEntity ~= instance:getParentOfKind("LogicEntity") then return end
1517
1518         local activitySequInst = instance.Parent.Parent
1519         local activeLogicEntityParent = activitySequInst:getActiveLogicEntityParent()
1520
1521         if activeLogicEntity==nil or activeLogicEntity~=activeLogicEntityParent then
1522                 return
1523         end
1524
1525         local sequenceUI = r2.activities:findSequenceUIFromInstance(activitySequInst)
1526         if r2.activities.isInitialized and sequenceUI then
1527                 local eltUI = r2.activities:findElementUIInSequenceUI(sequenceUI, instance)
1528                 if eltUI then r2.activities:updateElementUI(eltUI) end
1529         end
1530
1531         -- update mini activities view
1532         r2.miniActivities:updateMiniActivityView()
1533 end
1534
1535 ------------------------------------------------
1536 function activityStepPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
1537         if refIdName == "ActivityZoneId" then
1538                 r2.requestEraseNode(instance.InstanceId, "", -1)
1539         end
1540 end
1541
1542 ------------------------------------------------
1543 function activityStepPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
1544 end
1545
1546 -------------------------------------------------
1547 function r2:activityStepPropertySheetDisplayer()
1548         return activityStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1549 end