LoTROInterface SVN SequenceBars

Manager = class(Group);

function Manager:Constructor()

    Turbine.UI.Window.Constructor(self);

    self.constructing = true;

    self.manager = self;

    self.groupID = "0";

    self.objects = {};

    self.eventGenerators = {};

    self.eventCallbacks = {};

    self.lastSaveTime = 0;

    self.username = Turbine.Gameplay.LocalPlayer:GetInstance():GetName();

    -- Default settings

    self.settings = {};

    self.settings.type = "group";

    self.settings.caption = {};

    self.settings.snapToGrid = false;

    self.settings.gridSize = 35;

    self.settings.language = Turbine.Engine:GetLanguage();

    local name = L:GetText("/Default/GlobalName");

    self.settings.caption.text = string.gsub(name, "<name>", self.username);

    self.settings.caption.width = 80;

    self.settings.caption.height = 20;

    self.settings.caption.font = Turbine.UI.Lotro.Font.TrajanPro15;

    self.settings.color = "FFFFFF";

    self.settings.barIDs = {};

    self.settings.groupIDs = { "new" };

    self.settings.deletedBarIDs = {};

    self.settings.deletedGroupIDs = {};

    self.settings.eventHandlers = {};

    self.settings.eventsEnabled = false;

    self.settings.groups = {};

    self.settings.bars = {};

    self.settings.nextObjectID = 1;

    self.globals = self.settings;

    self:LoadSettings();

end

function Manager:LoadSettings()

    Turbine.PluginData.Load(Turbine.DataScope.Character, "SequenceBars", function(loadStr)

        if (loadStr) then

            -- Workaround for Turbine localization bug -- Thanks, Lynx3d!

            local settings = ImportTable(loadStr);

            if (not settings) then

                Turbine.Shell.WriteLine("Failed to parse SequenceBars.plugindata file!");

                return;

            end

            -- Previously-saved settings override the defaults

            DeepTableCopy(settings, self.settings);

        end

        -- Make color object from hex string

        self.color = Thurallor.Utils.Color(1, 0, 0, 0);

        self.color:SetHex(self.settings.color);

        -- Select language

        L:SetLanguage(self.settings.language);

        self:LoadBars();

        self:LoadGroups();

        self:UpdateOptionsPanel();

        self.constructing = nil;

    end);

end

function Manager:Unload()

    self.lastSaveTime = 0;

    self.constructing = false;

    self.editingCaption = true;

    self.lastSaveTime = 0; -- force save

    self:SaveSettings(false);

    for objectID, object in pairs(self.objects) do

--Puts("Destroying object " .. tostring(objectID));

        if (object) then

            object:Destroy();

        end

    end

end

function Manager:SaveSettings(updateOptionsPanel)

    if (updateOptionsPanel) then

        self.updateOptionsPanel = true;

    end

    if (not self.constructing) then

        -- Start the idle timer.

        self.lastIdleTime = Turbine.Engine.GetGameTime();

        self:SetWantsUpdates(true);

    end

end

function Manager:Update()

    -- Save will only occur when idle time reaches 0.25 s.

    local currentTime = Turbine.Engine.GetGameTime();

    if (currentTime - self.lastIdleTime < 0.25) then

        return;

    end

--Puts("Saving...");

    -- Workaround for Turbine localization bug -- Thanks, Lynx3d!

    local saveData = ExportTable(self.settings);

    Turbine.PluginData.Save(Turbine.DataScope.Character, "SequenceBars", saveData, function()

--Puts("Save complete.");

    end);

    if (self.updateOptionsPanel and (not self.editingCaption)) then

        self:UpdateOptionsPanel();

        self.updateOptionsPanel = false;

    end

    self:SetWantsUpdates(false);

end

function Manager:UpdateOptionsPanel()

    if (not self.optionsPanel) then

        self.optionsPanel = OptionsPanel(self);

    end

    self.optionsPanel:Update();

end

function Manager:FindNewObjectID()

    local id = self.settings.nextObjectID;

    self.settings.nextObjectID = id + 1;

    id = self.username .. "." .. tostring(id);

    self.objects[id] = { "reserved" };

    return id;

end

