LoTROInterface SVN SortPack

--[[Idea;

        Streamline the sort by using the new sorting function attached to listboxes.

        1) Tag each backpack slot with the items weight when added (set to zero when removed)

        2) When an item is added/moved to the pack, or the pack is opened, sort the group that contains it.

        This is a huge change, as it would no longer be nessecary (or desireable) to clear the bag when it is opened.

        Indeed, this method could be so secure that it may be worth just resorting each group when the bag is opened/closed or changed (but only if visible!)

        ]]

--Needs a tidy!

--Check the bag datais valid.

if SB==nil then SB={} end

if SB.x==nil then                               SB.x=100                                                end     --}

if      SB.y==nil then                          SB.y=100                                                end     --}Position

if      SB.icx==nil then                        SB.icx=4                                                end     --]

if      SB.icy==nil then                        SB.icy=3                                                end     --]Size, in icons

if      SB.override==nil then   SB.override=false                       end     --Override default bags?

if      SB.labelwidth==nil then         SB.labelwidth=80                        end     --Width of the text label for the group.

if      SB.font==nil then                       SB.font="TrajanPro14"   end     --Label font

if      SB.ShowItem==nil then   SB.ShowItem=true                        end     --un-hide a group when an item is looted in it?

--font size

SB.fontsize=string.sub(SB.font,-2)

if SB.fontsize=="ed" then SB.fontsize=13-1 else SB.fontsize=tonumber(SB.fontsize)-1 end

--Frame padding

pad={top=30,side=15,bottom=10}

--Calculate width and maximum height for the bag.

SB.width=SB.labelwidth+36*SB.icx+2*pad.side

SB.maxheight=Turbine.UI.Display.GetHeight()

--Functions

        --Set the sizes of all the areas of the bag.

        function SortBagSetSize()

                SortBag.ListBox:SetSize( SB.labelwidth+SB.icx*36, SortBag:GetHeight()-(pad.top+pad.bottom)+1)

                SortBag.ScrollBar:SetPosition(SB.labelwidth+SB.icx*36+10,pad.top+5)

                SortBag.ScrollBar:SetHeight(SortBag:GetHeight()-(pad.top+pad.bottom)-10)

                SortBag.Resize:SetPosition(SB.width-10,pad.top+10)

                SortBag.Resize:SetSize(10,SortBag:GetHeight()-2*pad.top-10)

                SortBag.ResizeBack:SetSize(10,SortBag:GetHeight()-pad.top-pad.bottom)

                Search.label:SetSize(SB.labelwidth,SB.fontsize)

        end

        --Adjust the sizes of the GroupBoxes.

        function SetGroupBoxSize()

                if GroupBox==nil then return end

                local height=0

                for j=0,#Groups do

                        --Adjust GroupBox Widths

                        GroupBox[j]:SetMaxItemsPerLine(SB.icx)

                        GroupBox[j]:SetWidth(SB.icx*36)

                        --Hide the slot, or adjust its height

                        if Groups[j].hide then

                                GroupBox[j]:SetHeight(0)

                                GroupBox[j].label:SetBackColor(Turbine.UI.Color( 1,0.4,0,0 ))

                        else

                                GroupBox[j]:SetHeight( math.ceil(GroupBox[j]:GetItemCount()/SB.icx)*36)

                                GroupBox[j].label:SetBackColor(Turbine.UI.Color( 1,0,0,0.4 ))

                        end

                        --Adjust Label Width,Height

                        GroupBox[j].label:SetWidth(SB.labelwidth)

                        if GroupBox[j]:GetItemCount()>0 then

                                GroupBox[j].label:SetHeight(SB.fontsize)

                        else

                                GroupBox[j].label:SetHeight(0)

                        end

                        --Add to the height variable

                        height=height+math.max(GroupBox[j]:GetHeight(),GroupBox[j].label:GetHeight())

                end

                if height>SB.maxheight-(pad.top+pad.bottom) then height=SB.maxheight-(pad.top+pad.bottom) end

                --Resize the window to fit the new height NOTE: The SB.fontsize is to accomodate the "search" box

                        SortBag:SetHeight(height+pad.top+pad.bottom+SB.fontsize)

                        --Change the title to show how many empty slots are left

                        SortBag:SetText(GroupBox[0]:GetItemCount().." empty slots left")

        end

