Cleaned up gui

expcore/gui/concepts/center.lua

@@ -0,0 +1,190 @@
+--- Gui structure define for center gui frames
+--[[
+>>>> Functions
+    CenterFrames.get_flow(player) --- Gets the center flow for a player
+    CenterFrames.clear_flow(player) --- Clears the center flow for a player
+    CenterFrames.draw_frame(player,name) --- Draws the center frame for a player, if already open then will do nothing
+    CenterFrames.redraw_frame(player,name) --- Draws the center frame for a player, if already open then will destroy it and redraw
+    CenterFrames.toggle_frame(player,name,state) --- Toggles if the frame is currently open or not, will open if closed and close if open
+
+    CenterFrames.new_frame(permision_name) --- Sets the frame to be the current active gui when opened and closes all other frames
+    CenterFrames._prototype:on_draw(player,frame) --- Use to draw your elements onto the new frame
+    CenterFrames._prototype:set_auto_focus(state) --- Sets the frame to be the current active gui when opened and closes all other frames
+    CenterFrames._prototype:draw_frame(player) --- Draws this frame to the player, if already open does nothing (will call on_draw to draw to the frame)
+    CenterFrames._prototype:redraw_frame(player) --- Draws this frame to the player, if already open it will remove it and redraw it (will call on_draw to draw to the frame)
+    CenterFrames._prototype:toggle_frame(player) --- Toggles if the frame is open, if open it will close it and if closed it will open it
+    CenterFrames._prototype:event_handler(action) --- Creates an event handler that will trigger one of its functions, use with Event.add
+]]
+local Gui = require 'expcore.gui.core'
+local Prototype = require 'expcore.gui.prototype'
+local Toolbar = require 'expcore.gui.concepts.toolbar'
+local Game = require 'utils.game'
+
+local CenterFrames = {
+	_prototype = Prototype.extend{
+		on_creation = Prototype.event
+	}
+}
+
+--- Gets the center flow for a player
+-- @tparam LuaPlayer player the player to get the flow for
+-- @treturn LuaGuiElement the center flow
+function CenterFrames.get_flow(player)
+    player = Game.get_player_from_any(player)
+    return player.gui.center
+end
+
+--- Clears the center flow for a player
+-- @tparam LuaPlayer player the player to clear the flow for
+function CenterFrames.clear_flow(player)
+    local flow = CenterFrames.get_flow(player)
+    flow.clear()
+end
+
+--- Draws the center frame for a player, if already open then will do nothing
+-- @tparam LuaPlayer player the player that will have the frame drawn
+-- @tparam string name the name of the hui that will drawn
+-- @treturn LuaGuiElement the new frame that was made
+function CenterFrames.draw_frame(player,name)
+    local define = Gui.get_define(name,true)
+    if define then
+        return define:draw_frame(player)
+    end
+end
+
+--- Draws the center frame for a player, if already open then will destroy it and redraw
+-- @tparam LuaPlayer player the player that will have the frame drawn
+-- @tparam string name the name of the hui that will drawn
+-- @treturn LuaGuiElement the new frame that was made
+function CenterFrames.redraw_frame(player,name)
+    local define = Gui.get_define(name,true)
+    if define then
+        return define:draw_frame(player)
+    end
+end
+
+--- Toggles if the frame is currently open or not, will open if closed and close if open
+-- @tparam LuaPlayer player the player that will have the frame toggled
+-- @tparam string name the name of the hui that will be toggled
+-- @tparam[opt] boolean state when set will force a state for the frame
+-- @treturn boolean if the frame if no open or closed
+function CenterFrames.toggle_frame(player,name,state)
+    local define = Gui.get_define(name,true)
+    if define then
+        if state == true then
+            define:draw_frame(player)
+            return true
+        elseif state == false then
+            local flow = CenterFrames.get_flow(player)
+            if flow[define.name..'-frame'] then
+                flow[define.name..'-frame'].destroy()
+            end
+            return false
+        else
+            return define:toggle_frame(player)
+        end
+    end
+end
+
+--- Creates a new center frame define
+-- @tparam string permision_name the name that can be used with the permision system
+-- @treturn table the new center frame define
+function CenterFrames.new_frame(permision_name)
+	local self = Toolbar.new_button(permision_name)
+
+	self:on_click(function(player,element)
+		self:toggle_frame(player)
+	end)
+
+    local mt = getmetatable(self)
+    mt.__index = CenterFrames._prototype
+	mt.__call = self.event_handler
+
+    Gui.on_custom_close(self.name..'-frame',function(event)
+        local element = event.element
+        if element and element.valid then element.destroy() end
+    end)
+
+	return self
+end
+
+--- Sets the frame to be the current active gui when opened and closes all other frames
+-- @tparam[opt=true] boolean state when true will auto close other frames and set this frame as player.opened
+function CenterFrames._prototype:set_auto_focus(state)
+    if state == false then
+        self.auto_focus = false
+    else
+        self.auto_focus = true
+    end
+end
+
+--- Draws this frame to the player, if already open does nothing (will call on_draw to draw to the frame)
+-- @tparam LuaPlayer player the player to draw the frame for
+-- @treturn LuaGuiElement the new frame that was drawn
+function CenterFrames._prototype:draw_frame(player)
+    player = Game.get_player_from_any(player)
+    local flow = CenterFrames.get_flow(player)
+
+    if flow[self.name..'-frame'] then
+        return flow[self.name..'-frame']
+    end
+
+    if self.auto_focus then
+        flow.clear()
+    end
+
+    local frame = flow.add{
+        type='frame',
+        name=self.name..'-frame'
+    }
+
+    if self.auto_focus then
+        player.opened = frame
+    end
+
+    self:raise_event('on_creation',player,frame)
+
+    return frame
+end
+
+--- Draws this frame to the player, if already open it will remove it and redraw it (will call on_draw to draw to the frame)
+-- @tparam LuaPlayer player the player to draw the frame for
+-- @treturn LuaGuiElement the new frame that was drawn
+function CenterFrames._prototype:redraw_frame(player)
+    player = Game.get_player_from_any(player)
+    local flow = CenterFrames.get_flow(player)
+
+    if flow[self.name..'-frame'] then
+        flow[self.name..'-frame'].destroy()
+    end
+
+    return self:draw_frame(player)
+end
+
+--- Toggles if the frame is open, if open it will close it and if closed it will open it
+-- @tparam LuaPlayer player the player to draw the frame for
+-- @treturn boolean with the gui frame is now open
+function CenterFrames._prototype:toggle_frame(player)
+    player = Game.get_player_from_any(player)
+    local flow = CenterFrames.get_flow(player)
+
+    if flow[self.name..'-frame'] then
+        flow[self.name..'-frame'].destroy()
+        return false
+    else
+        self:draw_frame(player)
+        return true
+    end
+end
+
+--- Creates an event handler that will trigger one of its functions, use with Event.add
+-- @tparam[opt=update] string action the action to take on this event
+function CenterFrames._prototype:event_handler(action)
+    action = action or 'update'
+    return function(event)
+        local player = Game.get_player_by_index(event.player_index)
+        self[action](self,player)
+    end
+end
+
+return CenterFrames