function Manager:HaveTrash()

    local haveTrash = (#self.settings.deletedGroupIDs > 0);

    for g = 1, #self.settings.groupIDs, 1 do

        local groupID = self.settings.groupIDs[g];

        local object = self.objects[groupID];

        if ((object) and (object:HaveTrash())) then

            haveTrash = true;

        end

    end

    return haveTrash;

end

function Manager:TransferBar(barID, oldGroup, newGroup)

    local foundPos = nil;

    for pos = 1, #oldGroup.settings.barIDs, 1 do

        if (oldGroup.settings.barIDs[pos] == barID) then

            foundPos = pos;

            break;

        end

    end

    if (foundPos) then

        table.remove(oldGroup.settings.barIDs, foundPos);

        table.insert(newGroup.settings.barIDs, barID);

        local bar = self.objects[barID];

        bar.parent = newGroup;

        self:SaveSettings(true);

    end

end

function Manager:TransferGroup(groupID, oldGroup, newGroup)

    local foundPos = nil;

    for pos = 1, #oldGroup.settings.groupIDs, 1 do

        if (oldGroup.settings.groupIDs[pos] == groupID) then

            foundPos = pos;

            break;

        end

    end

    if (foundPos) then

        table.remove(oldGroup.settings.groupIDs, foundPos);

        table.insert(newGroup.settings.groupIDs, groupID);

        local group = self.objects[groupID];

        group.parent = newGroup;

        self:SaveSettings(true);

    end

end

function Manager:EmptyTrash()

    self.settings.deletedGroupIDs = {};

    for groupID, settings in pairs(self.settings.groups) do

        settings.deletedGroupIDs = {};

        settings.deletedBarIDs = {};

        if (not self.objects[groupID]) then

            self.settings.groups[groupID] = nil;

        end

    end

    for barID, bar in pairs(self.settings.bars) do

        if (not self.objects[barID]) then

            self.settings.bars[barID] = nil;

        end

    end

    self:SaveSettings(false);

end

function Manager:ShowSettingsMenu()

    -- Build the settings menu.

    if (not self.settingsMenu) then

        self.settingsMenu = Turbine.UI.ContextMenu();

    end

    Group.AddSettingsMenuItem(self, self.settingsMenu, "Root", true);

    self.amSubMenu = false;

    self:AddSettingsMenuItem(self.settingsMenu, "Root");

    self.settingsMenu:ShowMenu();

end

function Manager:AddSettingsMenuItem(parent, itemName, amSubMenu)

    if (amSubMenu ~= nil) then

        self.amSubMenu = amSubMenu;

    end

    local item = Turbine.UI.MenuItem(L:GetText(itemName), true, false);

    parent:GetItems():Add(item);

    if (itemName == "Root") then

        local prevContext = L:SetContext("/GlobalMenu");

        parent:GetItems():Clear();

        self:AddSettingsMenuItem(parent, "HideAll");

        if (not self.amSubMenu) then

            L:SetContext("/GroupMenu");

            Group.AddSettingsMenuItem(self, parent, "CreateNewBar");

            Group.AddSettingsMenuItem(self, parent, "CreateNewSubgroup");

            Group.AddSettingsMenuItem(self, parent, "Import");

        end

        if (#self.settings.deletedBarIDs + #self.settings.deletedGroupIDs > 0) then

            self:AddSettingsMenuItem(parent, "Undelete");

        end

        L:SetContext("/GroupMenu");

        Group.AddSettingsMenuItem(self, parent, "ArrangeBars");

        Group.AddSettingsMenuItem(self, parent, "EventBehaviors");

        L:SetContext("/GlobalMenu");

        self:AddSettingsMenuItem(parent, "GlobalSettings");

        if (self:HaveTrash()) then

            self:AddSettingsMenuItem(parent, "EmptyTrash");

        end

        L:SetContext(prevContext);

    elseif (itemName == "HideAll") then

        item:SetChecked(self.settings.hidden);

        item.Click = function(sender, args)

            self:SetHidden(not self.settings.hidden);

        end

    elseif (itemName == "GlobalSettings") then

        local prevContext = L:SetContext("/GlobalMenu/GlobalSettingsMenu");

        self:AddSettingsMenuItem(item, "SnapToGrid");

        self:AddSettingsMenuItem(item, "Language");

        L:SetContext(prevContext);

    elseif (itemName == "SnapToGrid") then

        item:SetChecked(self.settings.snapToGrid);

        item.Click = function(sender, args)

            self.settings.snapToGrid = not self.settings.snapToGrid;

            if (self.settings.snapToGrid) then

                self:SnapToGrid();

            end

        end

    elseif (itemName == "Language") then

        local prevContext = L:SetContext("LanguageMenu");

        self:AddSettingsMenuItem(item, "English");

        self:AddSettingsMenuItem(item, "French");

        self:AddSettingsMenuItem(item, "German");

        self:AddSettingsMenuItem(item, "Russian");

        L:SetContext(prevContext);

    elseif (string.find("English|French|German|Russian", itemName)) then

        local checked = (L:GetLanguage() == Turbine.Language[itemName]);

        item:SetChecked(checked);

        item:SetEnabled(not checked);

        item.Click = function(sender, args)

            local language = Turbine.Language[itemName];

            self.settings.language = language;

            L:SetLanguage(language);

            self:SaveSettings(true);

        end

    elseif (itemName == "EmptyTrash") then

        item.Click = function(sender, args)

            self:EmptyTrash();

        end

    else

        -- Item is not handled here; send it to Group:AddSettingsMenuItem().

        parent:GetItems():RemoveAt(parent:GetItems():GetCount());

        Group.AddSettingsMenuItem(self, parent, itemName, true);

    end

end

function Manager:GetNearestGridPos(left, top)

    local gridSize = self.settings.gridSize;

    local displayBottom = Turbine.UI.Display:GetHeight() - 1;

    local centerLeft = math.floor(0.5 + Turbine.UI.Display:GetWidth() / 2 + gridSize / 2) + 3;

    local offsetLeft, offsetTop = left - centerLeft, displayBottom - top;

    local newLeft = centerLeft + math.floor(0.5 + offsetLeft / gridSize) * gridSize;

    local newTop = displayBottom - math.floor(0.5 + offsetTop / gridSize) * gridSize;

    return newLeft, newTop;

end

function Manager:AddEventGenerator(object, eventName)

    if (not self.eventGenerators[eventName]) then

        self.eventGenerators[eventName] = {};

    end

    table.insert(self.eventGenerators[eventName], object);

    local generatorID = #self.eventGenerators[eventName];

--Puts("Adding event generator " .. tostring(generatorID) .. " for event " .. Serialize(eventName) .. " from object " .. Serialize(object.settings.caption.text));

    return generatorID;

end

function Manager:RemoveEventGenerator(generatorID, eventName)

    local object = self.eventGenerators[eventName][generatorID];

--Puts("Removing event generator " .. tostring(generatorID) .. " for event " .. Serialize(eventName) .. " (was from object " .. Serialize(object.settings.caption.text));

    table.remove(self.eventGenerators[eventName], generatorID);

    if (#self.eventGenerators[eventName] == 0) then

        self.eventGenerators[eventName] = nil;

    end

end

-- Returns a list of bars that generates the specified event

function Manager:GetEventGenerators(eventName)

    return self.eventGenerators[eventName];

end

-- Returns the names of all of the events generated by all bars

function Manager:GetEventNames()

    local eventNames = {};

    for k in keys(self.eventGenerators) do

        table.insert(eventNames, k);

    end

    return eventNames;

end

function Manager:GetEventCallbacks()

    return self.eventCallbacks;

end

function Manager:PropagateEvent(eventName)

    local callbacks = self.eventCallbacks[eventName];

    if (type(callbacks) == "table") then

--Puts("Propagating event \"" .. tostring(eventName) .. "\" to " .. tostring(#callbacks) .. " callback functions: " .. Serialize(callbacks));

        for f = 1, #callbacks do

            local func = callbacks[f];

            func(eventName);

        end

    elseif (type(callbacks) == "function") then

--Puts("Propagating event \"" .. tostring(eventName) .. "\" to a single callback function: " .. Serialize(callbacks));

        callbacks(eventName);

    end

end