415 lines
11 KiB
Lua
415 lines
11 KiB
Lua
local TreeView = {}
|
|
TreeView.__index = TreeView
|
|
|
|
TreeView.SINGLE_SELECT = 0
|
|
TreeView.MULTI_SELECT = 1
|
|
TreeView.RANGE_SELECT = 2
|
|
|
|
TreeView.MOVE_ITEM_NONE = 0
|
|
TreeView.MOVE_ITEM_IN = 1
|
|
TreeView.MOVE_ITEM_UP = 2
|
|
TreeView.MOVE_ITEM_DOWN = 3
|
|
|
|
function TreeView:new( bounds, text, callback, grabCallback, dragCallback, styles, tooltip )
|
|
local object = setmetatable( {}, self )
|
|
object._gui = nil
|
|
|
|
object.padding = 4 -- Content edges.
|
|
object.spacing = 4 -- Between controls.
|
|
object.indentation = 14 -- Indentation for one depth level.
|
|
|
|
object.bounds = bounds:clone()
|
|
object.text = text
|
|
object.scroll = Vec2:new()
|
|
object.view = Rect:new()
|
|
object.callback = callback
|
|
object.grabCallback = grabCallback
|
|
object.dragCallback = dragCallback
|
|
object.styles = styles
|
|
object.tooltip = tooltip
|
|
|
|
object.gui = Raygui:new() -- Contains full independent gui system.
|
|
object.controls = {}
|
|
|
|
-- Set in setSize.
|
|
object.framebufferSize = nil
|
|
object.framebuffer = nil
|
|
object.defaultControlSize = nil
|
|
|
|
object.visible = true
|
|
object.disabled = false
|
|
object.draggable = true
|
|
|
|
object.mouseScale = 1 -- Set this if drawing in different size to render texture for example.
|
|
object.selectedItems = {}
|
|
|
|
object:setSize( Vec2:new( object.bounds.width, object.bounds.height ) )
|
|
|
|
object._forceCheckScroll = false
|
|
object._posY = 0 -- In control list update.
|
|
object._curDepth = 0 -- Current indentation.
|
|
object._curId = 0 -- Running number to give id's for controls.
|
|
object._idRange = { 1, 1 }
|
|
object._lastActiveItem = nil
|
|
object._clickedItem = nil
|
|
object._movingItem = object.MOVE_ITEM_NONE
|
|
|
|
object:updateMouseOffset()
|
|
|
|
return object
|
|
end
|
|
|
|
function TreeView:getDefaultBounds()
|
|
return Rect:new( self.padding, self.padding, self.defaultControlSize.x, self.defaultControlSize.y )
|
|
end
|
|
|
|
local function getControlBounds( control )
|
|
return control.viewBounds or control.focusBounds or control.bounds
|
|
end
|
|
|
|
function TreeView:updateControl( control )
|
|
control.bounds = self:getDefaultBounds()
|
|
control._depth = self._curDepth
|
|
control._indentation = self.indentation
|
|
control._id = self._curId
|
|
self._curId = self._curId + 1
|
|
|
|
if control.visible then
|
|
control:setPosition( Vec2:new( control.bounds.x, self._posY ) )
|
|
local bounds = getControlBounds( control )
|
|
|
|
bounds.x = bounds.x + self._curDepth * self.indentation
|
|
bounds.width = bounds.width - self._curDepth * self.indentation
|
|
|
|
if not control._noYAdvance then
|
|
self._posY = self._posY + bounds.height + self.spacing
|
|
end
|
|
self.content = self.content:fit( bounds )
|
|
end
|
|
|
|
if 0 < #control.controls then
|
|
self._curDepth = self._curDepth + 1
|
|
|
|
for i, groupControl in ipairs( control.controls ) do
|
|
groupControl.visible = control.open
|
|
groupControl._parent = control
|
|
groupControl._childId = i
|
|
|
|
if not control.open and 0 < #control.controls then
|
|
groupControl.open = false
|
|
groupControl.active = false
|
|
end
|
|
|
|
self:updateControl( groupControl )
|
|
end
|
|
|
|
self._curDepth = self._curDepth - 1
|
|
end
|
|
end
|
|
|
|
function TreeView:updateContent()
|
|
self._posY = self.padding
|
|
self._curId = 1
|
|
|
|
self.content.width = 0
|
|
self.content.height = 0
|
|
|
|
for i, control in ipairs( self.controls ) do
|
|
control._parent = nil -- Sets parent in updateControl if any.
|
|
control._childId = i
|
|
self:updateControl( control )
|
|
end
|
|
self.content.x = 0
|
|
self.content.y = 0
|
|
self.content.height = self.content.height + self.padding
|
|
self.content.width = self.content.width + self.padding
|
|
self._forceCheckScroll = true
|
|
end
|
|
|
|
function TreeView:addItem( name, group )
|
|
local control = self.gui:TreeItem(
|
|
self:getDefaultBounds(),
|
|
name,
|
|
{ -- Callbacks.
|
|
open = function( this ) self:updateContent() end,
|
|
toggle = function( this ) self:itemSelect( this ) end,
|
|
},
|
|
{ -- Styles.
|
|
properties = {
|
|
{ RL.TOGGLE, RL.TEXT_ALIGNMENT, RL.TEXT_ALIGN_LEFT },
|
|
{ RL.TOGGLE, RL.BASE_COLOR_NORMAL, RL.ColorToInt( RL.BLANK ) },
|
|
{ RL.TOGGLE, RL.BORDER_COLOR_NORMAL, RL.ColorToInt( RL.BLANK ) },
|
|
}
|
|
}
|
|
)
|
|
if group ~= nil then
|
|
table.insert( group.controls, control )
|
|
else
|
|
table.insert( self.controls, control )
|
|
end
|
|
|
|
self:updateContent()
|
|
|
|
return control
|
|
end
|
|
|
|
function TreeView:checkItem( controls, item, mode )
|
|
for _, control in ipairs( controls ) do
|
|
if mode == self.SINGLE_SELECT and control ~= item then
|
|
control.active = false
|
|
end
|
|
if 0 < #control.controls then
|
|
self:checkItem( control.controls, item, mode )
|
|
end
|
|
if mode == self.RANGE_SELECT then
|
|
if self._idRange[1] <= control._id and control._id <= self._idRange[2] then
|
|
control.active = true
|
|
end
|
|
end
|
|
if control.active then
|
|
table.insert( self.selectedItems, control )
|
|
-- table.insert( self.selectedItems, 1, control )
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Check if trying to move parent to child.
|
|
function TreeView:isChild( item, newParent )
|
|
local to = newParent
|
|
|
|
while to ~= nil do
|
|
to = to._parent
|
|
|
|
if item == to then
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function TreeView:itemSelect( item )
|
|
-- Item move.
|
|
|
|
local moveItems = {}
|
|
|
|
if self._movingItem ~= self.MOVE_ITEM_NONE then
|
|
|
|
for i = #self.selectedItems, 1, -1 do
|
|
local moveItem = self.selectedItems[i]
|
|
-- print( moveItem.text, "moveItem._id", moveItem._id, item.text, "item._id", item._id )
|
|
|
|
if moveItem ~= item and not self:isChild( moveItem, item ) then
|
|
local parentControls = self.controls
|
|
|
|
if moveItem._parent ~= nil then
|
|
parentControls = moveItem._parent.controls
|
|
end
|
|
|
|
local pos = #self.selectedItems - i + 1
|
|
|
|
if moveItem._parent == item._parent and moveItem._childId < item._childId then
|
|
pos = 1
|
|
end
|
|
|
|
table.insert( moveItems, pos, table.remove( parentControls, moveItem._childId ) )
|
|
end
|
|
|
|
moveItem.active = false
|
|
end
|
|
|
|
for _, moveItem in ipairs( moveItems ) do
|
|
local newParentControls = self.controls
|
|
|
|
if item._parent ~= nil then
|
|
newParentControls = item._parent.controls
|
|
end
|
|
|
|
local offset = 0
|
|
|
|
if moveItem._parent == item._parent and moveItem._childId < item._childId then
|
|
offset = -1
|
|
end
|
|
|
|
if self._movingItem == self.MOVE_ITEM_IN then
|
|
table.insert( item.controls, 1, moveItem )
|
|
elseif self._movingItem == self.MOVE_ITEM_UP then
|
|
local pos = RL.Clamp( item._childId + offset, 1, #newParentControls + 1 )
|
|
table.insert( newParentControls, pos, moveItem )
|
|
elseif self._movingItem == self.MOVE_ITEM_DOWN then
|
|
local pos = RL.Clamp( item._childId + offset + 1, 1, #newParentControls + 1 )
|
|
table.insert( newParentControls, pos, moveItem )
|
|
end
|
|
end
|
|
|
|
item.active = false
|
|
self._movingItem = self.MOVE_ITEM_NONE
|
|
self:updateContent()
|
|
|
|
return
|
|
end
|
|
|
|
-- Item select.
|
|
|
|
local mode = self.SINGLE_SELECT
|
|
|
|
if RL.IsKeyDown( RL.KEY_LEFT_CONTROL ) or RL.IsKeyDown( RL.KEY_RIGHT_CONTROL ) then
|
|
mode = self.MULTI_SELECT
|
|
elseif RL.IsKeyDown( RL.KEY_LEFT_SHIFT ) or RL.IsKeyDown( RL.KEY_RIGHT_SHIFT ) then
|
|
mode = self.RANGE_SELECT
|
|
end
|
|
|
|
if self._lastActiveItem ~= nil then
|
|
self._idRange = { math.min( self._lastActiveItem._id, item._id ), math.max( self._lastActiveItem._id, item._id ) }
|
|
end
|
|
self.selectedItems = {}
|
|
self:checkItem( self.controls, item, mode )
|
|
|
|
if mode ~= self.RANGE_SELECT then
|
|
self._lastActiveItem = item -- Old clicked.
|
|
end
|
|
|
|
if self.callback ~= nil then
|
|
self.callback( self.selectedItems )
|
|
end
|
|
end
|
|
|
|
function TreeView:update()
|
|
local mousePos = Vec2:new( RL.GetMousePosition() )
|
|
local guiMousePos = mousePos + self.gui.mouseOffset
|
|
local mouseInView = self.view:checkCollisionPoint( mousePos )
|
|
|
|
if not mouseInView then
|
|
self.gui.locked = true
|
|
else
|
|
self.gui.locked = false
|
|
end
|
|
|
|
self.gui:update()
|
|
|
|
local mouseInClickedItem = false
|
|
|
|
if RL.IsMouseButtonPressed( RL.MOUSE_BUTTON_LEFT ) then
|
|
if 0 < self.gui.focused and mouseInView and self.gui.controls[ self.gui.focused ].active then
|
|
self._clickedItem = self.gui.controls[ self.gui.focused ]
|
|
else
|
|
self._clickedItem = nil
|
|
end
|
|
end
|
|
|
|
if self._clickedItem ~= nil then
|
|
mouseInClickedItem = self._clickedItem.bounds:checkCollisionPoint( guiMousePos )
|
|
end
|
|
|
|
RL.BeginTextureMode( self.framebuffer )
|
|
RL.ClearBackground( RL.BLANK )
|
|
RL.rlTranslatef( { self.scroll.x, self.scroll.y, 0 } )
|
|
|
|
self.gui:draw()
|
|
|
|
if RL.IsMouseButtonDown( RL.MOUSE_BUTTON_LEFT ) and self._clickedItem ~= nil
|
|
and not mouseInClickedItem and 0 < self.gui.focused then
|
|
local focusBounds = self.gui.controls[ self.gui.focused ].bounds
|
|
local relY = ( guiMousePos.y - focusBounds.y ) / focusBounds.height
|
|
|
|
if relY <= 0.35 then
|
|
RL.DrawLine(
|
|
{ focusBounds.x, focusBounds.y },
|
|
{ focusBounds.x + focusBounds.width, focusBounds.y },
|
|
6, RL.RED
|
|
)
|
|
self._movingItem = self.MOVE_ITEM_UP
|
|
elseif 0.65 <= relY then
|
|
RL.DrawLine(
|
|
{ focusBounds.x, focusBounds.y + focusBounds.height },
|
|
{ focusBounds.x + focusBounds.width, focusBounds.y + focusBounds.height },
|
|
6, RL.RED
|
|
)
|
|
self._movingItem = self.MOVE_ITEM_DOWN
|
|
else
|
|
RL.DrawRectangleLines( focusBounds, RL.RED )
|
|
self._movingItem = self.MOVE_ITEM_IN
|
|
end
|
|
elseif RL.IsMouseButtonReleased( RL.MOUSE_BUTTON_LEFT ) then
|
|
self._clickedItem = nil
|
|
self._movingItem = self.MOVE_ITEM_NONE
|
|
end
|
|
RL.EndTextureMode()
|
|
|
|
return self._gui:drag( self )
|
|
end
|
|
|
|
function TreeView:draw()
|
|
local oldScroll = self.scroll:clone()
|
|
local _, scroll, view = RL.GuiScrollPanel( self.bounds, self.text, self.content, self.scroll, self.view )
|
|
self.view:set( view )
|
|
self.scroll:set( scroll )
|
|
|
|
if self.scroll ~= oldScroll or self._forceCheckScroll then
|
|
if not self._forceCheckScroll then
|
|
self._gui:checkScrolling()
|
|
end
|
|
self._forceCheckScroll = false
|
|
|
|
self:updateMouseOffset()
|
|
self.gui.view:set( -self.scroll.x, -self.scroll.y, self.view.width, self.view.height )
|
|
end
|
|
|
|
RL.DrawTexturePro(
|
|
RL.GetRenderTextureTexture( self.framebuffer ),
|
|
{ 0, self.framebufferSize.y - self.view.height, self.view.width, -self.view.height },
|
|
{ math.floor( self.view.x ), math.floor( self.view.y ), self.view.width, self.view.height },
|
|
{ 0, 0 },
|
|
0.0,
|
|
RL.WHITE
|
|
)
|
|
end
|
|
|
|
function TreeView:updateMouseOffset()
|
|
self.gui.mouseOffset = Vec2:new( -self.view.x - self.scroll.x, -self.view.y - self.scroll.y ):scale( self.mouseScale )
|
|
end
|
|
|
|
function TreeView:setPosition( pos )
|
|
self.bounds.x = pos.x
|
|
self.bounds.y = pos.y
|
|
|
|
self:updateMouseOffset()
|
|
end
|
|
|
|
function TreeView:setSize( size )
|
|
self.bounds.width = size.x
|
|
self.bounds.height = size.y
|
|
|
|
local scrollBarWidth = RL.GuiGetStyle( RL.LISTVIEW, RL.SCROLLBAR_WIDTH )
|
|
local borderWidth = RL.GuiGetStyle( RL.DEFAULT, RL.BORDER_WIDTH )
|
|
|
|
self.content = Rect:new(
|
|
0,
|
|
self.gui.RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT,
|
|
self.bounds.width - scrollBarWidth - self.padding * 2 - borderWidth * 2,
|
|
self.bounds.height - scrollBarWidth - self.padding * 2 - borderWidth * 2
|
|
)
|
|
self.defaultControlSize = Vec2:new( self.content.width, 22 )
|
|
|
|
local _, _, view = RL.GuiScrollPanel( self.bounds, self.text, self.content, self.scroll, self.view )
|
|
self.view = Rect:new( view )
|
|
|
|
self.gui.view = Rect:new( 0, 0, self.view.width, self.view.height )
|
|
self.framebufferSize = Vec2:new( self.bounds.width, self.bounds.height - self.gui.RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT )
|
|
|
|
if self.framebuffer ~= nil and not RL.IsGCUnloadEnabled() then
|
|
RL.UnloadRenderTexture( self.framebuffer )
|
|
end
|
|
self.framebuffer = RL.LoadRenderTexture( self.framebufferSize )
|
|
|
|
self:updateContent()
|
|
end
|
|
|
|
function TreeView:register( gui )
|
|
function gui:TreeView( bounds, text, callback, grabCallback, dragCallback, styles, tooltip )
|
|
return self:addControl( TreeView:new( bounds, text, callback, grabCallback, dragCallback, styles, tooltip ) )
|
|
end
|
|
end
|
|
|
|
return TreeView
|