--Search function now added to the bag!

        Search={}

        Search.label=Turbine.UI.Label()

                Search.label:SetBackColor( Turbine.UI.Color( 1,0.1,0.1,0.1 ) )

                Search.label:SetMultiline(true)

                Search.label:SetTextAlignment( Turbine.UI.ContentAlignment.MiddleCenter )

                Search.label:SetMouseVisible (true)

                Search.label:SetSize(SB.labelwidth,SB.fontsize)

                Search.label.MouseDown=function()

                        Search.Textbox:SetText("")

                        SearchBag("")

                end

        Search.Textbox=Turbine.UI.TextBox()

                Search.Textbox:SetSize(200,SB.fontsize)

        --Scan the text entered.

        Search.Textbox.TextChanged=function()

                SearchBag(Search.Textbox:GetText())

        end

        function SearchBag(SearchString)

                local txt1=string.lower(SearchString)

                for i=1,size do

                        local item = backpack:GetItem(i)

                        if item~=nil then

                                local itemInfo=item:GetItemInfo();

                                local txt2=string.lower(itemInfo:GetName())

                                if string.find(txt2,txt1) then

                                        BackpackSlots[i]:SetVisible(true)

                                else

                                        BackpackSlots[i]:SetVisible(false)

                                end

                        end

                end

        end

        --populate the bag.

        function populatebag()

                SortBag.ListBox:ClearItems()

                --Add the search section. Fonts applied here too.

                SortBag.ListBox:AddItem(Search.label)

                SortBag.ListBox:AddItem(Search.Textbox)

                Search.Textbox:SetFont(Turbine.UI.Lotro.Font[SB.font])

                Search.label:SetFont(Turbine.UI.Lotro.Font[SB.font])

                Search.label:SetText( "Search" )

                GroupBox={}

                BackpackSlots=nil

                BackpackSlots={}

                --Check for font size errors

                if SB.labelwidth<SB.fontsize then SB.labelwidth=SB.fontsize end

                --Build VirtPack

                VirtPack=analysepack()

                ---Build a box for this group of items. Box 0 is for empty slots.

                for i=0,#Groups do

                        GroupBox[i] = Turbine.UI.ListBox()

                        GroupBox[i]:SetOrientation( Turbine.UI.Orientation.Horizontal )

                        GroupBox[i]:SetAllowDrop( true )

                        GroupBox[i].DragDrop = function( sender, args )

                                --Empty slots allow drag-drop. Hopefully!

                                local shortcut = args.DragDropInfo:GetShortcut();

                                if ( shortcut ~= nil ) then

                                        local item = GroupBox[i]:GetItemAt( args.X, args.Y );

                                        local index

                                        if item==nil then index=1 else index= item.id end

                                        backpack:PerformShortcutDrop( shortcut, index, Turbine.UI.Control.IsShiftKeyDown() )

                                end

                        end

                end

                --Build the backpack Slots.

                for i=1,size do

                        item = backpack:GetItem(i)

                        if item~=nil then AddCallback(item, "QuantityChanged",  BagQuantityChanged) end

                        BackpackSlots[i]=Turbine.UI.Lotro.ItemControl( item )

                        BackpackSlots[i].id=i --so it can be passed for item swopping.

                        BackpackSlots[i]:SetBackground( "JackdawPlugins/SortPack/Back.tga" )

                        BackpackSlots[i]:SetBlendMode( Turbine.UI.BlendMode.Overlay )

                end

                --Move the items into the boxes

                for i=1,#VirtPack do

                        --if i<10 then Turbine.Shell.WriteLine(VirtPack[i].id) end --Re-enable if the "not sorting correctly" bug rears its head again.

                        BackpackSlots[VirtPack[i].id].Group=VirtPack[i].Group

                        GroupBox[VirtPack[i].Group]:AddItem(BackpackSlots[VirtPack[i].id])

                end

                --Add the groups to the backpack

                for j=0,#Groups do

                        --Build a label

                        GroupBox[j].label=Turbine.UI.Label()

                                GroupBox[j].label:SetBackColor( Turbine.UI.Color( 1,0,0,0.4 ) )

                                GroupBox[j].label:SetFont(Turbine.UI.Lotro.Font[SB.font])

                                GroupBox[j].label:SetMultiline(true)

                                GroupBox[j].label:SetTextAlignment( Turbine.UI.ContentAlignment.MiddleCenter )

                                GroupBox[j].label:SetText( Groups[j].Name )

                                GroupBox[j].label:SetMouseVisible (true)

                                GroupBox[j].label:SetSize(SB.labelwidth,0)--Initially of height 0

                                GroupBox[j].label.label=true

                        if j~=0 then

                                --Add the label and GroupBox, but not for empty slots

                                SortBag.ListBox:AddItem(GroupBox[j].label)

                                SortBag.ListBox:AddItem(GroupBox[j])

                        end

                        --Click events for the labels.

                        GroupBox[j].label.MouseClick=function(sender,args)

                                if ( args.Button == Turbine.UI.MouseButton.Left ) then

                                        --Left Clicking the label collapses this group

                                        Groups[j].hide=not(Groups[j].hide)

                                else

                                        --Right clicking either collapses all groups, if this one is shown, or opens all groups if not.

                                                Groups[j].hide=not(Groups[j].hide)

                                        for i=0,#Groups do

                                                Groups[i].hide=Groups[j].hide

                                        end

                                end

                                SetGroupBoxSize()

                        end

                end

                        --Empty Slots group added last.

                        SortBag.ListBox:AddItem(GroupBox[0].label)

                        SortBag.ListBox:AddItem(GroupBox[0])

                --Function refresh the heights of the group boxes

                SetGroupBoxSize()

        end

        --Show the backpack

        function openbag()

                --Clear out any previous search

                Search.Textbox:SetText("")

                SearchBag("")

                --Show the bag!

                SortBag:SetVisible(true)

        end

        --Events here replace the default bags with this one.

        function SBOverride()

                if SB.override then SortBag:SetWantsKeyEvents( true );

                        SortBag.KeyDown = function( sender, args )

                                if ( args.Action == Turbine.UI.Lotro.Action.Escape ) then

                                        SortBag:Close()

                                end

                                if ( args.Action == Turbine.UI.Lotro.Action.ToggleBags or

                                         args.Action == Turbine.UI.Lotro.Action.ToggleBag1 or

                                         args.Action == Turbine.UI.Lotro.Action.ToggleBag2 or

                                         args.Action == Turbine.UI.Lotro.Action.ToggleBag3 or

                                         args.Action == Turbine.UI.Lotro.Action.ToggleBag4 or

                                         args.Action == Turbine.UI.Lotro.Action.ToggleBag5 or

                                         args.Action == Turbine.UI.Lotro.Action.ToggleBag6)

                                then

                                        if SortBag:IsVisible() then

                                                SortBag:Close()

                                        else

                                                openbag()

                                        end

                                end

                        end

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack1, false )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack2, false )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack3, false )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack4, false )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack5, false )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack6, false )

                else

                        SortBag:SetWantsKeyEvents( false )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack1, true )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack2, true )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack3, true )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack4, true )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack5, true )

                        Turbine.UI.Lotro.LotroUI.SetEnabled( Turbine.UI.Lotro.LotroUIElement.Backpack6, true )

                end

        end

        --Next three items update the bag if items are added or removed.

                BagAdd=function( sender, args )

                        --args.Index    = Bag slot

                        --args.Item             = Item object

                        --Remove the slot from the group it is in.

                        for i=0,#Groups do

                                if GroupBox[i]:ContainsItem(BackpackSlots[args.Index]) then GroupBox[i]:RemoveItem(BackpackSlots[args.Index]) end

                        end

                        --Determine which group it belongs to

                        local destination=ItemGroup[ItemCategory[GetCat(args.Item)]]

                        if destination==nil then destination=0 end

                        --Insert the item in that group

                        BackpackSlots[args.Index]:SetItem(args.Item)

                        BackpackSlots[args.Index].Group=destination

                        GroupBox[destination]:InsertItem(position,BackpackSlots[args.Index])

                        if destination~=0 then

                                --Remove every item from that groupbox one at a time and resort them.

                                local temp={}

                                --cycle through the elements checking for weights

                                for i=GroupBox[destination]:GetItemCount(),1,-1 do

                                        temp[i]=GroupBox[destination]:GetItem(i)

                                        temp[i].Weight=weight(temp[i].id)

                                        temp[i].Name=GroupBox[destination]:GetItem(i):GetItem():GetName()

                                end

                                --Remove all the items

                                GroupBox[destination]:ClearItems()

                                --Sort the items according to weight (ignoring alpha. I am happy with this compromise)

                                table.sort(temp, function (a,b)

                                        if a.Weight == b.Weight then

                                                --return a.Name < b.Name

                                                --return strip(a.Name)< strip(b.Name)

                                                if revorder then return strip(a.Name)> strip(b.Name) else return strip(a.Name)< strip(b.Name) end

                                        else

                                                if revorder then return (a.Weight > b.Weight) else return (a.Weight < b.Weight) end

                                        end

                                 end)

                                --Put the items in the group

                                for i=1,#temp do

                                        GroupBox[destination]:AddItem(temp[i])

                                end

                        end

                        --Refresh heights

                        SetGroupBoxSize()

                        --Add the quantity changed event

                        AddCallback(args.Item, "QuantityChanged",       BagQuantityChanged)

                        unhide(args.Item)

                end

                BagRemove=function( sender, args )

                        --Turbine.Shell.WriteLine("BagRemove "..args.Index)

                        --Note: this is sometimes called when looting *and no item is removed* causing the "empty slot" bug. Annoying, and not my fault!

                        --Also called if a stack is merged.

                        --args.Index    = Bag slot

                        --Remove the quantity changed callback

                        item = backpack:GetItem(args.Index)

                        RemoveCallback(item, "QuantityChanged",         BagQuantityChanged)

                        --Remove item from group

                        GroupBox[BackpackSlots[args.Index].Group]:RemoveItem(BackpackSlots[args.Index])

                        --Make the item for that slot nil

                        BackpackSlots[args.Index]:SetItem(nil)

                        BackpackSlots[args.Index].Group=0

                        --Add it to empty slots.

                        GroupBox[0]:AddItem(BackpackSlots[args.Index])

                        --Refesh Heights

                        SetGroupBoxSize()

                end

                BagMove=function( sender, args )

                        --15/12/11 This has changed completely! The notes below are now false.

                        --Turbine.Shell.WriteLine("BagMove Old Index"..args.OldIndex.." New Index "..args.NewIndex)

                        --[[

                        1) If an item has just been moved to an empty slot then just this fires.

                        2) If an item has been swopped with another; Say A in slot n1 with B in slot n2

                                        ItemRemoved fires on slot n1

                                        ItemMoved fires with B from n2 to n1

                                        ItemAdded fires on slot n2 with item A

                        Essentially, item A (the moved item) gets held "in hand" making the target slot empty.

                        Recently I have come to the belief that it is this that causes the bug, and not ItemRemoved.

                        ]]

                        --args.Item             =Item object of the item that has been moved.

                        --args.NewIndex =Target Slot

                        --args.OldIndex =Destination Slot

                        BackpackSlots[args.NewIndex],BackpackSlots[args.OldIndex]=BackpackSlots[args.OldIndex],BackpackSlots[args.NewIndex]

                        --Refresh heights

                        SetGroupBoxSize()

                end

                BagQuantityChanged=function(sender,args)

                        unhide(sender)

                end

        function unhide(item)

                if not(SB.ShowItem) then return end

                local destination=ItemGroup[ItemCategory[GetCat(item)]]

                if destination==nil then destination=0 end

                --Un-Hide this group

                if Groups[destination].hide then

                        Groups[destination].hide=false

                        SetGroupBoxSize()

                end

        end

        AddCallback(backpack, "ItemAdded",                      BagAdd)

        AddCallback(backpack, "ItemRemoved",            BagRemove)

        AddCallback(backpack, "ItemMoved",                      BagMove)

