ryzom/common/data_common/r2/r2_events.lua

   1 r2.classLogicAttributes = {}
   2
   3 r2.events = {
   4
   5 uiId = "ui:interface:r2ed_events",
   6 ownCreatedInstances = {},
   7 openFirst = nil,
   8 elementsIdCounter = 0,
   9 elementOrder = false,
  10 maxAndMin = false,
  11 eltTemplateParams =     {
  12                                                 selectElt="r2.events:selectElement()",
  13                                                 openEltEditor="",
  14                                                 maxMinElt="",
  15                                                 removeElt="r2.events:removeElementInst()",
  16                                                 colOver="200 150 0 100",
  17                                                 colPushed="200 150 0 255",
  18                                                 multiMaxLine=""
  19                                         },
  20
  21 elementEditorTemplate = "template_edit_events",
  22 elementInitialName=i18n.get("uiR2EdAction"):toUtf8(),
  23
  24 currentEltUIID = nil, -- initialisé quand l'editeur est ouvert ou fermé
  25
  26 logicTranslations = {
  27                                                 ["ApplicableActions"] = {},
  28                                                 ["Events"] = {},
  29                                                 ["Conditions"] = {}
  30                                         },
  31
  32 selectedLogicEntity,
  33 selectedEventType,
  34
  35 eventTypeWithValue =    {
  36                                                         ["end of chat"]                                 = "ChatStep",
  37                                                         ["start of chat"]                               = "ChatStep",
  38                                                         ["starts chat"]                                 = "ChatStep",
  39                                                         ["is in chat"]                                  = "ChatStep",
  40
  41                                                         ["begin of activity step"]              = "ActivityStep",
  42                                                         ["end of activity step"]                = "ActivityStep",
  43                                                         ["is in activity step"]                 = "ActivityStep",
  44                                                         ["is in activity sequence"]     = "ActivitySequence",
  45                                                         ["end of activity sequence"]    = "ActivitySequence",
  46                                                         ["begin activity sequence"]             = "ActivitySequence",
  47                                                         ["begin of activity sequence"]  = "ActivitySequence",
  48                                                         ["emits user event"]                    = "Number",
  49                                                         ["user event emitted"]                  = "Number",
  50                                                         ["add seconds"]                                 = "Number",
  51                                                         ["sub seconds"]                                 = "Number",
  52                                                         ["add scenario points"]                 = "Number",
  53
  54
  55
  56                                                 },
  57
  58 filteredLogicEntityId = nil,
  59 dismatchWithFilter = 0,
  60
  61 actionOrConditionUIId = nil,
  62
  63 keyWordsColor = "@{FFFF}",
  64 communWordsColor = "@{FFFB}",
  65 filterWordColor = "@{FF0F}",
  66 entityWordColor = "@{F90B}",
  67
  68 maxVisibleLine = 10,
  69
  70 memberManagement = false,
  71 }
  72
  73
  74
  75
  76
  77
  78 -- sequence --------------------------------------------------
  79 function r2.events:currentSequUI()
  80         return getUI(self.uiId):find("sequence_elts")
  81 end
  82
  83 function r2.events:currentSequInstId()
  84         return self:currentSequUI().Env.InstanceId
  85 end
  86
  87 -- initialisé quand selection dialog dans menu
  88 function r2.events:setSequUIInstId(sequUI, id)
  89         sequUI.Env.InstanceId = id
  90 end
  91
  92 function r2.events:currentSequInst()
  93         return r2:getInstanceFromId(self:currentSequInstId())
  94 end
  95
  96 -- element ---------------------------------------------------
  97 function r2.events:currentEltUIId()
  98         return self.currentEltUIID
  99 end
 100
 101 function r2.events:currentEltUI()
 102         if self.currentEltUIID then
 103                 return getUI(self.currentEltUIID)
 104         end
 105         return nil
 106 end
 107
 108 function r2.events:setCurrentEltUIId(id)
 109         self.currentEltUIID = id
 110 end
 111
 112 function r2.events:currentEltInstId()
 113         if self.currentEltUIID then
 114                 return self:currentEltUI().Env.InstanceId
 115         end
 116         return nil
 117 end
 118
 119 function r2.events:currentEltInst()
 120         if self.currentEltUIID and self:currentEltInstId() then
 121                 return r2:getInstanceFromId(self:currentEltInstId())
 122         end
 123         return nil
 124 end
 125
 126 -- updated element and/or sequence (not necessary the same as current sequence or element)
 127 function r2.events:updatedSequUI()
 128         return self:currentSequUI()
 129 end
 130
 131 function r2.events:setUpdatedSequUIId(sequUIId)
 132 end
 133
 134 function r2.events:updatedEltUI()
 135         return self:currentEltUI()
 136 end
 137
 138 function r2.events:setUpdatedEltUIId(eltUIId)
 139 end
 140
 141
 142
 143 ------------------ INIT EVENTS EDITOR -------------------------
 144 function r2.events:initEditor()
 145         self:mergeLogicTranslations()
 146 end
 147
 148 ------------------ TRANSLATION TEXT ---------------------------
 149 function r2.events:getTranslationText(eventCategory, eventType)
 150         if self.logicTranslations[eventCategory][eventType] then
 151                 return self.logicTranslations[eventCategory][eventType].text
 152         else
 153                 debugInfo(eventType .. " is not translated")
 154                 return eventType
 155         end
 156 end
 157
 158 ------------------ TRANSLATION IN MENU ------------------------
 159 function r2.events:getTranslationMenu(eventCategory, eventType)
 160         if self.logicTranslations[eventCategory][eventType] then
 161                 return ucstring(self.logicTranslations[eventCategory][eventType].menu)
 162         else
 163                 debugInfo(eventType .. " is not translated")
 164                 return ucstring(eventType)
 165         end
 166 end
 167
 168 -------------------------------------------------
 169 -- Another global map containing all logic attributes per class
 170 function r2.events:registerClassLogicAttributes(class, logicTranslations)
 171         if r2.classLogicAttributes[class] then
 172                 r2.print("Logic attributes are already registered for class '" ..class.."'")
 173                 return
 174         end
 175
 176         r2.classLogicAttributes[class] = logicTranslations
 177 end
 178
 179 -------------------------------------------------
 180 --Looks for a logic attribute for a given class. If the attribute isn't in the corresponding map, looks
 181 -- in the class's baseclass map
 182 function r2.getLogicAttribute(class, logicCategory, value)
 183         if not class or class == "" then return nil end
 184
 185         local logicAttributes = r2.classLogicAttributes[class]
 186
 187         if not logicAttributes then
 188                 --look in parent map
 189                 local baseclass = r2.Classes[class].BaseClass
 190                 r2.print("Attributes not defined for class '"..class.."' looking in '"..baseclass.."' for inherited attributes")
 191                 if baseclass then
 192                         return r2.getLogicAttribute(baseclass, logicCategory, value)
 193                 end
 194                 return nil
 195         end
 196
 197         local attr = logicAttributes[logicCategory][value]
 198
 199         if not attr then
 200                 --look in parent map
 201                 local baseclass = r2.Classes[class].BaseClass
 202                 if baseclass then
 203                         return r2.getLogicAttribute(baseclass, logicCategory, value)
 204                 end
 205                 return nil
 206         end
 207
 208         return attr
 209 end
 210 ------------------------------------------------
 211 function r2.events:mergeLogicTranslations()
 212
 213         registerComponentsLogicTranslations = function(localLogicTranslations)
 214                 local k, v = next(localLogicTranslations, nil)
 215                 while k do
 216                         local k2, v2 = next(v, nil)
 217                         while k2 do
 218
 219                                 if not self.logicTranslations[k][k2] then
 220                                         self.logicTranslations[k][k2] = v2
 221                                 end
 222                                 k2, v2 = next(v, k2)
 223                         end
 224                         k, v = next(localLogicTranslations, k)
 225                 end
 226         end
 227
 228         local k, v = next(r2.Classes, nil)
 229         while k do
 230                 if v.getLogicTranslations then
 231                         local localLogicTranslations = v:getLogicTranslations()
 232                         if localLogicTranslations then
 233                                 self:registerClassLogicAttributes(k, localLogicTranslations)
 234                                 --registerComponentsLogicTranslations(localLogicTranslations)
 235                         else
 236                                 debugInfo(colorTag(255,0,0).."No Translation for component "..k)
 237                         end
 238                 end
 239                 k, v = next(r2.Classes, k)
 240         end
 241 end
 242
 243
 244 ------ OPEN EDITOR ------------------------------------------
 245 function r2.events:openEditor()
 246
 247         local ui = getUI(self.uiId)
 248
 249         if not ui.active then
 250
 251                 self:filterEvents()
 252
 253                 -- active editor
 254                 ui.active = true
 255                 ui:updateCoords()
 256
 257                 if self.openFirst == nil then
 258                         self.openFirst = true
 259                         ui:center()
 260                 end
 261         else
 262                 setTopWindow(ui)
 263                 ui:blink(1)
 264         end
 265 end
 266
 267 ------ CLOSE EDITOR ------------------------------------------
 268 function r2.events:closeEditor()
 269         local ui = getUI(self.uiId)
 270         ui.active = false
 271         r2.logicUI:closeEditor(r2.events)
 272 end
 273
 274 ------ CLEAN EDITOR ------------------------------------------
 275 function r2.events:cleanEditor()
 276
 277         -- reset current dialog and current chat
 278         self:setCurrentEltUIId(nil)
 279         self:setUpdatedSequUIId(nil)
 280         self:setUpdatedEltUIId(nil)
 281         self.elementsIdCounter = 0
 282
 283         local sequenceUI = self:currentSequUI()
 284         assert(sequenceUI)
 285         local eltsList = sequenceUI:find("elements_list")
 286         assert(eltsList)
 287         eltsList:clear()
 288
 289         local dismatchFilterMenu = getUI(self.uiId):find("filterMenu"):find("dismatch_filter")
 290         assert(dismatchFilterMenu)
 291         dismatchFilterMenu.active = false
 292
 293         self.dismatchWithFilter = 0
 294 end
 295
 296 --- UPDATE SEQUENCE UI-------------------------------------------
 297 function r2.events:updateSequenceUI()
 298
 299         local ui = getUI(self.uiId)
 300         assert(ui)
 301
 302         local filterMenuText = ui:find("filterMenu"):find("menu"):find("text")
 303         assert(filterMenuText)
 304
 305         local logicEntity = r2:getInstanceFromId(self.filteredLogicEntityId)
 306         assert(logicEntity)
 307
 308         filterMenuText.uc_hardtext = logicEntity:getDisplayName()
 309
 310         local currentSequ = self:currentSequUI()
 311         assert(currentSequ)
 312         local eltsList = currentSequ:find("elements_list")
 313         assert(eltsList)
 314         for i=0, eltsList.childrenNb-1 do
 315                 local elt = eltsList:getChild(i)
 316                 assert(elt)
 317                 --not element editor
 318                 if r2.logicUI:getEltUIInstId(elt) then
 319                         self:updateElementUI(elt)
 320                 end
 321         end
 322 end
 323
 324
 325 function r2.events:getLogicEntityParent(event)
 326
 327         local logicEntity = event.Parent.Parent.Parent
 328
 329         if logicEntity:isGrouped() and logicEntity:isLeader() then
 330                 logicEntity = logicEntity:getParentGroup()
 331         end
 332         return logicEntity
 333 end
 334
 335 function r2.events:filterIsLogicEntityParent(event)
 336         return self.filteredLogicEntityId==self:getLogicEntityParent(event).InstanceId
 337 end
 338
 339 function r2.events:getBehavior(logicEntity)
 340         return logicEntity.Behavior
 341 end
 342
 343
 344 ------ SELECT FILTER EVENTS --------------------------------------
 345 function r2.events:filterEvents(logicEntityId)
 346
 347         if logicEntityId==nil then
 348                 logicEntityId = r2:getSelectedInstance().InstanceId
 349         end
 350
 351         local logicEntity = r2:getInstanceFromId(logicEntityId)
 352         if logicEntity then
 353
 354                 if not self.memberManagement and logicEntity:isGrouped() then   --TEMP
 355                         logicEntity = logicEntity:getParentGroup()                                      --TEMP
 356                         logicEntityId = logicEntity.InstanceId                                          --TEMP
 357                 end                                                                                                                             --TEMP
 358
 359                 -- clean editor
 360                 self:cleanEditor()
 361
 362                 local ui = getUI(self.uiId)
 363                 assert(ui)
 364
 365                 -- update filter text
 366                 local filterMenuText = ui:find("filterMenu"):find("menu"):find("text")
 367                 assert(filterMenuText)
 368                 filterMenuText.uc_hardtext = logicEntity:getDisplayName()
 369
 370                 self.filteredLogicEntityId = logicEntityId
 371
 372                 -- recover all events of logic entities in current act
 373                 local allEvents = {}
 374                 local allLogicEntities = {}
 375
 376                 for i=0, r2.Scenario.Acts.Size-1 do
 377                         local act = r2.Scenario.Acts[i]
 378                         act:appendInstancesByType(allLogicEntities, "LogicEntity")
 379                         table.insert(allLogicEntities, act)
 380                 end
 381
 382                 table.insert(allLogicEntities, r2.Scenario)
 383                 for k0, entity in pairs(allLogicEntities) do
 384
 385                         local behavior = self:getBehavior(entity)
 386                         if not self.memberManagement then               -- TEMP
 387                                 behavior = entity:getBehavior()         -- TEMP
 388                         end                                                                             -- TEMP
 389
 390                         for e=0, behavior.Actions.Size-1 do
 391                                 local event = behavior.Actions[e]
 392                                 assert(event)
 393                                 allEvents[event.InstanceId] = event
 394                         end
 395                 end
 396
 397                 -- recover events which match with filter
 398                 local eventsType = {}
 399                 local eventsAction = {}
 400                 local eventsCondition = {}
 401
 402                 for k, event in pairs(allEvents) do
 403
 404                         local isSelected = false
 405
 406                         local filterIsLogicEntityParentB = self:filterIsLogicEntityParent(event)
 407                         if not self.memberManagement then       -- TEMP
 408                                 filterIsLogicEntityParentB = (event:getLogicEntityParent().InstanceId == logicEntityId) -- TEMP
 409                         end                                                                     -- TEMP
 410                         -- events type
 411
 412                         if filterIsLogicEntityParentB then
 413                                 table.insert(eventsType, event.InstanceId)
 414                                 isSelected = true
 415                         end
 416
 417                         -- actions
 418                         if not isSelected then
 419
 420                                 for a=0, event.Actions.Size-1 do
 421                                         local action = event.Actions[a]
 422                                         assert(action)
 423
 424                                         if tostring(action.Entity) == logicEntityId then
 425                                                 table.insert(eventsAction, event.InstanceId)
 426                                                 isSelected = true
 427                                                 break
 428                                         end
 429                                 end
 430                         end
 431
 432                         -- conditions
 433                         if not isSelected then
 434
 435                                 for a=0, event.Conditions.Size-1 do
 436                                         local condition = event.Conditions[a]
 437                                         assert(condition)
 438
 439                                         if tostring(condition.Entity) == logicEntityId then
 440                                                 table.insert(eventsCondition, event.InstanceId)
 441                                                 break
 442                                         end
 443                                 end
 444                         end
 445                 end
 446
 447                 -- create event editor
 448                 self:createElementEditor()
 449
 450                 -- display "events type"
 451                 for k, eventId in pairs(eventsType) do
 452                         local event = r2:getInstanceFromId(eventId)
 453                         assert(event)
 454                         self:newElementUI(event)
 455                 end
 456
 457                 -- display "events action"
 458                 for k, eventId in pairs(eventsAction) do
 459                         local event = r2:getInstanceFromId(eventId)
 460                         assert(event)
 461                         self:newElementUI(event)
 462                 end
 463
 464                 -- display "events condition"
 465                 for k, eventId in pairs(eventsCondition) do
 466                         local event = r2:getInstanceFromId(eventId)
 467                         assert(event)
 468                         self:newElementUI(event)
 469                 end
 470
 471         else
 472
 473                 debugInfo("UNKNOWN FILTER EVENTS")
 474
 475                 for k, eventId in pairs(allEvents) do
 476                         local event = r2:getInstanceFromId(eventId)
 477                         assert(event)
 478                         self:newElementUI(event)
 479                 end
 480         end
 481
 482         r2.logicComponents:selectSequence(r2.events)
 483 end
 484
 485 ------ REFRESH FILTER --------------------------------------------
 486 function r2.events:refreshEvents()
 487         self:filterEvents(self.filteredLogicEntityId)
 488 end
 489
 490
 491 ------ SELECT ELEMENT --------------------------------------------
 492 function r2.events:selectElement(selectedButtonElt)
 493         r2.logicComponents:selectElement(r2.events, selectedButtonElt)
 494 end
 495
 496 ------ CREATE EDITOR -----------------------------------------------
 497 function r2.events:createElementEditor()
 498
 499         r2.logicComponents:createElementEditor(r2.events)
 500 end
 501
 502 ------ OPEN ELEMENT EDITOR -----------------------------------------------
 503 function r2.events:updateElementEditor()
 504
 505         local instanceEvent = self:currentEltInst()
 506         if instanceEvent==nil then return end
 507
 508         local ui = getUI(self.uiId)
 509         assert(ui)
 510
 511         local sequenceUI = self:currentSequUI()
 512         assert(sequenceUI)
 513
 514         local eventEditor = sequenceUI:find("edit_element")
 515         assert(eventEditor)
 516
 517         -- editor title
 518         local editorTitleText = eventEditor:find("event_name"):find("name")
 519         assert(editorTitleText)
 520
 521         local logicEntity = self:getLogicEntityParent(instanceEvent)
 522         if not self.memberManagement then                                               --TEMP
 523                 logicEntity = instanceEvent:getLogicEntityParent()  --TEMP
 524         end                                                                                                             --TEMP
 525         assert(logicEntity)
 526
 527         -- when menu text
 528         local when = eventEditor:find("when")
 529         assert(when)
 530         when.Env.InstanceId = logicEntity.InstanceId
 531         local whenMenuText = when:find("text")
 532         assert(whenMenuText)
 533
 534         local coloredName = (logicEntity.InstanceId == self.filteredLogicEntityId)
 535
 536         if coloredName then
 537                 eventType = self.filterWordColor
 538         else
 539                 eventType = self.communWordsColor
 540         end
 541
 542         local name = "No name"
 543         if logicEntity.getName then
 544                 name = logicEntity:getName()
 545         elseif logicEntity.Name then
 546                 name = logicEntity.Name
 547         end
 548         eventType = eventType .. name .. " "
 549         if coloredName then eventType = eventType .. self.communWordsColor end
 550
 551
 552         local class = logicEntity.Class
 553         assert(class)
 554         eventType = eventType ..r2.getLogicAttribute(class, "Events", instanceEvent.Event.Type).text
 555         if instanceEvent.Event.Value~="" then
 556                 local instance = r2:getInstanceFromId(instanceEvent.Event.Value)
 557                 assert(instance)
 558                 eventType = eventType .. " '" .. instance:getShortName() .. "'"
 559         end
 560         if instanceEvent.Event.ValueString and instanceEvent.Event.ValueString~="" then
 561                 eventType = eventType .. " '" .. instanceEvent.Event.ValueString .. "'"
 562         end
 563
 564         local uc_when_text = ucstring()
 565         uc_when_text:fromUtf8(eventType)
 566         whenMenuText.uc_hardtext_single_line_format = uc_when_text
 567         editorTitleText.uc_hardtext = whenMenuText.hardtext .. " ..."
 568
 569         -- actions
 570         local actionsList = eventEditor:find("actions_list")
 571         assert(actionsList)
 572         actionsList:clear()
 573
 574         if instanceEvent.Actions.Size > 0 then
 575
 576                 for i=0, instanceEvent.Actions.Size-1 do
 577                         local actionInst = instanceEvent.Actions[i]
 578
 579                         local actionUI = self:newActionUI()
 580                         actionUI.Env.InstanceId = actionInst.InstanceId
 581
 582                         local actionMenuText = actionUI:find("text")
 583                         assert(actionMenuText)
 584
 585                         if actionInst.Entity~="" and actionInst.Action.Type~="" then
 586
 587                                 local actionLogicEntity = r2:getInstanceFromId(tostring(actionInst.Entity))
 588                                 assert(actionLogicEntity)
 589
 590                                 coloredName = (actionLogicEntity.InstanceId == self.filteredLogicEntityId)
 591                                 local actionType
 592                                 if coloredName then
 593                                         actionType = self.filterWordColor
 594                                 else
 595                                         actionType = self.communWordsColor
 596                                 end
 597                                 local name = "No name"
 598                                 if actionLogicEntity.getName then
 599                                         name = actionLogicEntity:getName()
 600                                 elseif actionLogicEntity.Name then
 601                                         name = actionLogicEntity.Name
 602                                 end
 603                                 actionType = actionType .. name .. " "
 604                                 if coloredName then actionType = actionType .. self.communWordsColor end
 605
 606                                 local class = actionLogicEntity.Class
 607                                 assert(class)
 608                                 actionType = actionType ..r2.getLogicAttribute(class, "ApplicableActions", actionInst.Action.Type).text
 609                                 if actionInst.Action.Value~="" then
 610                                         local instance = r2:getInstanceFromId(actionInst.Action.Value)
 611                                         assert(instance)
 612                                         actionType = actionType .. " '" .. instance:getShortName() .. "'"
 613                                 end
 614                                 if actionInst.Action.ValueString and actionInst.Action.ValueString ~= "" then
 615                                         if string.gfind(actionType, "%%1")() then
 616                                                 actionType = string.gsub(actionType, "%%1", "'"..tostring(actionInst.Action.ValueString).."'")
 617                                         else
 618                                                 actionType = actionType .. " '" .. tostring(actionInst.Action.ValueString).. "'"
 619                                         end
 620                                 end
 621
 622                                 local uc_action_text = ucstring()
 623                                 uc_action_text:fromUtf8(actionType)
 624                                 actionMenuText.uc_hardtext_single_line_format = uc_action_text
 625                         end
 626                 end
 627         else
 628                 self:newActionUI()
 629         end
 630
 631         -- conditions
 632         local conditionsList = eventEditor:find("conditions_list")
 633         assert(conditionsList)
 634         conditionsList:clear()
 635
 636         for i=0, instanceEvent.Conditions.Size-1 do
 637                 local conditionInst = instanceEvent.Conditions[i]
 638
 639                 local conditionUI = self:newConditionUI()
 640                 conditionUI.Env.InstanceId = conditionInst.InstanceId
 641
 642                 local conditionMenuText = conditionUI:find("text")
 643                 assert(conditionMenuText)
 644
 645                 if conditionInst.Entity~="" and conditionInst.Condition.Type~="" then
 646
 647                         local conditionLogicEntity = r2:getInstanceFromId(tostring(conditionInst.Entity))
 648                         assert(conditionLogicEntity)
 649
 650                         coloredName = (conditionLogicEntity.InstanceId == self.filteredLogicEntityId)
 651                         local conditionType
 652                         if coloredName then
 653                                 conditionType = self.filterWordColor
 654                         else
 655                                 conditionType = self.communWordsColor
 656                         end
 657                         conditionType = conditionType .. conditionLogicEntity.Name .. " "
 658                         if coloredName then conditionType = conditionType .. self.communWordsColor end
 659
 660                         local class = conditionLogicEntity.Class
 661                         assert(class)
 662                         conditionType = conditionType ..r2.getLogicAttribute(class, "Conditions", conditionInst.Condition.Type).text
 663                         if conditionInst.Condition.Value~="" then
 664                                 local instance = r2:getInstanceFromId(conditionInst.Condition.Value)
 665                                 assert(instance)
 666                                 conditionType = conditionType .. " '" .. instance:getShortName() .."'"
 667                         end
 668
 669                         local uc_condition_text = ucstring()
 670                         uc_condition_text:fromUtf8(conditionType)
 671                         conditionMenuText.uc_hardtext_single_line_format = uc_condition_text
 672                 end
 673         end
 674
 675         self:advancedEditor(((instanceEvent.Actions.Size > 1) or (instanceEvent.Conditions.Size > 0)))
 676
 677         -- match filter?
 678         local matchFilter = self:logicEntityActionMatchFilter(instanceEvent)
 679
 680         local dismatchFilter = eventEditor:find("dismatch_filter")
 681         assert(dismatchFilter)
 682         dismatchFilter.active = not matchFilter
 683
 684         -- valid event?
 685         self:updateValiditySymbol(eventEditor, instanceEvent)
 686 end
 687
 688 function r2.events:updateElementsUI()
 689
 690         local sequenceUI = self:currentSequUI()
 691         assert(sequenceUI)
 692
 693         local eltsList = sequenceUI:find("elements_list")
 694         assert(eltsList)
 695
 696         for i=0,eltsList.childrenNb-1 do
 697                 local elementUI = eltsList:getChild(i)
 698                 if r2.logicUI:getEltUIInstId(elementUI) then
 699                         self:updateElementUI(elementUI)
 700                 end
 701         end
 702 end
 703
 704 ----- CLOSE ELEMENT EDITOR ---------------------------------------------
 705 function r2.events:closeElementEditor()
 706         r2.logicComponents:closeElementEditor(r2.events)
 707 end
 708
 709 ------ NEW ELEMENT INST ------------------------------------------
 710 function r2.events:newElementInst()
 711
 712         r2.requestNewAction(i18n.get("uiR2EDNewEventAction"))
 713
 714         local logicEntity
 715         if self.filteredLogicEntityId~=nil then
 716                 logicEntity = r2:getInstanceFromId(self.filteredLogicEntityId)
 717         else
 718                 logicEntity = r2:getSelectedInstance()
 719         end
 720         assert(logicEntity)
 721
 722         local logicEvent = r2.newComponent("LogicEntityAction")
 723
 724         -- default event
 725         local defaultEvent
 726
 727         if not self.memberManagement or not logicEntity:isGrouped() then
 728                 local class = r2.Classes[logicEntity.Class]
 729                 assert(class)
 730                 if table.getn(class.Events) > 0 then
 731                         defaultEvent = class.Events[1]
 732                 else
 733                         debugInfo("Empty events table of lua class : "..logicEntity.Class)
 734                         return
 735                 end
 736         else
 737                 messageBox(i18n.get("uiR2EDNoEventCreation"))
 738                 return
 739         end
 740
 741         local eventType = r2.newComponent("EventType")
 742         eventType.Type = defaultEvent
 743         logicEvent.Event = eventType
 744
 745         local behavior = self:getBehavior(logicEntity)
 746         if not self.memberManagement then                               --TEMP
 747                         behavior = logicEntity:getBehavior()    --TEMP
 748         end                                                                                             --TEMP
 749         r2.requestInsertNode(behavior.InstanceId, "Actions", -1, "", logicEvent)
 750
 751         self.ownCreatedInstances[logicEvent.InstanceId] = true
 752
 753         r2.logicComponents:newElementInst(r2.events)
 754 end
 755
 756 -------- get first event in events list of a class -----------------
 757 function r2.events:hasApplicableActions(logicEntity)
 758
 759         local class = r2.Classes[logicEntity.Class]
 760         assert(class)
 761
 762 --      local eventsTable = {}
 763 --      if categoryEvent=="ApplicableActions" then
 764 --              eventsTable = logicEntity:getApplicableActions()
 765 --      else
 766 --              eventsTable = class[categoryEvent]
 767 --      end
 768         local actionsTable = logicEntity:getApplicableActions()
 769
 770         if table.getn(actionsTable) > 0 then
 771
 772                 if logicEntity:isGrouped() then
 773                         local groupIndependantEvent
 774                         for k, eventType in pairs(actionsTable) do
 775                                 local menuTitle = r2.getLogicAttribute(logicEntity.Class, "ApplicableActions", eventType)
 776                                 if menuTitle.groupIndependant==true then
 777                                         groupIndependantEvent = true
 778                                         break
 779                                 end
 780                         end
 781
 782                         if groupIndependantEvent==nil then
 783                                 return nil
 784                         end
 785                 end
 786         else
 787                 debugInfo("Empty 'ApplicableActions' table of lua class : "..logicEntity.Class)
 788                 return nil
 789         end
 790
 791         return true
 792 end
 793
 794 ------ NEW ELEMENT UI ------------------------------------------
 795 function r2.events:newElementUI(newInst)
 796         r2.logicUI:newElementUI(r2.events, newInst, false)
 797 end
 798
 799 ------ REMOVE ELEMENT INST ----------------------------------------
 800 function r2.events:removeElementInst()
 801         r2.requestNewAction(i18n.get("uiR2EDRemoveLogicElementAction"))
 802         r2.logicComponents:removeElementInst(r2.events)
 803         r2.requestEndAction()
 804 end
 805
 806 ------ REMOVE ELEMENT UI -------------------------------------------
 807 function r2.events:removeElementUI(removedEltUI)
 808         r2.logicUI:removeElementUI(r2.events, removedEltUI)
 809 end
 810
 811 ------ UPDATE ELEMENT TITLE -------------------------------------------
 812 function r2.events:updateElementTitle(eventUI)
 813
 814         r2.logicComponents:updateElementTitle(r2.events, eventUI, false)
 815 end
 816
 817 ------ UPDATE ELEMENT UI -------------------------------------------
 818 function r2.events:updateElementUI(elementUI)
 819
 820         r2.logicUI:updateElementUI(r2.events, elementUI)
 821
 822         local logicEntityAction = r2:getInstanceFromId(r2.logicUI:getEltUIInstId(elementUI))
 823         assert(logicEntityAction)
 824
 825         local matchFilter = self:logicEntityActionMatchFilter(logicEntityAction)
 826
 827         local dismatchFilter = elementUI:find("dismatch_filter")
 828         assert(dismatchFilter)
 829
 830         if dismatchFilter.active~=not matchFilter then
 831                 if matchFilter then
 832                         self.dismatchWithFilter = self.dismatchWithFilter-1
 833                 else
 834                         self.dismatchWithFilter = self.dismatchWithFilter+1
 835                 end
 836         end
 837
 838         local dismatchFilterMenu = getUI(self.uiId):find("filterMenu"):find("dismatch_filter")
 839         assert(dismatchFilterMenu)
 840         dismatchFilterMenu.active = (self.dismatchWithFilter>0)
 841
 842         dismatchFilter.active = not matchFilter
 843
 844         -- valid event?
 845         self:updateValiditySymbol(elementUI, logicEntityAction)
 846 end
 847
 848 -------------------------------------------------------------------------------
 849 function r2.events:updateValiditySymbol(elementUI, eventInst)
 850
 851         local invalidEvent = elementUI:find("invalid_event")
 852         assert(invalidEvent)
 853
 854         local validEvent = elementUI:find("valid_event")
 855         assert(validEvent)
 856
 857         local logicAct = eventInst:getLogicAct()
 858         invalidEvent.active = (logicAct==nil)
 859         validEvent.active = (logicAct~=nil and logicAct~=r2:getCurrentAct())
 860         if validEvent.active then
 861                 local uc_other_act = ucstring()
 862                 uc_other_act:fromUtf8(i18n.get("uiR2EDEventNotInCurrentAct"):toUtf8() .. "'" .. logicAct.Name .. "'")
 863                 validEvent.tooltip = uc_other_act
 864         end
 865 end
 866
 867 function r2.events:logicEntityActionMatchFilter(logicEntityAction)
 868
 869         local logicEntity = self:getLogicEntityParent(logicEntityAction)
 870         if not self.memberManagement then                                                       --TEMP
 871                 logicEntity = logicEntityAction:getLogicEntityParent()  --TEMP
 872         end
 873
 874         local matchFilter = (logicEntity.InstanceId==self.filteredLogicEntityId)
 875         if matchFilter then
 876                 return true
 877         end
 878
 879         for i=0, logicEntityAction.Actions.Size-1 do
 880                 local action = logicEntityAction.Actions[i]
 881                 if action.Entity==self.filteredLogicEntityId then
 882                         return true
 883                 end
 884         end
 885
 886         for i=0, logicEntityAction.Conditions.Size-1 do
 887                 local condition = logicEntityAction.Conditions[i]
 888                 if condition.Entity==self.filteredLogicEntityId then
 889                         return true
 890                 end
 891         end
 892
 893         return false
 894 end
 895
 896 --- INIT FILTER MENU ---------------------------------------------------
 897 function r2.events:initFilterMenu()
 898
 899         -- which entity menu initialization
 900         local logicEntityMenu = getUI("ui:interface:r2ed_triggers_menu")
 901         assert(logicEntityMenu)
 902
 903         local logicEntityMenu = logicEntityMenu:getRootMenu()
 904         assert(logicEntityMenu)
 905
 906         logicEntityMenu:reset()
 907
 908         -- entity classes
 909         for k, class in pairs(r2.Classes) do
 910                 if class.initLogicEntitiesMenu then class:initLogicEntitiesMenu(logicEntityMenu) end
 911         end
 912         logicEntityMenu:setMaxVisibleLine(self.maxVisibleLine)
 913
 914         -- for each entity classes, list of instances in current act
 915         for c=0,logicEntityMenu:getNumLine()-1 do
 916
 917                 logicEntityMenu:addSubMenu(c)
 918                 local subMenu = logicEntityMenu:getSubMenu(c)
 919
 920                 local entityClass = tostring(logicEntityMenu:getLineId(c))
 921                 local class = r2.Classes[entityClass]
 922
 923                 if class.initLogicEntitiesInstancesMenu then
 924                         class:initLogicEntitiesInstancesMenu(subMenu, "r2.events:filterEvents")
 925                 end
 926                 subMenu:setMaxVisibleLine(self.maxVisibleLine)
 927         end
 928
 929         r2.logicUI:openLogicMenu(getUICaller())
 930 end
 931
 932 ------ INIT EVENT TYPE MENU -------------------------------------------
 933 function r2.events:initEventMenu(categoryEvent)
 934
 935
 936
 937         -- local startTime = nltime.getPreciseLocalTime()
 938
 939         self.actionOrConditionUIId = getUICaller().parent.parent.id
 940
 941         -- which entity menu initialization
 942         local logicEntityMenu = getUI("ui:interface:r2ed_triggers_menu")
 943         assert(logicEntityMenu)
 944
 945         local logicEntityMenu = logicEntityMenu:getRootMenu()
 946         assert(logicEntityMenu)
 947
 948         logicEntityMenu:reset()
 949
 950         -- if a logic entity has been already selected, we give a direct access to this one
 951         local caller = getUI(self.actionOrConditionUIId)
 952         assert(caller)
 953         local logicEntity
 954         local firstLine = 0
 955         if caller.Env.InstanceId  ~= nil then
 956                 if categoryEvent=="Events" then
 957                         logicEntity = r2:getInstanceFromId(caller.Env.InstanceId)
 958                 elseif categoryEvent=="ApplicableActions" or categoryEvent=="Conditions" then
 959                         local instance = r2:getInstanceFromId(caller.Env.InstanceId)
 960                         logicEntity = r2:getInstanceFromId(instance.Entity)
 961                 end
 962         end
 963
 964
 965         --local endTime = nltime.getPreciseLocalTime()
 966         --debugInfo(string.format("time for 1 is %f", endTime - startTime))
 967         --startTime = nltime.getPreciseLocalTime()
 968
 969
 970         if logicEntity then
 971
 972                 firstLine = 2
 973                 local uc_name = ucstring()
 974                 uc_name:fromUtf8(logicEntity.Name)
 975                 logicEntityMenu:addLine(uc_name, "lua", "r2.events:setLogicEntity('".. logicEntity.InstanceId .."')", logicEntity.InstanceId)
 976                 logicEntityMenu:addSeparator()
 977
 978                 logicEntityMenu:addSubMenu(0)
 979                 local subMenuEventType = logicEntityMenu:getSubMenu(0)
 980
 981                 logicEntity:initEventTypeMenu(subMenuEventType, categoryEvent)
 982
 983                 if logicEntity.initEventValuesMenu then
 984                         logicEntity:initEventValuesMenu(subMenuEventType, categoryEvent)
 985                 end
 986                 subMenuEventType:setMaxVisibleLine(self.maxVisibleLine)
 987         end
 988
 989         --local endTime = nltime.getPreciseLocalTime()
 990         --debugInfo(string.format("time for 2 is %f", endTime - startTime))
 991         --startTime = nltime.getPreciseLocalTime()
 992
 993         -- entity classes
 994         for k, class in pairs(r2.Classes) do
 995                 if class.initLogicEntitiesMenu and table.getn(class[categoryEvent])~=0 then
 996                         class:initLogicEntitiesMenu(logicEntityMenu, (categoryEvent=="ApplicableActions"))
 997                 end
 998         end
 999         logicEntityMenu:setMaxVisibleLine(self.maxVisibleLine)
