LoTROInterface SVN KragenBars

import "Turbine.UI";
import "Turbine.UI.Lotro";
import "Turbine.Gameplay";
import "KragenPlugs.Utils";
import "KragenPlugs.KragenBars";

ClassBar = class( );

function ClassBar:Constructor()
        
        -- inialize the setupWindow
        self.setup = SetupWindow();
        self.setupbb = self.setup.setupbb;
        self.setupf = self.setup.setupf;
        self.setupqs = self.setup.setupqs;
        
        -- inialize tables
        self.windows = { };
        self.bars = { };
        self.skills = { };
        self.multi = { };
        
        self.barlist = { };
        self.effectlist = {};
        self.barcount = 0;
        
        self.setup:SetWantsKeyEvents(true);
        
        self.setup.KeyDown = function(sender, args)
        if args.Action == 0x100000B3 then
                        self.setup:SetWantsUpdates(true);
                end
        end
        
        self.setup.Update = function(sender, args)
        for k,v in pairs(self.skills) do
                        v:RefreshBorders();
                end
                self.setup:SetWantsUpdates(false);
        end
        
        -- SET AND UPDATE DEFAULT SETTINGS
    if (not settings.class) then
        settings.class = vars.playerclass;
        self:DefaultSettings();
        self:ShowSetup();
    else
        self.settings = settings.classinfo;
        if (settings.vers ~= vars.vers) then
                self:UpdateSettings();
        end
    end 
        
        -- BUILD ALL WINDOWS AND USERCONF BARS
        for k,v in pairs(self.settings.userconf) do
                self.barlist[v.id] = k;
                self.windows[k] = SkillWindow(v);
                self.bars[k] = SkillBar(self.windows[k], 1, 1, v.size[1], v.size[2], true, false);
                self.barcount = self.barcount + 1;
        end
        
        for k,v in pairs(self.settings.preconf) do
                self.barlist[v.id] = k;
                self.windows[k] = SkillWindow(v);
                self.barcount = self.barcount + 1;
        end
        
        -- Combat Event
        AddCallback(vars.player, "InCombatChanged", function(sender, args)
                KragenBars:CombatChange(vars.player:IsInCombat());
        end);
        
        -- Effect Events
    AddCallback(vars.effects, "EffectAdded", function(sender, args)
                KragenBars:AddEffect( args.Index );
        end);

        AddCallback(vars.effects, "EffectRemoved", function(sender, args)
                if (args.Effect ~= nil) then
                        KragenBars:RemoveEffect( args.Effect );
                end
        end);
        
end