--Main Structure; Create the window to hold the backpack slots and populate it.

SortBag = Turbine.UI.Lotro.Window()

        SortBag:SetPosition( SB.x,SB.y )

        SortBag:SetText("SortBag")

SortBag.ListBox = Turbine.UI.ListBox()

        SortBag.ListBox:SetParent( SortBag )

        SortBag.ListBox:SetPosition( pad.side, pad.top )

        SortBag.ListBox:SetMaxItemsPerLine(2)

        SortBag.ListBox:SetOrientation( Turbine.UI.Orientation.Horizontal )

        SortBag.ScrollBar=Turbine.UI.Lotro.ScrollBar()

                SortBag.ScrollBar:SetOrientation( Turbine.UI.Orientation.Vertical )

                SortBag.ListBox:SetVerticalScrollBar( SortBag.ScrollBar )

                SortBag.ScrollBar:SetParent(SortBag)

                SortBag.ScrollBar:SetPosition(SB.labelwidth+SB.icx*36+10,pad.top+5)

                SortBag.ScrollBar:SetWidth(10)

        --Remove this control when Turbine fix the backpack bug. again.

        SortBag.Control=Turbine.UI.Control()

                SortBag.Control:SetParent(SortBag)

                SortBag.Control:SetMouseVisible(true)

                SortBag.Control:SetBackground(0x41007e26)

                SortBag.Control:SetSize(16,16)

                SortBag.Control:SetPosition(pad.side-15,pad.top-15)

        SortBag.Control.MouseClick=function()

                --This was, originally, in Button.lua. And is better there imho.

                local contextMenu = Turbine.UI.ContextMenu()

                contextMenu.items = contextMenu:GetItems()

                local option2=Turbine.UI.MenuItem("Re-stack the items - WARNING! EXPERIMENTAL!",true)

                        option2.Click = function () import "JackdawPlugins.SortPack.Stack"      Turbine.Shell.WriteLine("<rgb=#888888>Starting stack")  Stack() end

                local option3=Turbine.UI.MenuItem("Override default bags",true,SB.override)

                        option3.Click = function () SB.override=not(SB.override) SBOverride() end

                local option4=Turbine.UI.MenuItem("Open the sort order panel",true)

                        option4.Click = function () import"JackdawPlugins.SortPack.ListOption" ShowListOption() end

                local option6=Turbine.UI.MenuItem("Create/Edit custom Categories",true)

                        option6.Click = function () import"JackdawPlugins.SortPack.CustomOption" ShowCustomOption() end

                local option7=Turbine.UI.MenuItem("Show a group on item gain.",true,SB.ShowItem)

                        option7.Click = function () SB.ShowItem=not(SB.ShowItem) end

                local option8=Turbine.UI.MenuItem("Open the Debug Window",true)

                        option8.Click = function () import"JackdawPlugins.SortPack.Debug" Debug() end

                local option5 = Turbine.UI.MenuItem("Select SortBag label font;")

                        contextMenu.SubMenuItems = option5:GetItems()

                        local suboption5={}

                        local font={}

                        j=1

                        for i in pairs(Turbine.UI.Lotro.Font) do

                                font[j]=i

                                j=j+1

                        end

                        table.sort(font, function (a,b)

                                        return (a < b)

                         end)

                         for i=1,#font do

                                suboption5[i] = Turbine.UI.MenuItem(font[i],true,font[i]==SB.font)

                                suboption5[i].Click = function ()

                                        SB.font=font[i]

                                        SB.fontsize=string.sub(SB.font,-2)

                                        if SB.fontsize=="ed" then SB.fontsize=13-1 else SB.fontsize=tonumber(SB.fontsize)-1 end

                                        populatebag()

                                end

                                contextMenu.SubMenuItems:Add(suboption5[i])

                        end

                contextMenu.items:Add(option2)

                contextMenu.items:Add(option5)

                contextMenu.items:Add(option3)

                contextMenu.items:Add(option7)

                contextMenu.items:Add(option4)

                contextMenu.items:Add(option6)

                contextMenu.items:Add(option8)

                contextMenu:ShowMenu()

        end

        SortBag.Resize=Turbine.UI.Control()

                SortBag.Resize:SetParent(SortBag)

                SortBag.Resize:SetZOrder(99)

                SortBag.ResizeBack=Turbine.UI.Control()

                SortBag.ResizeBack:SetParent(SortBag.Resize)

                SortBag.ResizeBack:SetBackColor(Turbine.UI.Color(0.7,0.3,0.3,1))

                SortBag.ResizeBack:SetVisible(false)

                SortBag.ResizeBack:SetMouseVisible(false)

                SortBag.Resize.MouseEnter=function() SortBag.ResizeBack:SetVisible(true) end

                SortBag.Resize.MouseLeave=function() SortBag.ResizeBack:SetVisible(false)  end

                SortBag.Resize.MouseDown=function ()

                        draggingr=true

                end

                SortBag.Resize.MouseUp=function ()

                        draggingr=false

                end

                SortBag.Resize.MouseMove=function(sender,args)

                        if draggingr then

                                local oldwidth=SB.width

                                SB.width,dummy=SortBag:GetMousePosition()

                                if SortBag:IsAltKeyDown() then

                                        SB.labelwidth=SB.width-oldwidth+SB.labelwidth

                                        if SB.labelwidth<SB.fontsize then SB.labelwidth=SB.fontsize end

                                else

                                        SB.icx=math.floor((SB.width-2*pad.side-SB.labelwidth)/36)

                                        SB.icy=math.floor((SB.maxheight-(pad.top+pad.bottom))/36)

                                        if SB.icx<3 then SB.icx=3 end

                                        if SB.icy<1 then SB.icy=1 end

                                end

                                        SB.width=36*SB.icx+2*pad.side+SB.labelwidth

                                        SortBag:SetSize(SB.width,SB.maxheight)

                        end

                end

SortBag.SizeChanged=function()

        SortBagSetSize()

        SetGroupBoxSize()

        --Now, if the size of the bag would take the bottom of the bag off the screen, then re-position it.

        local x,y=SortBag:GetPosition()

        if y+SortBag:GetHeight()>SB.maxheight then y=SB.maxheight-SortBag:GetHeight() end

        SortBag:SetPosition(x,y)

end

SortBag:SetSize(SB.width,SB.maxheight)

SortBag.PositionChanged=function()

        local x,y=SortBag:GetPosition()

                if x<0 then x=0 end

                if y<0 then y=0 end

                SortBag:SetPosition(x,y)

                SB.x,SB.y=x,y

end

populatebag()

SBOverride()