expcore/gui/concepts/left.lua

@@ -0,0 +1,314 @@
+--- Gui structure define for left frames
+--[[
+>>>> Example formating
+
+    -- first we add config that relates to the button on the toolbar, all normal button functions are present
+    local left_frame =
+    Gui.new_left_frame('test-left-frame')
+    :set_caption('Test Left Gui')
+    :set_post_authenticator(function(player,button_name)
+        return global.show_test_gui
+    end)
+
+    -- then we add the config for the left frame, on_draw should draw the gui from an empty frame, on_update should take a frame from on_draw on edit it
+    :set_open_by_default()
+    :on_draw(function(_player,frame)
+        for _,player in pairs(game.connected_players) do
+            frame.add{
+                type='label',
+                caption=player.name
+            }
+        end
+    end)
+
+    -- now we can use the action factory to call events on the gui, actions are: 'update', 'update_all', 'redraw', 'redraw_all'
+    Event.add(defines.events.on_player_joined_game,left_frame 'update_all')
+    Event.add(defines.events.on_player_left_game,left_frame 'update_all')
+
+>>>> Functions
+    LeftFrames.get_flow(player) --- Gets the left frame flow for a player
+    LeftFrames.get_frame(name,player) --- Gets one frame from the left flow by its name
+    LeftFrames.get_open(player) --- Gets all open frames for a player, if non are open it will remove the close all button
+    LeftFrames.toggle_frame(name,player,state) --- Toggles the visiblty of a left frame, or sets its visiblty state
+
+    LeftFrames.new_frame(permision_name) --- Creates a new left frame define
+    LeftFrames._prototype:set_open_by_default(state) --- Sets if the frame is visible when a player joins, can also be a function to return a boolean
+    LeftFrames._prototype:set_direction(direction) --- Sets the direction of the frame, either vertical or horizontal
+    LeftFrames._prototype:get_frame(player) --- Gets the frame for this define from the left frame flow
+    LeftFrames._prototype:is_open(player) --- Returns if the player currently has this define visible
+    LeftFrames._prototype:toggle(player) --- Toggles the visiblty of the left frame
+
+    LeftFrames._prototype:update(player) --- Updates the contents of the left frame, first tries update callback, oter wise will clear and redraw
+    LeftFrames._prototype:update_all(update_offline) --- Updates the frame for all players, see update
+    LeftFrames._prototype:redraw(player) --- Redraws the frame by calling on_draw, will always clear the frame
+    LeftFrames._prototype:redraw_all(update_offline) --- Redraws the frame for all players, see redraw
+
+    LeftFrames._prototype:on_draw(player,frame) --- Use to draw your elements to the new frame
+    LeftFrames._prototype:on_update(player,frame) --- Use to edit your frame when there is no need to redraw it
+    LeftFrames._prototype:on_player_toggle(player,frame) --- Is triggered when the player presses the toggle button
+    LeftFrames._prototype:event_handler(action) --- Creates an event handler that will trigger one of its functions, use with Event.add
+]]
+local Gui = require 'expcore.gui.core'
+local Prototype = require 'expcore.gui.prototype'
+local Toolbar = require 'expcore.gui.concepts.toolbar'
+local Buttons = require 'expcore.gui.elements.buttons'
+local mod_gui = require 'mod-gui'
+local Game = require 'utils.game'
+local Event = require 'utils.event'
+
+local LeftFrames = {
+    frames={},
+    _prototype=Prototype.extend{
+        on_creation = Prototype.event,
+        on_update = Prototype.event,
+        on_player_toggle = Prototype.event
+    }
+}
+setmetatable(LeftFrames._prototype, {
+    __index = Buttons._prototype
+})
+
+--- Gets the left frame flow for a player
+-- @tparam LuaPlayer player the player to get the flow of
+-- @treturn LuaGuiElement the left frame flow for the player
+function LeftFrames.get_flow(player)
+    player = Game.get_player_from_any(player)
+    return mod_gui.get_frame_flow(player)
+end
+
+--- Gets one frame from the left flow by its name
+-- @tparam string name the name of the gui frame to get
+-- @tparam LuaPlayer player the player to get the frame of
+-- @treturn LuaGuiElement the frame in the left frame flow with that name
+function LeftFrames.get_frame(name,player)
+    local define = LeftFrames.frames[name]
+    if not define then
+        return error('Left Frame '..name..' is not defined.',2)
+    end
+    return define:get_frame(player)
+end
+
+--- Gets all open frames for a player, if non are open it will remove the close all button
+-- @tparam LuaPlayer player the player to get the flow of
+-- @treturn table contains all the open (and registered) frames for the player
+function LeftFrames.get_open(player)
+    local open = {}
+    local flow = LeftFrames.get_flow(player)
+
+    for _,define in pairs(LeftFrames.frames) do
+        if define:is_open(player) then
+            table.insert(open,define)
+        end
+    end
+
+    flow[LeftFrames.toggle_button.name].visible = #open ~= 0
+
+    return open
+end
+
+--- Toggles the visiblty of a left frame, or sets its visiblty state
+-- @tparam string name the name of the gui frame to toggle
+-- @tparam LuaPlayer player the player to get the frame of
+-- @tparam[opt] boolean state when given will be the state that the visiblty is set to
+-- @treturn boolean the new state of the visiblity
+function LeftFrames.toggle_frame(name,player,state)
+    local define = LeftFrames.frames[name]
+    if not define then
+        return error('Left Frame '..name..' is not defined.',2)
+    end
+
+    local frame = LeftFrames.get_frame(name,player)
+    if state ~= nil then
+        frame.visible = state
+    else
+        Gui.toggle_visible(frame)
+    end
+
+    LeftFrames.get_open(player)
+
+    return frame.visible
+end
+
+--- Creates a new left frame define
+-- @tparam string permision_name the name that can be used with the permision system
+-- @treturn table the new left frame define
+function LeftFrames.new_frame(permision_name)
+    local self = Toolbar.new_button(permision_name)
+
+    local mt = getmetatable(self)
+    mt.__index = LeftFrames._prototype
+    mt.__call = self.event_handler
+
+    self:on_click(function(player,_element)
+        local visible = self:toggle(player)
+        local frame = self:get_frame(player)
+        self:raise_event('on_player_toggle',player,frame,visible)
+    end)
+
+    LeftFrames.frames[self.name] = self
+
+    return self
+end
+
+--- Sets if the frame is visible when a player joins, can also be a function to return a boolean
+-- @tparam[opt=true] ?boolean|function state the default state of the visiblty, can be a function
+-- state param - player LuaPlayer - the player that has joined the game
+-- state param - define_name string - the define name for the frame
+-- state return - boolean - false will hide the frame
+function LeftFrames._prototype:set_open_by_default(state)
+    if state == false then
+        self.open_by_default = false
+    elseif state == nil then
+        self.open_by_default = true
+    else
+        self.open_by_default = state
+    end
+    return self
+end
+
+--- Sets the direction of the frame, either vertical or horizontal
+-- @tparam string direction the direction to have the elements be added to thef frame
+function LeftFrames._prototype:set_direction(direction)
+    self.direction = direction
+    return self
+end
+
+--- Creates the gui for the first time, used internally
+-- @tparam LuaPlayer player the player to draw the frame to
+-- @treturn LuaGuiElement the frame that was made
+function LeftFrames._prototype:_internal_draw(player)
+    local flow = LeftFrames.get_flow(player)
+    local frame = flow.add{
+        type='frame',
+        name=self.name..'-frame',
+        direction=self.direction
+    }
+
+    self:raise_event('on_creation',player,frame)
+
+    if not self.open_by_default then
+        frame.visible = false
+    elseif type(self.open_by_default) == 'function' then
+        if not self.open_by_default(player,self.name) then
+            frame.visible = false
+        end
+    end
+
+    if not Toolbar.allowed(player,self.name) then
+        frame.visible = false
+    end
+
+    return frame
+end
+
+--- Gets the frame for this define from the left frame flow
+-- @tparam LuaPlayer player the player to get the frame of
+-- @treturn LuaGuiElement the frame in the left frame flow for this define
+function LeftFrames._prototype:get_frame(player)
+    local flow = LeftFrames.get_flow(player)
+    if flow[self.name..'-frame'] and flow[self.name..'-frame'].valid then
+        return flow[self.name..'-frame']
+    else
+        return self:_internal_draw(player)
+    end
+end
+
+--- Returns if the player currently has this define visible
+-- @tparam LuaPlayer player the player to get the frame of
+-- @treturn boolean true if it is open/visible
+function LeftFrames._prototype:is_open(player)
+    local frame = self:get_frame(player)
+    return frame and frame.visible or false
+end
+
+--- Toggles the visiblty of the left frame
+-- @tparam LuaPlayer player the player to toggle the frame of
+-- @treturn boolean the new state of the visiblity
+function LeftFrames._prototype:toggle(player)
+    local frame = self:get_frame(player)
+    Gui.toggle_visible(frame)
+    LeftFrames.get_open(player)
+    return frame.visible
+end
+
+--- Updates the contents of the left frame, first tries update callback, oter wise will clear and redraw
+-- @tparam LuaPlayer player the player to update the frame of
+function LeftFrames._prototype:update(player)
+    local frame = self:get_frame(player)
+    if self:raise_event('on_update',player,frame) == 0 then
+        frame.clear()
+        self:raise_event('on_creation',player,frame)
+    end
+end
+
+--- Updates the frame for all players, see update
+-- @tparam[opt=false] boolean update_offline when true will update the frame for offline players
+function LeftFrames._prototype:update_all(update_offline)
+    local players = update_offline == true and game.players or game.connected_players
+    for _,player in pairs(players) do
+        self:update(player)
+    end
+end
+
+--- Redraws the frame by calling on_draw, will always clear the frame
+-- @tparam LuaPlayer player the player to update the frame of
+function LeftFrames._prototype:redraw(player)
+    local frame = self:get_frame(player)
+    frame.clear()
+    self:raise_event('on_creation',player,frame)
+end
+
+--- Redraws the frame for all players, see redraw
+-- @tparam[opt=false] boolean update_offline when true will update the frame for offline players
+function LeftFrames._prototype:redraw_all(update_offline)
+    local players = update_offline == true and game.players or game.connected_players
+    for _,player in pairs(players) do
+        self:redraw(player)
+    end
+end
+
+--- Creates an event handler that will trigger one of its functions, use with Event.add
+-- @tparam[opt=update] string action the action to take on this event
+function LeftFrames._prototype:event_handler(action)
+    action = action or 'update'
+    return function(event)
+        local player
+        if event and event.player_index then
+            player = Game.get_player_by_index(event.player_index)
+        end
+        self[action](self,player)
+    end
+end
+
+LeftFrames.toggle_button =
+Buttons.new_button()
+:set_tooltip{'expcore-gui.left-button-tooltip'}
+:set_caption('<')
+:on_click(function(player,element)
+    for _,define in pairs(LeftFrames.frames) do
+        local frame = LeftFrames.get_frame(define.name,player)
+        frame.visible = false
+        define:raise_event('on_player_toggle',player,frame,false)
+    end
+    element.visible = false
+end)
+
+Event.add(defines.events.on_player_created,function(event)
+    local player = Game.get_player_by_index(event.player_index)
+    local flow = LeftFrames.get_flow(player)
+
+    local close_button = LeftFrames.toggle_button(flow)
+    Gui.set_padding(close_button)
+    local style = close_button.style
+    style.width = 18
+    style.height = 36
+    style.font = 'default-small-bold'
+
+    for _,define in pairs(LeftFrames.frames) do
+        define:_internal_draw(player)
+    end
+
+    LeftFrames.get_open(player)
+end)
+
+return LeftFrames