-- Index and Position Bars
function ClassBar:InitBars()
        self.DefineEffectList();
        
        for k,v in pairs(self.bars) do
                v.index = k;
        end
        
        if(settings.skilldata ~=nil) then
                for k,v in pairs(self.skills) do
                        if (settings.skilldata[k] ~= nil) then
                            local data = settings.skilldata[k];
                            data.parent = self.bars[settings.skilldata[k].parent]
                                v:LoadPosition(data);
                        end
                end
        end
        
        if(settings.multidata ~=nil) then
                for k,v in pairs(self.multi) do
                        if (settings.multidata[k] ~= nil) then
                                local data = settings.multidata[k];
                            data.parent = self.bars[settings.multidata[k].parent]
                                v:LoadPosition(data);
                        end
                end
        end
        
        for k,v in pairs(self.windows) do
                v:SetVisible(v.active);
        end
        
        for k,v in pairs(self.skills) do
                if (v.parent ~= nil) then
                        v.parent:AddSkill(v);
                end
                v:RefreshBorders();
        end
        
        for i = 1, vars.effects:GetCount() do
                self:AddEffect(i);
        end
        
        self.tempwindow = Turbine.UI.Window();
        self.tempwindow:SetPosition(100, 100);
        self.tempwindow:SetSize(300, 300);
        self.tempwindow:SetVisible( false );
        self.tempwindow:SetBackColor(Turbine.UI.Color(.925, 0, 0, 0));
        
        self.pulldown = KragenPlugs.UI.ComboBox();
    self.pulldown:SetParent(self.tempwindow);
    self.pulldown:SetSize(190, 20);
    self.pulldown:SetPosition(10, 10);
    self.pulldown:SetVisible(true);
        self.pulldown:AddItem(" ", 0);
        for k,v in pairs(self.barlist) do
                if (self.settings.preconf[v] ~= nil) then
                        self.pulldown:AddItem(self.settings.preconf[v].name, k);
                elseif (self.settings.userconf[v] ~= nil) then
                        self.pulldown:AddItem(self.settings.userconf[v].name, k);
                end
                
        end
        
        self.pulldown.SelectedIndexChanged = function(sender, args)
                if (self.windows[self.currentkey] ~= nil) then 
                        self.windows[self.currentkey]:SetBackColor(Turbine.UI.Color(nil));
                        self.nameText:SetWantsUpdates(false);
                        self.enabled:SetWantsUpdates(false);
                        self.widthslider:SetWantsUpdates(false);
                        self.heightslider:SetWantsUpdates(false);
                        self.windows[self.currentkey].dragBar:SetRotator(true);
                        self.windows[self.currentkey].dragBar:SetRotatorOffset(3, 23);
                end
                
                if (self.settings.preconf[self.barlist[args.selection]] ~= nil) then
                        self.currentedit = self.settings.preconf[self.barlist[args.selection]];
                        self.currentkey = self.barlist[args.selection];
                        self.nameText:SetText(self.currentedit.name);
                        self.enabled:SetChecked(self.currentedit.active);
                        self.nameText:SetVisible(true);
                        self.nameText:SetEnabled(false);
                        self.nameText:SetWantsUpdates(false);
                        self.enabled:SetVisible(true);
                        self.enabled:SetWantsUpdates(true);
                        self.visibility:SetVisible(true);
                        self.visibility:SetSelection(self.windows[self.currentkey]:GetCombat());
                        self.widthslider:SetVisible(false);
                        self.widthslider:SetWantsUpdates(false);
                        self.heightslider:SetVisible(false);
                        self.heightslider:SetWantsUpdates(false);
                        self.del:SetVisible(false);
                        self.windows[self.currentkey]:SetBackColor(Turbine.UI.Color( 0, 0, 1 ));
                        self.windows[self.currentkey].dragBar:SetRotator(false);
                        self:EditBar(self.currentkey);
                elseif (self.settings.userconf[self.barlist[args.selection]] ~= nil) then
                        self.currentedit = self.settings.userconf[self.barlist[args.selection]];
                        self.currentkey = self.barlist[args.selection];
                        self.nameText:SetText(self.currentedit.name);
                        self.enabled:SetChecked(self.currentedit.active);
                        self.widthslider:SetValue(self.windows[self.currentkey].width);
                        self.heightslider:SetValue(self.windows[self.currentkey].height);
                        self.nameText:SetVisible(true);
                        self.nameText:SetWantsUpdates(true);
                        self.nameText:SetEnabled(true);
                        self.enabled:SetVisible(true);
                        self.enabled:SetWantsUpdates(true);
                        self.visibility:SetVisible(true);
                        self.visibility:SetSelection(self.windows[self.currentkey]:GetCombat());
                        self.widthslider:SetVisible(true);
                        self.widthslider:SetWantsUpdates(true);
                        self.heightslider:SetVisible(true);
                        self.heightslider:SetWantsUpdates(true);
                        self.del:SetVisible(true);
                        self.windows[self.currentkey]:SetBackColor(Turbine.UI.Color( 0, 0, 1 ));
                        self.windows[self.currentkey].dragBar:SetRotator(false);
                        self:EditBar(self.currentkey);
                else
                        self.nameText:SetVisible(false);
                        self.nameText:SetWantsUpdates(false);
                        self.enabled:SetVisible(false);
                        self.enabled:SetWantsUpdates(false);
                        self.visibility:SetVisible(false);
                        self.widthslider:SetVisible(false);
                        self.widthslider:SetWantsUpdates(false);
                        self.heightslider:SetVisible(false);
                        self.heightslider:SetWantsUpdates(false);
                        self.del:SetVisible(false);
                        
                        self:EditBar(nil);
                        
                        self.currentedit = nil;
                        self.currentkey = nil;
                end
        end
        
        self.new = Turbine.UI.Lotro.Button();
    self.new:SetParent(self.tempwindow);
    self.new:SetPosition(10, 40);
    self.new:SetSize(100, 20);
    self.new:SetText("New");
        self.new:SetVisible(true);
    self.new.Click = function(sender, args)
        local newbar = self:CreateBar();
                self.pulldown:AddItem(self.settings.userconf[self.barlist[newbar]].name, newbar);
                self.pulldown:SetSelection(newbar);
    end
        
        self.del = Turbine.UI.Lotro.Button();
    self.del:SetParent(self.tempwindow);
    self.del:SetPosition(120, 40);
    self.del:SetSize(100, 20);
    self.del:SetText("Remove");
        self.del:SetVisible(false);
    self.del.Click = function(sender, args)
        self:DeleteBar(self.currentkey);
                self.pulldown:SetSelection(0); 
                self.pulldown.listBox:ClearItems();
                self.pulldown:AddItem(" ", 0);
                for k,v in pairs(self.barlist) do
                        if (self.settings.userconf[v] ~= nil) then
                                self.pulldown:AddItem(self.settings.userconf[v].name, k);
                        end
                end
    end 
        
        self.nameText = Turbine.UI.Lotro.TextBox();
    self.nameText:SetParent(self.tempwindow);
    self.nameText:SetSize(280, 20);
    self.nameText:SetPosition(10, 100);
    self.nameText:SetFont(Turbine.UI.Lotro.Font.Verdana14);
    self.nameText:SetMultiline(false);
        self.nameText:SetVisible(false);
        self.nameText:SetWantsUpdates(false);
        self.nameText:SetWantsKeyEvents(false);
        self.nameText.KeyDown = function(sender, args)
                if (args.Action == 162) then
                        self.nameText:SetReadOnly(true);
                        self.nameText.blocker:SetZOrder(0);
                        self.nameText:SetWantsKeyEvents(false);
                end
        end
        self.nameText.Update = function(sender, args)
                self:RenameBar(self.currentkey, self.nameText:GetText());
                self.pulldown:UpdateSelectionText(self.nameText:GetText());
        end
        
        self.nameText.blocker = Turbine.UI.Window();
        self.nameText.blocker:SetParent(self.tempwindow);
        self.nameText.blocker:SetSize(280, 20);
    self.nameText.blocker:SetPosition(10, 100);
        self.nameText.blocker:SetVisible(true);
        self.nameText.blocker:SetOpacity(0);
        self.nameText.blocker:SetMouseVisible(true);
        self.nameText.blocker.MouseDown = function(sender, args)
                self.nameText.blocker:SetZOrder(-1);
                self.nameText:SetWantsKeyEvents(true);
                self.nameText:SetReadOnly(false);
        end
        
        self.enabled = KragenPlugs.UI.CheckBox();
    self.enabled:SetParent(self.tempwindow);
    self.enabled:SetText("Enabled");
    self.enabled:SetSize(180,20);
    self.enabled:SetPosition(10,130);
    self.enabled:AlignLeft(true);
        self.enabled:SetVisible(false);
        self.enabled:SetWantsUpdates(false);
        self.enabled.Update = function(sender, args)
                self.currentedit.active = self.enabled:IsChecked();
                self.windows[self.currentkey]:Refresh(self.enabled:IsChecked());
        end
        
        self.visibility = KragenPlugs.UI.ComboBox();
    self.visibility:SetParent(self.tempwindow);
    self.visibility:SetSize(190, 20);
    self.visibility:SetPosition(10, 160);
    self.visibility:SetVisible(false);
        self.visibility:AddItem("Always", 1);
        self.visibility:AddItem("Only In Combat", 2);
        self.visibility:AddItem("Only Out of Combat", 3);
        self.visibility.SelectedIndexChanged = function(sender, args)
                self:BarCombat(self.currentkey, args.selection);
        end
        
        self.widthslider = KragenPlugs.UI.Slider();
    self.widthslider:SetParent(self.tempwindow);
    self.widthslider:SetText("Width");
    self.widthslider:SetPosition(10, 190);
    self.widthslider:SetSize(200, 40);
    self.widthslider:SetStep(1);
    self.widthslider:SetMin(1);
    self.widthslider:SetMax(12);
        self.widthslider:SetVisible(false);
        self.widthslider:SetWantsUpdates(false);
        self.widthslider.Update = function(sender, args)
                self.currentedit.size = { self.widthslider:GetValue(), self.heightslider:GetValue() };
                self:ResizeBar(self.currentkey, self.currentedit.size);
        end
        
        self.heightslider = KragenPlugs.UI.Slider();
    self.heightslider:SetParent(self.tempwindow);
    self.heightslider:SetText("Height");
    self.heightslider:SetPosition(10, 240);
    self.heightslider:SetSize(200, 40);
    self.heightslider:SetStep(1);
    self.heightslider:SetMin(1);
    self.heightslider:SetMax(12);
        self.heightslider:SetVisible(false);
        self.heightslider:SetWantsUpdates(false);
        self.heightslider.Update = function(sender, args)
                self.currentedit.size = { self.widthslider:GetValue(), self.heightslider:GetValue() };
                self:ResizeBar(self.currentkey, self.currentedit.size);
        end
        
        
