LoTROInterface SVN KragenBars

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

ItemSlot = class ( KragenPlugs.Utils.Extensions.SimpleWindow );

function ItemSlot:Constructor ( parent, x, y, active, multi )
        KragenPlugs.Utils.Extensions.SimpleWindow.Constructor( self );
        
        self.parent = parent;
        self.x = x;
        self.y = y;
        self.active     = active;
        self.hover              = false;
        self.incombat   = true;
        self.outcombat  = true;
        self.multi              = multi;
        self.item = nil;
        self.key = nil;
        self.manager = nil;
        self.index = 0;
        
        self.blocker = KragenPlugs.Utils.Extensions.SimpleWindow();
        self.blocker:SetParent(self);
        self.blocker:SetSize(35,35);
        self.blocker:SetPosition(0,0);
        self.blocker:SetVisible(true);
        self.blocker:SetOpacity(0);
        self.blocker:SetWantsUpdates(self.multi);
        self.bslot = Turbine.UI.Lotro.Quickslot();
        self.bslot:SetParent(self.blocker);
        self.blocker.Update = function(sender, args)
                if (self:IsAltKeyDown()) then
                        self.blocker:SetVisible(true);
                        self.blocker:SetZOrder(10);
                else
                        self.blocker:SetVisible(false);
                        self.blocker:SetZOrder(-10);
                end
        end
        
        -- QUICKSLOT
        self.quickslot = Turbine.UI.Lotro.ItemControl();
        self.quickslot:SetParent(self);
        self.quickslot:SetSize(35,35);
        self.quickslot:SetVisible(true);
        self.quickslot:SetAllowDrop(true);
        
        -- TIMER
        self.timer = Timer();
        self.timerOn = true;
        self.timerEnd = true;

        -- TIMER EVENT
        self.timer.TimerElapsed = function ()
        if (self.timerEnd) then
                        self:SetOpacity( settings.opacity * .5 );
                        self:SetActive( true );
                else
                    self:SetActive( false );
                end
        end
        
        -- set properties
        self:SetParent( parent );
        self:SetPosition( (x - 1) * 35, (y - 1) * 35 );
        self:SetSize(35,35);
        self:SetVisible(true);
        self:SetFadeSpeed(.3);
        self:SetActive(self.active);
        
        -- COLOR BAND
        self.border = Turbine.UI.Window();
        self.bordervisible = true;
        self.border:SetSize(36, 36);
        self.border:SetPosition(self:PointToScreen(1, 1));
        self.border:SetZOrder(-10);
        self.border:SetVisible(false);
        
        -- EVENTS
        -- hover mouse enter event
        self.quickslot.MouseEnter = function(sender,args)
        if (self.hover and self.active) then
                        self:SetOpacity(settings.opacity);
                end
        end

        -- hover mouse leave event
        self.quickslot.MouseLeave = function(sender,args)
            if (self.hover and self.active) then
                        self:SetOpacity(settings.opacity * .5);
                end
        end
        
        -- scrolling event
        self.bslot.MouseWheel = function(sender,args)
                if(self.multi) then
                        local newkey = self.key + (args.Direction * -1);
                        self:SetItem(self.manager:GetItem(self.index, newkey, args.Direction * -1));
                        self.blocker:SetVisible(false);
                        self.blocker:SetZOrder(-10);
                end
        end
        
        self.quickslot.DragDrop = function(sender,args)
                if (args.DragDropInfo:GetShortcut():GetItem() == nil) then
                        KragenBars:SwapSlots(self, args.DragDropInfo:GetShortcut():GetData());
                else
                        KragenBars:SwapSlots(self, args.DragDropInfo:GetShortcut():GetItem():GetName(), true);
                end
        end
        
        
        
end

function ItemSlot:RegisterManager(manager, index)
        self.manager = manager;
        self.index = index;
end

-- SET ACTIVE (To be used in place of SetVisible)
function ItemSlot:SetActive( active )
        self.active = active;
        if ( self.active and self.item ~= nil and ( ( vars.player:IsInCombat() and self.incombat ) or ( not vars.player:IsInCombat() and self.outcombat ) ) ) then
                if (self.hover) then
                    self:SetOpacity(settings.opacity * .5)
                else
                    self:SetOpacity(settings.opacity)
                end
                self.quickslot:SetItem( self.item );
        else
        self:SetOpacity(0);
        self.quickslot:SetItem( nil );
        end