expcore/gui/concepts/popups.lua

@@ -0,0 +1,222 @@
+--- Gui structure define for popup gui
+--[[
+>>>> Functions
+    PopupFrames.get_flow(player) --- Gets the left flow that contains the popup frames
+    PopupFrames.open(define_name,player,open_time,...) --- Opens a popup for the player, can give the amount of time it is open as well as params for the draw function
+
+    PopupFrames.close_progress --- Progress bar which when depleaded will close the popup frame
+    PopupFrames.close_button --- A button which can be used to close the gui before the timer runs out
+
+    PopupFrames.new_popup(name) --- Creates a new popup frame define
+    PopupFrames._prototype:set_default_open_time(amount) --- Sets the default open time for the popup, will be used if non is provided with open
+    PopupFrames._prototype:open(player,open_time,...) --- Opens this define for a player, can be given open time and any other params for the draw function
+]]
+local Gui = require 'expcore.gui.core'
+local Prototype = require 'expcore.gui.prototype'
+local Game = require 'utils.game'
+local Event = require 'utils.event'
+local ProgressBar = require 'expcore.gui.elements.progress-bar'
+local Button = require 'expcore.gui.elements.buttons'
+local mod_gui = require 'mod-gui'
+local Color = require 'resources.color_presets'
+local Global = require 'utils.global'
+
+local PopupFrames = {
+    paused_popups={},
+	popup_flow_name = Gui.uid_name(),
+	main_frame_name = Gui.uid_name(),
+	close_frame_name = Gui.uid_name(),
+	_prototype = Prototype.extend{
+		on_creation = Prototype.event
+	}
+}
+Global.register(PopupFrames.paused_popups,function(tbl)
+    PopupFrames.paused_popups = tbl
+end)
+
+--- Sets the state of the element in the pasued list, nil or true
+-- @tparam LuaGuiElement element the element to set the state of
+-- @tparam[opt] boolean state the state to set it to, true will pause the the progress bar
+local function set_pasued_state(element,state)
+    local name = element.player_index..':'..element.index
+    PopupFrames.paused_popups[name] = state
+end
+
+--- Gets the state of the element in the pasued list, nil or true
+-- @tparam LuaGuiElement element the element to get the state of
+local function get_pasued_state(element)
+    local name = element.player_index..':'..element.index
+    return PopupFrames.paused_popups[name]
+end
+
+--- Gets the left flow that contains the popup frames
+-- @tparam LuaPlayer player the player to get the flow for
+-- @treturn LuaGuiElement the left flow that contains the popup frames
+function PopupFrames.get_flow(player)
+    player = Game.get_player_from_any(player)
+    local flow = mod_gui.get_frame_flow(player)
+	return flow[PopupFrames.popup_flow_name]
+end
+
+--- Opens a popup for the player, can give the amount of time it is open as well as params for the draw function
+-- @tparam string define_name the name of the define that you want to open for the player
+-- @tparam LuaPlayer player the player to open the popup for
+-- @tparam[opt] number open_time the minimum number of ticks you want the popup open for, 0 means no limit, nil will take default
+-- @tparam any ... the other params that you want to pass to your on_draw event
+-- @treturn LuaGuiElement the frame that was drawn, the inner gui flow which contains the content
+function PopupFrames.open(define_name,player,open_time,...)
+    local define = Gui.get_define(define_name,true)
+    player = Game.get_player_from_any(player)
+    return define:open(player,open_time,...)
+end
+
+--- Closes the popup, is called by progress bar and close button
+-- @tparam LuaGuiElement element either the progress bar or the close button
+local function close_popup(element)
+	local frame = element.parent.parent.parent
+    if not frame or not frame.valid then return end
+    set_pasued_state(element.parent[PopupFrames.close_progress:uid()])
+	frame.destroy()
+end
+
+--- Progress bar which when depleaded will close the popup frame
+PopupFrames.close_progress =
+ProgressBar.new_progressbar()
+:use_count_down()
+:set_tooltip('Pause/Resume Auto-close')
+:on_complete(function(player,element)
+	close_popup(element)
+end)
+
+--- A button which can be used to close the gui before the timer runs out
+PopupFrames.close_button =
+Button.new_button()
+:set_sprites('utility/close_white')
+:set_tooltip('Close Popup')
+:on_click(function(player,element)
+	close_popup(element)
+end)
+
+--- When the progress bar is clicked it will pause its progress, or resume if previously paused
+Gui.on_click(PopupFrames.close_progress:uid(),function(event)
+    local element = event.element
+    if get_pasued_state(element) then
+        set_pasued_state(element)
+    else
+        set_pasued_state(element,true)
+    end
+end)
+
+--- When the parent flow of the progress bar is clicked it will pause its progress, or resume if previously paused
+Gui.on_click(PopupFrames.close_frame_name,function(event)
+    local element = event.element[PopupFrames.close_progress:uid()]
+    if get_pasued_state(element) then
+        set_pasued_state(element)
+    else
+        set_pasued_state(element,true)
+    end
+end)
+
+--- Creates a new popup frame define
+-- @tparam[opt] string name the optional debug name that can be added
+-- @treturn table the new popup frame define
+function PopupFrames.new_popup(name)
+	local self = Gui.new_define(PopupFrames._prototype,name)
+    self.draw_data.type = 'flow'
+	self.draw_data.direction = 'vertical'
+
+    local mt = getmetatable(self)
+    mt.__call = function(tbl,player,open_time,...)
+        return tbl:open(player,open_time,...)
+    end
+
+    self:on_draw(function(player,element,maximum,...)
+        -- main content frame
+		local frame = element.add{
+            type='flow',
+			name=PopupFrames.main_frame_name
+        }
+        frame.style.horizontally_stretchable = true
+
+        -- flow for progress bar and close button
+		local close_flow = element.add{
+            type='flow',
+			name=PopupFrames.close_frame_name
+        }
+        close_flow.style.horizontally_stretchable = true
+
+        -- progress bar, when 0 then a static full one is drawn
+        local progress_style
+        if maximum == 0 then
+            progress_style = close_flow.add{
+                type='progressbar',
+                tooltip='No Auto-close',
+                value=1
+            }.style
+        else
+            progress_style = PopupFrames.close_progress(close_flow,maximum).style
+        end
+        progress_style.top_padding = 6
+        progress_style.bottom_padding = 3
+        progress_style.height = 11
+        progress_style.color = Color.grey
+
+        -- close button, will close the popup when clicked
+        local close_button = PopupFrames.close_button(close_flow)
+        Gui.set_padding(close_button)
+        local close_button_style = close_button.style
+        close_button_style.width = 20
+        close_button_style.height = 20
+
+        -- event trigger to draw the gui content
+        self:raise_event('on_creation',player,frame,...)
+	end)
+
+	return self
+end
+
+--- Sets the default open time for the popup, will be used if non is provided with open
+-- @tparam number amount the number of ticks, by default, the popup will be open for
+-- @treturn table the define to allow for chaining
+function PopupFrames._prototype:set_default_open_time(amount)
+	self.default_open_time = amount
+	return self
+end
+
+--- Opens this define for a player, can be given open time and any other params for the draw function
+-- @tparam LuaPlayer player the player to open the popup for
+-- @tparam[opt] number open_time the minimum number of ticks you want the popup open for, 0 means no limit, nil will take default
+-- @tparam any ... the other params that you want to pass to your on_draw event
+-- @treturn LuaGuiElement the frame that was drawn, the inner gui flow which contains the content
+function PopupFrames._prototype:open(player,open_time,...)
+    open_time = open_time or self.default_open_time or 0
+    player = Game.get_player_from_any(player)
+
+    local flow = PopupFrames.get_flow(player)
+    local frame = flow.add{
+        type='frame',
+        style='blurry_frame'
+    }
+
+    Gui.set_padding(frame,3,3,4,4)
+    return self:draw_to(frame,open_time,...)[PopupFrames.main_frame_name]
+end
+
+--- When player is first created the popup flow is added to they left flow
+Event.add(defines.events.on_player_created,function(event)
+	local player = Game.get_player_by_index(event.player_index)
+	local flow = mod_gui.get_frame_flow(player)
+
+	flow.add{
+		type='flow',
+		direction='vertical',
+		name=PopupFrames.popup_flow_name
+    }
+end)
+
+--- Every tick any, not pasued, progress bars will go down by one tick
+Event.add(defines.events.on_tick,PopupFrames.close_progress:event_countdown(function(element)
+    return not get_pasued_state(element)
+end))
+
+return PopupFrames