1000
1001         --local endTime = nltime.getPreciseLocalTime()
1002         --debugInfo(string.format("time for 3 is %f", endTime - startTime))
1003         --startTime = nltime.getPreciseLocalTime()
1004
1005         -- for each entity classes, list of instances in current act
1006         for c=firstLine,logicEntityMenu:getNumLine()-1 do
1007
1008                 logicEntityMenu:addSubMenu(c)
1009                 local subMenu = logicEntityMenu:getSubMenu(c)
1010
1011                 local entityClass = tostring(logicEntityMenu:getLineId(c))
1012                 local class = r2.Classes[entityClass]
1013
1014                 if class.initLogicEntitiesInstancesMenu then
1015
1016                         class:initLogicEntitiesInstancesMenu(subMenu, "r2.events:setLogicEntity")
1017
1018                         --local endTime = nltime.getPreciseLocalTime()
1019                         --debugInfo(string.format("time for 6 is %f", endTime - startTime))
1020                         --startTime = nltime.getPreciseLocalTime()
1021
1022                         -- for each entity, list of its events type
1023                         for e=0,subMenu:getNumLine()-1 do
1024
1025                                 local entityId = tostring(subMenu:getLineId(e))
1026                                 local entity = r2:getInstanceFromId(entityId)
1027                                 if entity then
1028
1029                                         subMenu:addSubMenu(e)
1030                                         local subMenuEventType = subMenu:getSubMenu(e)
1031
1032                                         entity:initEventTypeMenu(subMenuEventType, categoryEvent)
1033
1034                                         --local endTime = nltime.getPreciseLocalTime()
1035                                         --debugInfo(string.format("time for 7 is %f", endTime - startTime))
1036                                         --startTime = nltime.getPreciseLocalTime()
1037
1038                                         if entity.initEventValuesMenu then
1039                                                 entity:initEventValuesMenu(subMenuEventType, categoryEvent)
1040                                         end
1041
1042                                         --local endTime = nltime.getPreciseLocalTime()
1043                                         --debugInfo(string.format("time for 9 is %f", endTime - startTime))
1044                                         --startTime = nltime.getPreciseLocalTime()
1045
1046                                         subMenuEventType:setMaxVisibleLine(self.maxVisibleLine)
1047
1048                                         --local endTime = nltime.getPreciseLocalTime()
1049                                         --debugInfo(string.format("time for 8 is %f", endTime - startTime))
1050                                         --startTime = nltime.getPreciseLocalTime()
1051                                 end
1052                         end
1053                 end
1054                 subMenu:setMaxVisibleLine(self.maxVisibleLine)
1055         end
1056
1057         --local endTime = nltime.getPreciseLocalTime()
1058         --debugInfo(string.format("time for 4 is %f", endTime - startTime))
1059         --startTime = nltime.getPreciseLocalTime()
1060
1061         r2.logicUI:openLogicMenu(getUICaller())
1062
1063         --local endTime = nltime.getPreciseLocalTime()
1064         --debugInfo(string.format("time for 5 is %f", endTime - startTime))
1065         --startTime = nltime.getPreciseLocalTime()
1066
1067 end
1068
1069 ----- SET LOGIC ENTITY (selected in menu ) -------------------------------------------
1070 function r2.events:setLogicEntity(entityId)
1071         self.selectedLogicEntity = entityId
1072 end
1073
1074 ----- SET EVENT TYPE ------------------------------------------------
1075 function r2.events:setEventType(eventType, endRequest, categoryEvent)
1076
1077         self.selectedEventType = eventType
1078
1079         if endRequest==tostring(true) then
1080                 if categoryEvent=="Events" then self:setEvent("")
1081                 elseif categoryEvent=="ApplicableActions" then self:setAction("")
1082                 elseif categoryEvent=="Conditions" then self:setCondition("")
1083                 end
1084         end
1085 end
1086
1087 ----- SET EVENT VALUE ------------------------------------------------
1088 function r2.events:setEventValue(instanceId, categoryEvent, optionalValueString)
1089
1090         if categoryEvent=="Events" then self:setEvent(instanceId, optionalValueString)
1091         elseif categoryEvent=="ApplicableActions" then self:setAction(instanceId, optionalValueString)
1092         elseif categoryEvent=="Conditions" then self:setCondition(instanceId, optionalValueString)
1093         end
1094 end
1095
1096 ---- SET EVENT -----------------------------------------------------------------------
1097 function r2.events:setEvent(valueInstId, optionalValueString)
1098
1099         r2.requestNewAction(i18n.get("uiR2EDSetEventAction"))
1100
1101         local eventInst = self:currentEltInst()
1102         assert(eventInst)
1103
1104         local oldLogicEntity = self:getLogicEntityParent(eventInst)
1105         if not self.memberManagement then
1106                 oldLogicEntity = eventInst:getLogicEntityParent()
1107         end
1108         assert(oldLogicEntity)
1109
1110         local newLogicEntity = r2:getInstanceFromId(self.selectedLogicEntity)
1111         assert(newLogicEntity)
1112
1113         if oldLogicEntity~=newLogicEntity then
1114
1115                 local index = r2.logicComponents:searchElementIndex(eventInst)
1116                 index = index - 1
1117                 if index >= 0 then
1118                         local oldBehavior = self:getBehavior(oldLogicEntity)
1119                         local newBehavior = self:getBehavior(newLogicEntity)
1120                         if not self.memberManagement then                               --TEMP
1121                                 oldBehavior = oldLogicEntity:getBehavior()      --TEMP
1122                                 newBehavior = newLogicEntity:getBehavior()      --TEMP
1123                         end
1124                         r2.requestMoveNode(oldBehavior.InstanceId, "Actions", index,
1125                                 newBehavior.InstanceId, "Actions", -1)
1126                 end
1127         end
1128
1129         r2.requestSetNode(eventInst.Event.InstanceId, "Type", self.selectedEventType)
1130
1131         r2.requestSetNode(eventInst.Event.InstanceId, "Value", r2.RefId(valueInstId))
1132         if optionalValueString then
1133                 r2.requestSetNode(eventInst.Event.InstanceId, "ValueString", optionalValueString)
1134         elseif eventInst.ValueString and eventInst.ValueString ~="" then
1135                 r2.requestSetNode(eventInst.Event.InstanceId, "ValueString", optionalValueString)
1136         end
1137
1138
1139         self.selectedLogicEntity = nil
1140         self.selectedEventType = nil
1141 end
1142
1143 ------ SET ACTION  ------------------------------------------------------
1144 function r2.events:setAction(valueInstId, optionalValueString)
1145
1146         r2.requestNewAction(i18n.get("uiR2EDSetEventActionAction"))
1147
1148         local eventInst = self:currentEltInst()
1149         assert(eventInst)
1150
1151         local actionLogicEntity = r2:getInstanceFromId(self.selectedLogicEntity)
1152         assert(actionLogicEntity)
1153
1154         local caller = getUI(self.actionOrConditionUIId)
1155         assert(caller)
1156
1157         local action
1158         if caller.Env.InstanceId == nil then
1159                 action = r2.newComponent("ActionStep")
1160                 r2.requestInsertNode(eventInst.InstanceId, "Actions",-1,"", action)
1161                 caller.Env.InstanceId = action.InstanceId
1162         else
1163                 action = r2:getInstanceFromId(caller.Env.InstanceId)
1164         end
1165         assert(action)
1166
1167         r2.requestSetNode(action.InstanceId, "Entity", r2.RefId(self.selectedLogicEntity))
1168         r2.requestSetNode(action.Action.InstanceId, "Type", self.selectedEventType)
1169         r2.requestSetNode(action.Action.InstanceId, "Value", r2.RefId(valueInstId))
1170         if optionalValueString then
1171                 r2.requestSetNode(action.Action.InstanceId, "ValueString", optionalValueString)
1172         elseif action.Action.ValueString and action.Action.ValueString ~= "" then
1173                 r2.requestSetNode(action.Action.InstanceId, "ValueString", "")
1174         end
1175
1176
1177         self.selectedLogicEntity = nil
1178         self.selectedEventType = nil
1179         self.actionOrConditionUIId = nil
1180 end
1181
1182 ------ SET CONDITION  ------------------------------------------------------
1183 function r2.events:setCondition(valueInstId)
1184
1185         r2.requestNewAction(i18n.get("uiR2EDSetEventConditionAction"))
1186
1187         local eventInst = self:currentEltInst()
1188         assert(eventInst)
1189
1190         local actionLogicEntity = r2:getInstanceFromId(self.selectedLogicEntity)
1191         assert(actionLogicEntity)
1192
1193         local caller = getUI(self.actionOrConditionUIId)
1194         assert(caller)
1195
1196         local condition
1197         if caller.Env.InstanceId == nil then
1198                 condition = r2.newComponent("ConditionStep")
1199                 r2.requestInsertNode(eventInst.InstanceId, "Conditions",-1,"", condition)
1200                 caller.Env.InstanceId = condition.InstanceId
1201         else
1202                 condition = r2:getInstanceFromId(caller.Env.InstanceId)
1203         end
1204         assert(condition)
1205
1206         r2.requestSetNode(condition.InstanceId, "Entity", r2.RefId(self.selectedLogicEntity))
1207         r2.requestSetNode(condition.Condition.InstanceId, "Type", self.selectedEventType)
1208
1209         r2.requestSetNode(condition.Condition.InstanceId, "Value", r2.RefId(valueInstId))
1210
1211         self.selectedLogicEntity = nil
1212         self.selectedEventType = nil
1213         self.actionOrConditionUIId = nil
1214 end
1215
1216 ---- EDITOR ELEMENT IN ADVANCED OR EASY MODE
1217 function r2.events:advancedEditor(advancedMode)
1218
1219         local instanceEvent = self:currentEltInst()
1220         if instanceEvent==nil then return end
1221
1222         local sequenceUI = self:currentSequUI()
1223         assert(sequenceUI)
1224
1225         local eventEditor = sequenceUI:find("edit_element")
1226         assert(eventEditor)
1227
1228         local addActionButton = eventEditor:find("what_happens"):find("add")
1229         assert(addActionButton)
1230         addActionButton.active = advancedMode
1231
1232         local conditionsGr = eventEditor:find("conditions")
1233         assert(conditionsGr)
1234         conditionsGr.active = advancedMode
1235
1236         local addConditionButton = conditionsGr:find("add")
1237         assert(addConditionButton)
1238         addConditionButton.active = advancedMode
1239
1240         local advancedButton = eventEditor:find("advanced")
1241         advancedButton.active = not advancedMode
1242
1243         local conditionsList = eventEditor:find("conditions_gr")
1244         assert(conditionsList)
1245         conditionsList.active = (instanceEvent.Conditions.Size > 0)
1246 end
1247
1248 -- NEW ACTION -------------------------------------------------
1249 function r2.events:newActionUI()
1250
1251         local sequenceUI = self:currentSequUI()
1252         assert(sequenceUI)
1253
1254         local eventEditor = sequenceUI:find("edit_element")
1255         assert(eventEditor)
1256
1257         local actionsList = eventEditor:find("actions_list")
1258         assert(actionsList)
1259
1260         local idActionUI = "action" .. actionsList.childrenNb
1261
1262         local params = {
1263                                                 id=idActionUI, x="0", y="0", sizeref="w",
1264                                                 posparent="", posref="TL TL", w="0", h="20",
1265                                                 params_l="r2.events:initEventMenu('ApplicableActions')",
1266                                                 remove_menu="r2.events:removeActionInst()", params_over="r2.events:activeTrashButton('true')",
1267                                         }
1268
1269
1270         local newActionUI = createGroupInstance("menu_trash_template", actionsList.id, params)
1271         assert(newActionUI)
1272         actionsList:addChild(newActionUI)
1273         actionsList.parent:updateCoords()
1274
1275         newActionUI.Env.InstanceId = nil
1276
1277         return  newActionUI
1278 end
1279
1280 -- NEW CONDITION -------------------------------------------------
1281 function r2.events:newConditionUI()
1282
1283         local sequenceUI = self:currentSequUI()
1284         assert(sequenceUI)
1285
1286         local eventEditor = sequenceUI:find("edit_element")
1287         assert(eventEditor)
1288
1289         local conditionsGr = eventEditor:find("conditions_gr")
1290         assert(conditionsGr)
1291         conditionsGr.active = true
1292
1293         local conditionsList = eventEditor:find("conditions_list")
1294         assert(conditionsList)
1295
1296         local idConditionUI = "condition" .. conditionsList.childrenNb
1297
1298         local params = {
1299                                                 id=idConditionUI, x="0", y="0", sizeref="w",
1300                                                 posparent="", posref="TL TL", w="0", h="20",
1301                                                 params_l="r2.events:initEventMenu('Conditions')",
1302                                                 remove_menu="r2.events:removeConditionInst()", params_over="r2.events:activeTrashButton('false')",
1303                                         }
1304
1305
1306         local newConditionUI = createGroupInstance("menu_trash_template", conditionsList.id, params)
1307         assert(newConditionUI)
1308         conditionsList:addChild(newConditionUI)
1309         conditionsList.parent:updateCoords()
1310
1311         newConditionUI.Env.InstanceId = nil
1312
1313         return newConditionUI
1314 end
1315
1316
1317 --- ACTIVE TRASH BUTTON ----------------------------------------------------------
1318 function r2.events:activeTrashButton(actionsList)
1319
1320         local overMenuTrash = getUICaller().parent.parent
1321         assert(overMenuTrash)
1322
1323         local trashButtonCaller = overMenuTrash:find("remove_menu")
1324         assert(trashButtonCaller)
1325
1326         local menuTrashList = overMenuTrash.parent
1327         assert(menuTrashList)
1328
1329         if actionsList==tostring(true) and menuTrashList.childrenNb==1 then return end
1330
1331         for i=0, menuTrashList.childrenNb-1 do
1332                 local menuTrash = menuTrashList:getChild(i)
1333                 assert(menuTrash)
1334
1335                 local trashButton = menuTrash:find("remove_menu")
1336                 assert(trashButton)
1337
1338                 if trashButton.active then
1339                         if trashButton.id == trashButtonCaller.id then return end
1340                         trashButton.active = false
1341                         break
1342                 end
1343         end
1344
1345         trashButtonCaller.active = true
1346 end
1347
1348
1349 --- REMOVE CONDITION INSTANCE -----------------------------------------------------
1350 function r2.events:removeConditionInst()
1351
1352         r2.requestNewAction(i18n.get("uiR2EDRemoveEventConditionAction"))
1353
1354         local menuTrash = getUICaller().parent.parent.parent.parent
1355         assert(menuTrash)
1356
1357         local menuTrashList = menuTrash.parent
1358         assert(menuTrashList)
1359
1360         if menuTrash.Env.InstanceId~=nil then
1361                 r2.requestEraseNode(menuTrash.Env.InstanceId, "", -1)
1362         else
1363                 menuTrashList:delChild(menuTrash)
1364         end
1365 end
1366
1367 --- REMOVE ACTION INSTANCE -----------------------------------------------------
1368 function r2.events:removeActionInst()
1369
1370         r2.requestNewAction(i18n.get("uiR2EDRemoveEventActionAction"))
1371
1372         local menuTrash = getUICaller().parent.parent.parent.parent
1373         assert(menuTrash)
1374
1375         local menuTrashList = menuTrash.parent
1376         assert(menuTrashList)
1377
1378         if menuTrash.Env.InstanceId~=nil then
1379                 r2.requestEraseNode(menuTrash.Env.InstanceId, "", -1)
1380         else
1381                 menuTrashList:delChild(menuTrash)
1382         end
1383 end
1384
1385
1386
1387
1388
1389
1390
1391
1392 --------------------------------------------------------------------------------------------------
1393 -------------------------------- LOGIC ENTITY DisplayerProperties -------------------------
1394 --------------------------------------------------------------------------------------------------
1395 local logicEntityPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1396
1397 ------------------------------------------------
1398 function logicEntityPropertySheetDisplayerTable:onPostCreate(instance)
1399 end
1400 ------------------------------------------------
1401 function logicEntityPropertySheetDisplayerTable:onErase(instance)
1402
1403         local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
1404
1405         if elementUI then
1406                 r2.events:removeElementUI(elementUI)
1407         end
1408 end
1409 ------------------------------------------------
1410 function logicEntityPropertySheetDisplayerTable:onPreHrcMove(instance)
1411 end
1412 ------------------------------------------------
1413 function logicEntityPropertySheetDisplayerTable:onPostHrcMove(instance)
1414 end
1415 ------------------------------------------------
1416 function logicEntityPropertySheetDisplayerTable:onFocus(instance, hasFocus)
1417 end
1418
1419 ------------------------------------------------
1420 function logicEntityPropertySheetDisplayerTable:onSelect(instance, isSelected)
1421
1422         if not isSelected then
1423                 r2.events:closeEditor()
1424         end
1425 end
1426
1427 ------------------------------------------------
1428 local oldOnAttrModified = logicEntityPropertySheetDisplayerTable.onAttrModified
1429 function logicEntityPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1430
1431         if attributeName == "Name" then
1432                 local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
1433
1434                 if elementUI then
1435                         r2.events:updateElementUI(elementUI)
1436                 end
1437         end
1438    oldOnAttrModified(self, instance, attributeName)
1439 end
1440
1441 ------------------------------------------------
1442 function r2:logicEntityPropertySheetDisplayer()
1443         return logicEntityPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1444 end
1445
1446
1447
1448 --------------------------------------------------------------------------------------------------
1449 -------------------------------- LOGIC ENTITY ACTION DisplayerProperties -------------------------
1450 --------------------------------------------------------------------------------------------------
1451 local logicEntityActionPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1452
1453 ------------------------------------------------
1454 function logicEntityActionPropertySheetDisplayerTable:onPostCreate(instance)
1455
1456         local filterIsLogicEntityParentB = r2.events:filterIsLogicEntityParent(instance)
1457         if not r2.events.memberManagement then
1458                 filterIsLogicEntityParentB = (instance:getLogicEntityParent().InstanceId==r2.events.filteredLogicEntityId)
1459         end
1460         if filterIsLogicEntityParentB then
1461                 r2.events:newElementUI(instance)
1462         end
1463 end
1464 ------------------------------------------------
1465 function logicEntityActionPropertySheetDisplayerTable:onErase(instance)
1466
1467         instance.User.Deleted = true
1468
1469         local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
1470
1471         if elementUI then
1472                 r2.events:removeElementUI(elementUI)
1473         end
1474 end
1475 ------------------------------------------------
1476 function logicEntityActionPropertySheetDisplayerTable:onPreHrcMove(instance)
1477 end
1478
1479 ------------------------------------------------
1480 function logicEntityActionPropertySheetDisplayerTable:onPostHrcMove(instance)
1481
1482         local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
1483
1484         local filterIsLogicEntityParentB = r2.events:filterIsLogicEntityParent(instance)
1485         if not r2.events.memberManagement then
1486                 filterIsLogicEntityParentB = (instance:getLogicEntityParent().InstanceId==r2.events.filteredLogicEntityId)
1487         end
1488
1489         if elementUI then
1490                 r2.events:updateElementUI(elementUI)
1491         elseif filterIsLogicEntityParentB then
1492                 r2.events:newElementUI(instance)
1493         end
1494 end
1495 ------------------------------------------------
1496 function logicEntityActionPropertySheetDisplayerTable:onFocus(instance, hasFocus)
1497 end
1498
1499 ------------------------------------------------
1500 function logicEntityActionPropertySheetDisplayerTable:onSelect(instance, isSelected)
1501 end
1502
1503 ------------------------------------------------
1504 function logicEntityActionPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1505
1506         local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
1507
1508         if elementUI then
1509                 r2.events:updateElementUI(elementUI)
1510         end
1511 end
1512
1513 ------------------------------------------------
1514 function r2:logicEntityActionPropertySheetDisplayer()
1515         return logicEntityActionPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1516 end
1517
1518
1519 --------------------------------------------------------------------------------------------------
1520 -------------------------------- EVENT TYPE DisplayerProperties -----------------------
1521 --------------------------------------------------------------------------------------------------
1522 local eventTypePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1523
1524 ------------------------------------------------
1525 function eventTypePropertySheetDisplayerTable:onPostCreate(instance)
1526 end
1527 ------------------------------------------------
1528 function eventTypePropertySheetDisplayerTable:onErase(instance)
1529 end
1530 ------------------------------------------------
1531 function eventTypePropertySheetDisplayerTable:onPreHrcMove(instance)
1532 end
1533 ------------------------------------------------
1534 function eventTypePropertySheetDisplayerTable:onPostHrcMove(instance)
1535 end
1536 ------------------------------------------------
1537 function eventTypePropertySheetDisplayerTable:onFocus(instance, hasFocus)
1538 end
1539
1540 ------------------------------------------------
1541 function eventTypePropertySheetDisplayerTable:onSelect(instance, isSelected)
1542 end
1543
1544 ------------------------------------------------
1545 function eventTypePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1546 end
1547
1548 ------------------------------------------------
1549 function eventTypePropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
1550         r2.requestEraseNode(instance.Parent.InstanceId, "", -1)
1551 end
1552 ------------------------------------------------
1553 function eventTypePropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
1554         if targetAttrName == "Name" then
1555
1556                 local eventInst = instance.Parent
1557                 assert(eventInst.Class=="LogicEntityAction")
1558                 local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
1559
1560                 if elementUI then
1561                         r2.events:updateElementUI(elementUI)
1562                 end
1563         end
1564 end
1565
1566 ------------------------------------------------
1567 function r2:eventTypePropertySheetDisplayer()
1568         return eventTypePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1569 end
1570
1571
1572
1573 --------------------------------------------------------------------------------------------------
1574 -------------------------------- ACTION STEP DisplayerProperties -----------------------
1575 --------------------------------------------------------------------------------------------------
1576 local actionStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1577
1578 ------------------------------------------------
1579 function actionStepPropertySheetDisplayerTable:onPostCreate(instance)
1580 end
1581 ------------------------------------------------
1582 function actionStepPropertySheetDisplayerTable:onErase(instance)
1583 end
1584 ------------------------------------------------
1585 function actionStepPropertySheetDisplayerTable:onPreHrcMove(instance)
1586 end
1587 ------------------------------------------------
1588 function actionStepPropertySheetDisplayerTable:onPostHrcMove(instance)
1589 end
1590 ------------------------------------------------
1591 function actionStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)
1592 end
1593
1594 ------------------------------------------------
1595 function actionStepPropertySheetDisplayerTable:onSelect(instance, isSelected)
1596 end
1597
1598 ------------------------------------------------
1599 function actionStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1600 end
1601
1602 ------------------------------------------------
1603 function actionStepPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
1604
1605         if refIdName == "Entity" then
1606                 r2.requestEraseNode(instance.InstanceId, "", -1)
1607         end
1608 end
1609 ------------------------------------------------
1610 function actionStepPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
1611         if targetAttrName == "Name" then
1612
1613                 local eventInst = instance.Parent.Parent
1614                 assert(eventInst.Class=="LogicEntityAction")
1615                 local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
1616
1617                 if elementUI then
1618                         r2.events:updateElementUI(elementUI)
1619                 end
1620         end
1621 end
1622
1623 ------------------------------------------------
1624 function actionStepPropertySheetDisplayerTable:onTargetInstancePostHrcMove(instance, refIdName, refIdIndexInArray)
1625
1626         if refIdName=="Entity" then
1627                 r2.requestSetNode(instance.InstanceId, "Entity", r2.RefId(""))
1628                 r2.requestSetNode(instance.Action.InstanceId, "Type", "")
1629                 r2.requestSetNode(instance.Action.InstanceId, "Value", r2.RefId(""))
1630         end
1631 end
1632
1633
1634 ------------------------------------------------
1635 function r2:actionStepPropertySheetDisplayer()
1636         return actionStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1637 end
1638
1639
1640
1641 --------------------------------------------------------------------------------------------------
1642 -------------------------------- ACTION TYPE DisplayerProperties -----------------------
1643 --------------------------------------------------------------------------------------------------
1644 local actionTypePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1645
1646 ------------------------------------------------
1647 function actionTypePropertySheetDisplayerTable:onPostCreate(instance)
1648 end
1649 ------------------------------------------------
1650 function actionTypePropertySheetDisplayerTable:onErase(instance)
1651 end
1652 ------------------------------------------------
1653 function actionTypePropertySheetDisplayerTable:onPreHrcMove(instance)
1654 end
1655 ------------------------------------------------
1656 function actionTypePropertySheetDisplayerTable:onPostHrcMove(instance)
1657 end
1658 ------------------------------------------------
1659 function actionTypePropertySheetDisplayerTable:onFocus(instance, hasFocus)
1660 end
1661
1662 ------------------------------------------------
1663 function actionTypePropertySheetDisplayerTable:onSelect(instance, isSelected)
1664 end
1665
1666 ------------------------------------------------
1667 function actionTypePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1668 end
1669
1670 ------------------------------------------------
1671 function actionTypePropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
1672         r2.requestSetNode(instance.InstanceId, "Type", "")
1673         r2.requestSetNode(instance.InstanceId, "Value", r2.RefId(""))
1674 end
1675 ------------------------------------------------
1676 function actionTypePropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
1677         if targetAttrName == "Name" then
1678
1679                 local eventInst = instance.Parent.Parent.Parent
1680                 assert(eventInst.Class=="LogicEntityAction")
1681                 local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
1682
1683                 if elementUI then
1684                         r2.events:updateElementUI(elementUI)
1685                 end
1686         end
1687 end
1688
1689 ------------------------------------------------
1690 function r2:actionTypePropertySheetDisplayer()
1691         return actionTypePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1692 end
1693
1694
1695
1696 --------------------------------------------------------------------------------------------------
1697 -------------------------------- CONDITION STEP DisplayerProperties -----------------------
1698 --------------------------------------------------------------------------------------------------
1699 local conditionStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1700
1701 ------------------------------------------------
1702 function conditionStepPropertySheetDisplayerTable:onPostCreate(instance)
1703 end
1704 ------------------------------------------------
1705 function conditionStepPropertySheetDisplayerTable:onErase(instance)
1706 end
1707 ------------------------------------------------
1708 function conditionStepPropertySheetDisplayerTable:onPreHrcMove(instance)
1709 end
1710 ------------------------------------------------
1711 function conditionStepPropertySheetDisplayerTable:onPostHrcMove(instance)
1712 end
1713 ------------------------------------------------
1714 function conditionStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)
1715 end
1716
1717 ------------------------------------------------
1718 function conditionStepPropertySheetDisplayerTable:onSelect(instance, isSelected)
1719 end
1720
1721 ------------------------------------------------
1722 function conditionStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1723 end
1724
1725 ------------------------------------------------
1726 function conditionStepPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
1727
1728         if refIdName == "Entity" then
1729                 r2.requestEraseNode(instance.InstanceId, "", -1)
1730         end
1731 end
1732 ------------------------------------------------
1733 function conditionStepPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
1734         if targetAttrName == "Name" then
1735
1736                 local eventInst = instance.Parent.Parent
1737                 assert(eventInst.Class=="LogicEntityAction")
1738                 local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
1739
1740                 if elementUI then
1741                         r2.events:updateElementUI(elementUI)
1742                 end
1743         end
1744 end
1745
1746 ------------------------------------------------
1747 function r2:conditionStepPropertySheetDisplayer()
1748         return conditionStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1749 end
1750
1751
1752
1753
1754 --------------------------------------------------------------------------------------------------
1755 -------------------------------- CONDITION TYPE DisplayerProperties -----------------------
1756 --------------------------------------------------------------------------------------------------
1757 local conditionTypePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
1758
1759 ------------------------------------------------
1760 function conditionTypePropertySheetDisplayerTable:onPostCreate(instance)
1761 end
1762 ------------------------------------------------
1763 function conditionTypePropertySheetDisplayerTable:onErase(instance)
1764 end
1765 ------------------------------------------------
1766 function conditionTypePropertySheetDisplayerTable:onPreHrcMove(instance)
1767 end
1768 ------------------------------------------------
1769 function conditionTypePropertySheetDisplayerTable:onPostHrcMove(instance)
1770 end
1771 ------------------------------------------------
1772 function conditionTypePropertySheetDisplayerTable:onFocus(instance, hasFocus)
1773 end
1774
1775 ------------------------------------------------
1776 function conditionTypePropertySheetDisplayerTable:onSelect(instance, isSelected)
1777 end
1778
1779 ------------------------------------------------
1780 function conditionTypePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
1781 end
1782
1783 ------------------------------------------------
1784 function conditionTypePropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
1785         r2.requestSetNode(instance.InstanceId, "Type", "")
1786         r2.requestSetNode(instance.InstanceId, "Value", r2.RefId(""))
1787 end
1788 ------------------------------------------------
1789 function conditionTypePropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
1790         if targetAttrName == "Name" then
1791
1792                 local eventInst = instance.Parent.Parent.Parent
1793                 assert(eventInst.Class=="LogicEntityAction")
1794                 local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
1795
1796                 if elementUI then
1797                         r2.events:updateElementUI(elementUI)
1798                 end
1799         end
1800 end
1801
1802 ------------------------------------------------
1803 function r2:conditionTypePropertySheetDisplayer()
1804         return conditionTypePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
1805 end
1806
1807
1808
1809
1810
1811