end

function ClassBar:ShowSetup()
        self.setup:SetVisible(true);

        self.setupbb.opacityslider:SetValue(settings.opacity * 100);
        self.setupbb.checkboxlock:SetChecked(settings.lockslots);
        self.setupbb.checkboxgrid:SetChecked(settings.snaptogrid);
        self.setupbb.combolangbox:SetSelection(settings.language);
        
        for k,v in pairs(self.settings.preconf) do              self.setupbb.buttonbars[v.id]:SetActive(v.name, v.active) end
        for k,v in pairs(self.settings.userconf) do     self.setupbb.buttonbars[v.id]:SetActive(v.name, v.active) end
        for k,v in pairs(self.settings.traits) do               self.setupf.traits[v.id]:SetActive(v.name, v.active) end
        for k,v in pairs(self.settings.features) do     self.setupf.features[v.id]:SetActive(v.name, v.active) end
        for k,v in pairs(self.settings.defaults) do
                self.setupf.defaults[v.id].combobox.listBox:ClearItems();
                self.setupf.defaults[v.id].label:SetText(v.name);
                self.setupf.defaults[v.id].label:SetVisible(true);
                for key,value in pairs(v.list) do
                        self.setupf.defaults[v.id].combobox:AddItem(value, key);
                end
                self.setupf.defaults[v.id].combobox:SetVisible(true);
                self.setupf.defaults[v.id].combobox:SetSelection(v.selected);
        end
        for k,v in pairs(self.settings.quickslots) do   self.setupqs:ActivateQuickslot(self.setupqs.quickslots[v.id], v.name, v.active, v.type, v.data) end