expcore/gui/concepts/toolbar.lua

@@ -0,0 +1,106 @@
+--- Gui structure for the toolbar (top left)
+--[[
+>>>> Example format
+    -- this is the same as any other button define, this just automatically draws it
+    -- you can use add_button if you already defined the button
+    local toolbar_button =
+    Toolbar.new_button('print-click')
+    :on_click(function(player,_element)
+        player.print('You clicked a button!')
+    end)
+
+>>>> Functions
+    Toolbar.new_button(name) --- Adds a new button to the toolbar
+    Toolbar.add_button(button) --- Adds an existing buttton to the toolbar
+    Toolbar.update(player) --- Updates the player's toolbar with an new buttons or expected change in auth return
+]]
+local Gui = require 'expcore.gui.core'
+local Buttons = require 'expcore.gui.elements.buttons'
+local Roles = require 'expcore.roles'
+local Event = require 'utils.event'
+local Game = require 'utils.game'
+local mod_gui = require 'mod-gui'
+
+local Toolbar = {
+    permisison_names = {},
+    buttons = {}
+}
+
+function Toolbar.allowed(player,define_name)
+    local permisison_name = Toolbar.permisison_names[define_name] or define_name
+    return Roles.player_allowed(player,permisison_name)
+end
+
+function Toolbar.permission_alias(define_name,permisison_name)
+    Toolbar.permisison_names[define_name] = permisison_name
+end
+
+--- Adds a new button to the toolbar
+-- @tparam[opt] string name when given allows an alias to the button for the permission system
+-- @treturn table the button define
+function Toolbar.new_button(name)
+    local button =
+    Buttons.new_button()
+    :set_post_authenticator(Toolbar.allowed)
+    :set_style(mod_gui.button_style,function(style)
+        Gui.set_padding_style(style,-2,-2,-2,-2)
+    end)
+    Toolbar.add_button(button)
+    Toolbar.permission_alias(button.name,name)
+    return button
+end
+
+--- Adds an existing buttton to the toolbar
+-- @tparam table button the button define for the button to be added
+function Toolbar.add_button(button)
+    table.insert(Toolbar.buttons,button)
+    Gui.allow_player_to_toggle_top_element_visibility(button.name)
+    Gui.on_player_show_top(button.name,function(event)
+        if not button.post_authenticator(event.player,button.name) then
+            event.element.visible = false
+        end
+    end)
+    if not button.post_authenticator then
+        button:set_post_authenticator(function() return true end)
+    end
+end
+
+--- Updates the player's toolbar with an new buttons or expected change in auth return
+-- @tparam LuaPlayer player the player to update the toolbar for
+function Toolbar.update(player)
+    local top = Gui.get_top_element_flow(player)
+    if not top then return end
+    local visible = top[Gui.top_toggle_button_name].caption == '<'
+    for _,button in pairs(Toolbar.buttons) do
+        local element
+        if top[button.name] then element = top[button.name]
+        else element = button:draw_to(top) end
+        if button.post_authenticator(player,button.name) then
+            element.visible = visible
+            element.enabled = true
+        else
+            element.visible = false
+            element.enabled = false
+        end
+    end
+end
+
+--- When there is a new player they will have the toolbar update
+Event.add(defines.events.on_player_created,function(event)
+    local player = Game.get_player_by_index(event.player_index)
+    Toolbar.update(player)
+end)
+
+--- When a player gets a new role they will have the toolbar updated
+Event.add(Roles.events.on_role_assigned,function(event)
+    local player = Game.get_player_by_index(event.player_index)
+    Toolbar.update(player)
+end)
+
+--- When a player loses a role they will have the toolbar updated
+Event.add(Roles.events.on_role_unassigned,function(event)
+    local player = Game.get_player_by_index(event.player_index)
+    Toolbar.update(player)
+end)
+
+return Toolbar