end

function ItemSlot:SetItem(item)
        if (item ~= nil) then
                self.item = item[1];
                self.key = item[2];
                self.quickslot:SetItem(item[1]);
                self:SetActive(self.active);
        else
                self.item = nil;
                self.key = nil;
                self.quickslot:SetItem(nil);
        end
end

function ItemSlot:ResetQuickslot()
end

-- SET HOVER (Set the hover state)
function ItemSlot:SetHover(bol)
        self.hover = bol;
        
        if (self.active) then
                if (bol) then
                        self:SetOpacity(settings.opacity * .5);
                else
                        self:SetOpacity(settings.opacity);
                end
        end
end

-- SET COMBAT (Sets the combat visibility variables)
function ItemSlot:SetCombat( incombat, outcombat )
        self.incombat   = incombat;
        self.outcombat  = outcombat;
end

-- REFRESH COMBAT (Refresh Visibility for combat changes)
function ItemSlot:RefreshCombat()
        self:SetActive( self.active );
end

-- LOAD POSITION, RECALL SAVED POSITION AND PARENT
function ItemSlot:LoadPosition(data)
        self.x = data.pos[1];
        self.y = data.pos[2];
        self:SetPosition( (self.x - 1) * 35, (self.y - 1) * 35 );
        self.border:SetPosition(self:PointToScreen(1, 1));

        if (data.parent == nil) then 
                self:SetParent(limbo);
        else
                self:SetParent(data.parent); 
        end
        
        self.parent = data.parent;
end

-- SWAP POSITION WITH ANOTHER ItemSlot (REF)
function ItemSlot:SwapPosition(ref)
        local newx = ref.x;
        local newy = ref.y;
        local newparent = ref.parent;
        
    self:SetPosition( (newx - 1) * 35, (newy - 1) * 35 );
        self.border:SetPosition(self:PointToScreen(1, 1));
        self:SetParent(newparent);
        self:SetParent(newparent);
        
        if (not ref.blank) then
                if (self.parent ~= nil) then
                        ref:SetPosition( (self.x - 1) * 35, (self.y - 1) * 35 );
                        ref.border:SetPosition(ref:PointToScreen(1, 1));                
                        ref:SetParent(self.parent);
                else
                        ref:SetParent(limbo);
                end

                ref.x = self.x;
                ref.y = self.y;
                ref.parent = self.parent;
                ref:SetActive(ref.active);
        end
        
        self.x = newx;
        self.y = newy;
        self.parent = newparent;
        self:SetActive(self.active);

end

-- UPDATE THE WINDOW STATE
function ItemSlot:Refresh()
        self:SetActive( self.active );
end

-- START TIMER (Starts the timer, bol is true for Early Warnings and false for Skill Hacks)
function ItemSlot:StartTimer(duration, bol)
        self.timer:Stop();
        self.timer:SetInterval(duration);
        self.timer:Start();
        self.timerEnd = bol;
end

-- ROTATE BAR: SWAP THE SLOTS X AND Y POSITION
function ItemSlot:RotateBar()
        local newx = self.y;
        local newy = self.x;
        
        self:SetPosition( (newx - 1) * 35, (newy - 1) * 35 );

        self.x = newx;
        self.y = newy;
end

function ItemSlot:SetColor(color)
        if (color == "purple") then
        self.border:SetBackColor(Turbine.UI.Color(.8, .0, 1));
        self.border:SetVisible(self.active and self.bordervisible);

    elseif (color == "red") then
        self.border:SetBackColor(Turbine.UI.Color(1, .0, 0));
        self.border:SetVisible(self.active and self.bordervisible);

        elseif (color == nil) then
                self.border:SetVisible(false);
        end
end

function ItemSlot:RefreshBorders()
        if (self.parent == nil or not self.parent.parent:IsVisible()) then
                self.bordervisible = false;
                self.border:SetVisible(false);
        else
                self.border:SetVisible(true);
        end
end