end

function ClassBar:SetupClosing()
        settings.opacity = self.setupbb.opacityslider:GetValue() / 100;
        settings.lockslots = self.setupbb.checkboxlock:IsChecked();
        settings.snaptogrid = self.setupbb.checkboxgrid:IsChecked();
        settings.language = self.setupbb.combolangbox:GetSelection();
        
        for k, v in pairs (self.settings.preconf) do    v.active = self.setupbb.buttonbars[v.id]:IsChecked() end
        for k, v in pairs (self.settings.userconf) do   v.active = self.setupbb.buttonbars[v.id]:IsChecked() end
        for k, v in pairs (self.settings.traits) do     v.active = self.setupf.traits[v.id]:IsChecked() end
        for k, v in pairs (self.settings.features) do   v.active = self.setupf.features[v.id]:IsChecked() end
        for k, v in pairs (self.settings.defaults) do   v.selected = self.setupf.defaults[v.id].combobox:GetSelection() end
        for k, v in pairs (self.settings.quickslots) do
                if (self.setupqs.quickslots[v.id].quickslot:GetShortcut():GetData() ~= "" ) then
                        v.active = self.setupqs.quickslots[v.id].checkbox:IsChecked();
                        v.type = self.setupqs.quickslots[v.id].quickslot:GetShortcut():GetType();
                        v.data = self.setupqs.quickslots[v.id].quickslot:GetShortcut():GetData();
                else
                        v.active = false;
                        v.type = Turbine.UI.Lotro.ShortcutType.Undefined;
                        v.data = "";
                end
        end
        
        self:SaveSettings();
        self:Refresh();
end

-- Swap Slots
function ClassBar:SwapSlots(ref, code, item)
        
        local swap = nil;
        local swaptype = 1;
        if (not settings.lockslots) then
                for k,v in pairs(self.skills) do
                        if (not item) then
                                if ((type(v.hex) == 'table' and (v.hex[1] == code or v.hex[2] == code)) or v.hex == code) then
                                        swap = v;
                                        swaptype = 1;
                                end
                        else
                                if (v.item ~= nil and v.item:GetName() == code) then
                                        swap = v;
                                        swaptype = 1;
                                end
                        end
                end
                for k,v in pairs(self.multi) do
                        if (not item) then
                                if (v.quickslot:GetShortcut():GetData() == code ) then
                                        swap = v;
                                        swaptype = 2;
                                end
                        else
                                if (v.item ~= nil and v.item:GetName() == code ) then
                                        swap = v;
                                        swaptype = 2;
                                end
                        end
                end
        end
        if (swap ~= nil) then
                if (swap:GetParent() == limbo)  then
                        if (not ref:GetParent().exclusive and ref:GetParent() == ref.parent) then
                                        swap:SwapPosition(ref);
                        end
                else
                        if( (ref:GetParent() == swap:GetParent() or ( not ref:GetParent().exclusive and not swap:GetParent().exclusive)) and (ref:GetParent() == ref.parent and swap:GetParent() == swap.parent)) then
                                if (swaptype == 1) then
                                        ref:SwapPosition(swap);
                                else
                                        swap:SwapPosition(ref);
                                end
                        end
                end
        end
        if (swap.parent.index == self.currentkey) then
                swap:SetOpacity(1);
                swap:ResetQuickslot();
        end
        ref:ResetQuickslot();
end

-- Rotate Window
function ClassBar:RotateWindow(ref)
        local rotatebar = { };
        local counter=1
        for k,v in pairs(self.bars) do
                if(v:GetParent() == ref) then
                        v:RotateBar();
                        rotatebar[counter] = v;
                        counter = counter + 1;
                end
        end
        
        for k,v in pairs(self.skills) do
                for i=1, counter do
                        if(v:GetParent() == rotatebar[i]) then
                                v:RotateBar();
                        end
                end
        end
        
        for k,v in pairs(self.multi) do
                for i=1, counter do
                        if(v:GetParent() == rotatebar[i]) then
                                v:RotateBar();
                        end
                end
        end
end

-- Save Settings
function ClassBar:SaveSettings()

        if (self.settings.preconf ~= nil) then
                for k,v in pairs(self.settings.preconf) do
                        v.pos = { };
                        v.pos[1], v.pos[2] = self.windows[k]:GetPosition();
                        v.size = { self.windows[k].width, self.windows[k].height };
                        v.combat = { self.windows[k].incombat, self.windows[k].outcombat };
                        v.rotate = self.windows[k].rotate;
                end
                
                for k,v in pairs(self.settings.userconf) do
                        v.name = self.windows[k].heading;
                        v.pos = { };
                        v.pos[1], v.pos[2] = self.windows[k]:GetPosition();
                        v.size = { self.windows[k].width, self.windows[k].height };
                        v.combat = { self.windows[k].incombat, self.windows[k].outcombat };
                end
        else
                for k,v in pairs(self.windows) do
                        self.settings[k].x, self.settings[k].y = self.windows[k]:GetPosition();
                        self.settings[k].rotate = self.windows[k].rotate;
                end
        end
    
    local skilldata = { };
    for k,v in pairs(self.skills) do
                if (v.GetParent() == limbo) then
                        skilldata[k] = { pos = {v.x, v.y}, parent = nil };
                else
                        skilldata[k] = { pos = {v.x, v.y}, parent = v.parent.index };
                end
        end
        
        local multidata = { };
        for k,v in pairs(self.multi) do
                if (v.GetParent() == limbo) then
                        multidata[k] = { current = v.currentshortcut, layer = v.currentlayer, lock = v.lock, pos = { v.x, v.y }, parent = nil };
                else
                        multidata[k] = { current = v.currentshortcut, layer = v.currentlayer, lock = v.lock, pos = { v.x, v.y }, parent = v.parent.index };
                end
                
        end
        
        for k,v in pairs(self.windows) do
                v:SetVisible(v.active);
        end

        --Turbine.Shell.WriteLine("KragenBars: " .. settings.class .. " Bars settings saved successfully.");

        settings.multidata = multidata;
        settings.skilldata = skilldata;
        settings.classinfo = self.settings;
        SaveSettings();
end

-- Refresh Player Level and Window and Skill States
function ClassBar:RefreshBars()
        -- Refresh Player Level
        vars.playerlevel = vars.player:GetLevel();
        
        if (self.settings.preconf ~= nil) then
                -- Refresh Windows
                for k,v in pairs(self.settings.preconf) do
                        self.windows[k]:Refresh(v.active);
                end
                
                for k,v in pairs(self.settings.userconf) do
                        self.windows[k]:Refresh(v.active);
                end
        else
                -- Refresh Windows
                for k,v in pairs(self.windows) do
                        self.windows[k]:Refresh(self.settings[k].active);
                end
        end
        
        -- Refresh Skills
        for k,v in pairs(self.skills) do
                self.skills[k]:Refresh();
        end
end

function ClassBar:DefaultPosition()
    -- Refresh Windows
        for k,v in pairs(self.windows) do
        self.windows[k]:DefaultPosition();
        end
end

function ClassBar:RecalculateBorders()
        -- Refresh Skills
        for k,v in pairs(self.skills) do
                v.border:SetPosition(v:PointToScreen(1, 1));
        end
end

function ClassBar:CombatChange(combat)
        for k,v in pairs(self.skills) do
                self.skills[k]:RefreshCombat();
        end
        
        for k,v in pairs(self.multi) do
                self.multi[k]:RefreshCombat();
        end
        
        for k,v in pairs(self.bars) do
                self.bars[k]:RefreshCombat();
        end
end

function ClassBar:EditBar(key)
        for k,v in pairs(self.skills) do
                if (v.parent ~= nil and v.parent.parent == self.windows[key]) then
                        v:SetOpacity(1);
                        v:ResetQuickslot();
                else
                        v:RefreshCombat();
                end
        end
end

function ClassBar:CreateBar()
        local name = "UserBar"..tostring(settings.userbars + 1);
        local v = nil;
        
        settings.userbars = settings.userbars + 1;
        self.barcount = self.barcount + 1;
        
        v = { id = self.barcount, name = name, defpos = {0,0}, size = {1, 1} , pos = {800, 200+(35*settings.userbars)}, combat = {true,true}, active = true };
        self.windows[name] = SkillWindow(v);
        self.bars[name] = SkillBar(self.windows[name], 1, 1, 1, 1, true, false);
        
        self.settings.userconf[name] = v;
        self.barlist[v.id] = name;
        
        return v.id;
end

function ClassBar:ResizeBar(key, size)
        self.bars[key]:ChangeSize(size[1], size[2]);
end

function ClassBar:RenameBar(key, name)
        if (self.windows[key] ~= nil) then
                self.windows[key]:SetName(name);
                self.settings.userconf[key].name = name;
        end
end

function ClassBar:BarCombat(key, num)
        self.windows[key]:SetCombat(num ~= 3, num ~= 2);
        self:CombatChange();
end

function ClassBar:DeleteBar(key)
        local id = nil
        
        self.barcount = 0;
        
        if (self.windows[key] ~= nil and self.settings.userconf[key] ~= nil) then
                id = self.settings.userconf[key].id;
                self.bars[key]:ChangeSize(0,0);
                self.bars[key]:SetVisible(false);
                self.windows[key]:Trash();
                self.windows[key] = nil;
                self.bars[key] = nil;
                self.settings.userconf[key] = nil;
                
                self.barlist = { };
                
                for k,v in pairs (self.settings.preconf) do
                        self.barlist[v.id] = k;
                        self.barcount = self.barcount + 1;
                end
                
                for k,v in pairs (self.settings.userconf) do
                        if (v.id > id) then
                                v.id = v.id - 1;
                        end
                        self.barlist[v.id] = k;
                        self.barcount = self.barcount + 1;
                end
                
                self.setupbb["checkboxbb"..tostring(self.barcount+1)]:SetVisible(false);
        end
end