minetest-mm/mods/smartfs/smartfs.lua

1536 lines
40 KiB
Lua
Raw Normal View History

2020-10-26 17:38:53 +01:00
---------------------------
-- SmartFS: Smart Formspecs
-- License: CC0 or WTFPL
-- by Rubenwardy
---------------------------
local smartfs = {
_fdef = {},
_edef = {},
_ldef = {},
opened = {},
inv = {}
}
local function boolToStr(v)
return v and "true" or "false"
end
-- the smartfs() function
function smartfs.__call(self, name)
return smartfs.get(name)
end
function smartfs.get(name)
return smartfs._fdef[name]
end
------------------------------------------------------
-- Smartfs Interface - Creates a new form and adds elements to it by running the function. Use before Minetest loads. (like minetest.register_node)
------------------------------------------------------
-- Register forms and elements
function smartfs.create(name, onload)
assert(not smartfs._fdef[name],
"SmartFS - (Error) Form "..name.." already exists!")
assert(not smartfs.loaded or smartfs._loaded_override,
"SmartFS - (Error) Forms should be declared while the game loads.")
smartfs._fdef[name] = {
form_setup_callback = onload,
name = name,
show = smartfs._show_,
attach_to_node = smartfs._attach_to_node_
}
return smartfs._fdef[name]
end
------------------------------------------------------
-- Smartfs Interface - Creates a new element type
------------------------------------------------------
function smartfs.element(name, data)
assert(not smartfs._edef[name],
"SmartFS - (Error) Element type "..name.." already exists!")
assert(data.onCreate, "element requires onCreate method")
smartfs._edef[name] = data
return smartfs._edef[name]
end
------------------------------------------------------
-- Smartfs Interface - Creates a dynamic form. Returns state
------------------------------------------------------
function smartfs.dynamic(name,player)
if not smartfs._dynamic_warned then
smartfs._dynamic_warned = true
minetest.log("warning", "SmartFS - (Warning) On the fly forms are being used. May cause bad things to happen")
end
local statelocation = smartfs._ldef.player._make_state_location_(player)
local state = smartfs._makeState_({name=name}, nil, statelocation, player)
smartfs.opened[player] = state
return state
end
------------------------------------------------------
-- Smartfs Interface - Returns the name of an installed and supported inventory mod that will be used above, or nil
------------------------------------------------------
function smartfs.inventory_mod()
if minetest.global_exists("unified_inventory") then
return "unified_inventory"
elseif minetest.global_exists("inventory_plus") then
return "inventory_plus"
elseif minetest.global_exists("sfinv") then
return "sfinv"
else
return nil
end
end
------------------------------------------------------
-- Smartfs Interface - Adds a form to an installed advanced inventory. Returns true on success.
------------------------------------------------------
function smartfs.add_to_inventory(form, icon, title, show_inv)
local ldef
local invmod = smartfs.inventory_mod()
if invmod then
ldef = smartfs._ldef[invmod]
else
return false
end
return ldef.add_to_inventory(form, icon, title, (show_inv == nil) and true or show_inv)
end
------------------------------------------------------
-- Smartfs Interface - Set the form as players inventory
------------------------------------------------------
function smartfs.set_player_inventory(form)
smartfs._ldef.inventory.set_inventory(form)
end
------------------------------------------------------
-- Smartfs Interface - Allows you to use smartfs.create after the game loads. Not recommended!
------------------------------------------------------
function smartfs.override_load_checks()
smartfs._loaded_override = true
end
------------------------------------------------------
-- Smartfs formspec locations
------------------------------------------------------
-- Unified inventory plugin
smartfs._ldef.unified_inventory = {
add_to_inventory = function(form, icon, title, show_inv)
unified_inventory.register_button(form.name, {
type = "image",
image = icon,
})
unified_inventory.register_page(form.name, {
get_formspec = function(player, formspec)
local name = player:get_player_name()
local state
if smartfs.inv[name] and smartfs.inv[name].def.name == form.name then
state = smartfs.inv[name]
else
local statelocation = smartfs._ldef.unified_inventory._make_state_location_(name)
state = smartfs._makeState_(form, nil, statelocation, name)
if form.form_setup_callback(state) ~= false then
smartfs.inv[name] = state
else
smartfs.inv[name] = nil
return ""
end
end
return {formspec = state:_buildFormspec_(false), draw_inventory = show_inv}
end
})
end,
_make_state_location_ = function(player)
return {
type = "inventory",
player = player,
_show_ = function(state)
unified_inventory.set_inventory_formspec(minetest.get_player_by_name(state.location.player), state.def.name)
end
}
end
}
-- Inventory plus plugin
smartfs._ldef.inventory_plus = {
add_to_inventory = function(form, icon, title)
minetest.register_on_joinplayer(function(player)
inventory_plus.register_button(player, form.name, title)
end)
minetest.register_on_player_receive_fields(function(player, formname, fields)
if formname == "" and fields[form.name] then
local name = player:get_player_name()
local statelocation = smartfs._ldef.inventory_plus._make_state_location_(name)
local state = smartfs._makeState_(form, nil, statelocation, name)
if form.form_setup_callback(state) ~= false then
smartfs.inv[name] = state
state:show()
end
end
end)
end,
_make_state_location_ = function(player)
return {
type = "inventory",
player = player,
_show_ = function(state)
inventory_plus.set_inventory_formspec(minetest.get_player_by_name(state.location.player), state:_buildFormspec_(true))
end
}
end
}
-- Sfinv plugin
smartfs._ldef.sfinv = {
add_to_inventory = function(form, icon, title, show_inv)
sfinv.register_page(form.name, {
title = title,
get = function(self, player, context)
local name = player:get_player_name()
local state
if smartfs.inv[name] then
state = smartfs.inv[name]
else
local statelocation = smartfs._ldef.sfinv._make_state_location_(name)
state = smartfs._makeState_(form, nil, statelocation, name)
smartfs.inv[name] = state
if form.form_setup_callback(state) ~= false then
smartfs.inv[name] = state
else
return ""
end
end
local fs = state:_buildFormspec_(false)
return sfinv.make_formspec(player, context, fs, show_inv)
end,
on_player_receive_fields = function(self, player, _, fields)
local name = player:get_player_name()
if smartfs.inv[name] then
smartfs.inv[name]:_sfs_on_receive_fields_(name, fields)
end
end,
on_leave = function(self, player)
local name = player:get_player_name()
if smartfs.inv[name] then
smartfs.inv[name].players:disconnect(name)
smartfs.inv[name] = nil
end
end,
})
end,
_make_state_location_ = function(player)
return {
type = "inventory",
inventory_handles_fields = true,
player = player,
_show_ = function(state)
sfinv.set_player_inventory_formspec(minetest.get_player_by_name(state.location.player))
end,
}
end
}
-- Show to player
smartfs._ldef.player = {
_make_state_location_ = function(player)
return {
type = "player",
player = player,
_show_ = function(state)
if not state._show_queued then
state._show_queued = true
minetest.after(0, function(state)
if state then
state._show_queued = nil
if (not state.closed) and (not state.obsolete) then
minetest.show_formspec(state.location.player, state.def.name, state:_buildFormspec_(true))
end
end
end, state) -- state given as reference. Maybe additional updates are done in the meantime or the form is obsolete
end
end
}
end
}
-- Standalone inventory
smartfs._ldef.inventory = {
set_inventory = function(form)
if sfinv and sfinv.enabled then
sfinv.enabled = nil
end
minetest.register_on_joinplayer(function(player)
local name = player:get_player_name()
local statelocation = smartfs._ldef.inventory._make_state_location_(name)
local state = smartfs._makeState_(form, nil, statelocation, name)
if form.form_setup_callback(state) ~= false then
smartfs.inv[name] = state
state:show()
end
end)
minetest.register_on_leaveplayer(function(player)
local name = player:get_player_name()
smartfs.inv[name].obsolete = true
smartfs.inv[name] = nil
end)
end,
_make_state_location_ = function(name)
return {
type = "inventory",
player = name,
_show_ = function(state)
if not state._show_queued then
state._show_queued = true
minetest.after(0, function(state)
if state then
state._show_queued = nil
local player = minetest.get_player_by_name(state.location.player)
--print("smartfs formspec:", state:_buildFormspec_(true))
player:set_inventory_formspec(state:_buildFormspec_(true))
end
end, state)
end
end
}
end
}
-- Node metadata
smartfs._ldef.nodemeta = {
_make_state_location_ = function(nodepos)
return {
type = "nodemeta",
pos = nodepos,
_show_ = function(state)
if not state._show_queued then
state._show_queued = true
minetest.after(0, function(state)
if state then
state._show_queued = nil
local meta = minetest.get_meta(state.location.pos)
meta:set_string("formspec", state:_buildFormspec_(true))
meta:set_string("smartfs_name", state.def.name)
meta:mark_as_private("smartfs_name")
end
end, state)
end
end,
}
end
}
-- Sub-container (internally used)
smartfs._ldef.container = {
_make_state_location_ = function(element)
local self = {
type = "container",
containerElement = element,
parentState = element.root
}
if self.parentState.location.type == "container" then
self.rootState = self.parentState.location.rootState
else
self.rootState = self.parentState
end
return self
end
}
------------------------------------------------------
-- Minetest Interface - on_receive_fields callback can be used in minetest.register_node for nodemeta forms
------------------------------------------------------
function smartfs.nodemeta_on_receive_fields(nodepos, formname, fields, sender, params)
local meta = minetest.get_meta(nodepos)
local nodeform = meta:get_string("smartfs_name")
if not nodeform then
print("SmartFS - (Warning) smartfs.nodemeta_on_receive_fields for node without smarfs data")
return false
end
-- get the currentsmartfs state
local opened_id = minetest.pos_to_string(nodepos)
local state
local form = smartfs.get(nodeform)
if not smartfs.opened[opened_id] or -- If opened first time
smartfs.opened[opened_id].def.name ~= nodeform or -- Or form is changed
smartfs.opened[opened_id].obsolete then
local statelocation = smartfs._ldef.nodemeta._make_state_location_(nodepos)
state = smartfs._makeState_(form, params, statelocation)
if smartfs.opened[opened_id] then
smartfs.opened[opened_id].obsolete = true
end
smartfs.opened[opened_id] = state
form.form_setup_callback(state)
else
state = smartfs.opened[opened_id]
end
-- Set current sender check for multiple users on node
local name
if sender then
name = sender:get_player_name()
state.players:connect(name)
end
-- take the input
state:_sfs_on_receive_fields_(name, fields)
-- Reset form if all players disconnected
if sender and not state.players:get_first() and not state.obsolete then
local statelocation = smartfs._ldef.nodemeta._make_state_location_(nodepos)
local resetstate = smartfs._makeState_(form, params, statelocation)
if form.form_setup_callback(resetstate) ~= false then
resetstate:show()
end
smartfs.opened[opened_id] = nil
end
end
------------------------------------------------------
-- Minetest Interface - on_player_receive_fields callback in case of inventory or player
------------------------------------------------------
minetest.register_on_player_receive_fields(function(player, formname, fields)
local name = player:get_player_name()
if smartfs.opened[name] and smartfs.opened[name].location.type == "player" then
if smartfs.opened[name].def.name == formname then
local state = smartfs.opened[name]
state:_sfs_on_receive_fields_(name, fields)
-- disconnect player if form closed
if not state.players:get_first() then
smartfs.opened[name].obsolete = true
smartfs.opened[name] = nil
end
end
elseif smartfs.inv[name] and smartfs.inv[name].location.type == "inventory" and not smartfs.inv[name].location.inventory_handles_fields then
local state = smartfs.inv[name]
state:_sfs_on_receive_fields_(name, fields)
end
return false
end)
------------------------------------------------------
-- Minetest Interface - Notify loading of smartfs is done
------------------------------------------------------
minetest.after(0, function()
smartfs.loaded = true
end)
------------------------------------------------------
-- Form Interface [linked to form:show()] - Shows the form to a player
------------------------------------------------------
function smartfs._show_(form, name, params)
assert(form)
assert(type(name) == "string", "smartfs: name needs to be a string")
assert(minetest.get_player_by_name(name), "player does not exist")
local statelocation = smartfs._ldef.player._make_state_location_(name)
local state = smartfs._makeState_(form, params, statelocation, name)
if form.form_setup_callback(state) ~= false then
if smartfs.opened[name] then -- set maybe previous form to obsolete
smartfs.opened[name].obsolete = true
end
smartfs.opened[name] = state
state:show()
end
return state
end
------------------------------------------------------
-- Form Interface [linked to form:attach_to_node()] - Attach a formspec to a node meta
------------------------------------------------------
function smartfs._attach_to_node_(form, nodepos, params)
assert(form)
assert(nodepos and nodepos.x)
local statelocation = smartfs._ldef.nodemeta._make_state_location_(nodepos)
local state = smartfs._makeState_(form, params, statelocation)
if form.form_setup_callback(state) ~= false then
local opened_id = minetest.pos_to_string(nodepos)
if smartfs.opened[opened_id] then -- set maybe previous form to obsolete
smartfs.opened[opened_id].obsolete = true
end
state:show()
end
return state
end
------------------------------------------------------
-- Smartfs Framework - Element class Methods
------------------------------------------------------
local element_class = {}
local element_class_mt = { __index = element_class }
function element_class:remove()
self.root._ele[self.name] = nil
end
function element_class:setPosition(x,y)
self.data.pos = {x=x,y=y}
end
function element_class:getPosition()
return self.data.pos
end
function element_class:setSize(w,h)
self.data.size = {w=w,h=h}
end
function element_class:getSize()
return self.data.size
end
function element_class:setVisible(visible)
if visible == nil then
self.data.visible = true
else
self.data.visible = visible
end
end
function element_class:getVisible()
return self.data.visible
end
function element_class:getAbsName()
return self.root:getNamespace()..self.name
end
function element_class:setBackground(image)
self.data.background = image
end
function element_class:getBackground()
return self.data.background
end
function element_class:getBackgroundString()
if self.data.background then
local size = self:getSize()
if size then
return "background["..
self.data.pos.x..","..self.data.pos.y..";"..
size.w..","..size.h..";"..
self.data.background.."]"
else
return ""
end
else
return ""
end
end
function element_class:setValue(value)
self.data.value = value
end
function element_class:setTooltip(text)
self.data.tooltip = minetest.formspec_escape(text)
end
function element_class:getTooltip()
return self.data.tooltip
end
function element_class:getTooltipString()
if self.data.tooltip then
return "tooltip["..self:getAbsName()..";"..self:getTooltip().."]"
else
return ""
end
end
------------------------------------------------------
-- Smartfs Framework - State class Methods
------------------------------------------------------
local state_class = {}
local state_class_mt = { __index = state_class }
function state_class:get(name)
return self._ele[name]
end
function state_class:close()
self.closed = true
end
function state_class:getSize()
return self._size
end
function state_class:size(w,h)
self._size = {w=w,h=h}
end
state_class.setSize = state_class.size
function state_class:getNamespace()
local ref = self
local namespace = ""
while ref.location.type == "container" do
namespace = ref.location.containerElement.name.."#"..namespace
ref = ref.location.parentState -- step near to the root
end
return namespace
end
function state_class:_buildFormspec_(size)
local res = ""
if self._size and size then
res = "size["..self._size.w..","..self._size.h.."]"
end
for key,val in pairs(self._ele) do
if val:getVisible() then
res = res .. val:getBackgroundString() .. val:build() .. val:getTooltipString()
end
end
return res
end
function state_class:_get_element_recursive_(field)
local topfield
for z in field:gmatch("[^#]+") do
topfield = z
break
end
local element = self._ele[topfield]
if element and field == topfield then
return element
elseif element then
if element._getSubElement_ then
local rel_field = string.sub(field, string.len(topfield)+2)
return element:_getSubElement_(rel_field)
else
return element
end
else
return nil
end
end
-- process onInput hook for the state
function state_class:_sfs_process_oninput_(fields, player)
if self._onInput then
self:_onInput(fields, player)
end
-- recursive all onInput hooks on visible containers
for elename, eledef in pairs(self._ele) do
if eledef.getContainerState and eledef:getVisible() then
eledef:getContainerState():_sfs_process_oninput_(fields, player)
end
end
end
-- Receive fields and actions from formspec
function state_class:_sfs_on_receive_fields_(player, fields)
local fields_todo = {}
for field, value in pairs(fields) do
local element = self:_get_element_recursive_(field)
if element then
fields_todo[field] = { element = element, value = value }
end
end
for field, todo in pairs(fields_todo) do
todo.element:setValue(todo.value)
end
self:_sfs_process_oninput_(fields, player)
for field, todo in pairs(fields_todo) do
if todo.element.submit then
todo.element:submit(todo.value, player)
end
end
-- handle key_enter
if fields.key_enter and fields.key_enter_field then
local element = self:_get_element_recursive_(fields.key_enter_field)
if element and element.submit_key_enter then
element:submit_key_enter(fields[fields.key_enter_field], player)
end
end
if not fields.quit and not self.closed and not self.obsolete then
self:show()
else
self.players:disconnect(player)
if not fields.quit and self.closed and not self.obsolete then
--closed by application (without fields.quit). currently not supported, see: https://github.com/minetest/minetest/pull/4675
minetest.show_formspec(player,"","size[5,1]label[0,0;Formspec closing not yet created!]")
end
end
return true
end
function state_class:onInput(func)
self._onInput = func -- (fields, player)
end
function state_class:load(file)
local file = io.open(file, "r")
if file then
local table = minetest.deserialize(file:read("*all"))
if type(table) == "table" then
if table.size then
self._size = table.size
end
for key,val in pairs(table.ele) do
self:element(val.type,val)
end
return true
end
end
return false
end
function state_class:save(file)
local res = {ele={}}
if self._size then
res.size = self._size
end
for key,val in pairs(self._ele) do
res.ele[key] = val.data
end
local file = io.open(file, "w")
if file then
file:write(minetest.serialize(res))
file:close()
return true
end
return false
end
function state_class:setparam(key,value)
if not key then return end
self.param[key] = value
return true
end
function state_class:getparam(key,default)
if not key then return end
return self.param[key] or default
end
function state_class:element(typen,data)
local type = smartfs._edef[typen]
assert(type, "Element type "..typen.." does not exist!")
assert(not self._ele[data.name], "Element "..data.name.." already exists")
local ele = setmetatable({}, element_class_mt)
ele.name = data.name
ele.root = self
ele.data = data
ele.data.type = typen
ele.data.visible = true
for key, val in pairs(type) do
ele[key] = val
end
self._ele[data.name] = ele
type.onCreate(ele)
return self._ele[data.name]
end
------------------------------------------------------
-- Smartfs Framework - State class Methods - Build time only
------------------------------------------------------
function state_class:button(x, y, w, h, name, text, exitf)
return self:element("button", {
pos = {x=x,y=y},
size = {w=w,h=h},
name = name,
value = text,
closes = exitf or false
})
end
function state_class:image_button(x, y, w, h, name, text, image, exitf)
return self:element("button", {
pos = {x=x,y=y},
size = {w=w,h=h},
name = name,
value = text,
image = image,
closes = exitf or false
})
end
function state_class:item_image_button(x, y, w, h, name, text, item, exitf)
return self:element("button", {
pos = {x=x,y=y},
size = {w=w,h=h},
name = name,
value = text,
item = item,
closes = exitf or false
})
end
function state_class:label(x, y, name, text)
return self:element("label", {
pos = {x=x,y=y},
name = name,
value = text,
vertical = false
})
end
function state_class:vertlabel(x, y, name, text)
return self:element("label", {
pos = {x=x,y=y},
name = name,
value = text,
vertical = true
})
end
function state_class:toggle(x, y, w, h, name, list)
return self:element("toggle", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
id = 1,
list = list
})
end
function state_class:field(x, y, w, h, name, label)
return self:element("field", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
value = "",
label = label
})
end
function state_class:pwdfield(x, y, w, h, name, label)
local res = self:element("field", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
value = "",
label = label
})
res:isPassword(true)
return res
end
function state_class:textarea(x, y, w, h, name, label)
local res = self:element("field", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
value = "",
label = label
})
res:isMultiline(true)
return res
end
function state_class:image(x, y, w, h, name, img)
return self:element("image", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
value = img,
imgtype = "image"
})
end
function state_class:background(x, y, w, h, name, img)
return self:element("image", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
background = img,
imgtype = "background"
})
end
function state_class:item_image(x, y, w, h, name, img)
return self:element("image", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
value = img,
imgtype = "item"
})
end
function state_class:checkbox(x, y, name, label, selected)
return self:element("checkbox", {
pos = {x=x, y=y},
name = name,
value = selected,
label = label
})
end
function state_class:listbox(x, y, w, h, name, selected, transparent)
return self:element("list", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
selected = selected,
transparent = transparent
})
end
function state_class:dropdown(x, y, w, h, name, selected)
return self:element("dropdown", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name,
selected = selected
})
end
function state_class:inventory(x, y, w, h, name)
return self:element("inventory", {
pos = {x=x, y=y},
size = {w=w, h=h},
name = name
})
end
function state_class:container(x, y, name, relative)
return self:element("container", {
pos = {x=x, y=y},
name = name,
relative = false
})
end
function state_class:view(x, y, name, relative)
return self:element("container", {
pos = {x=x, y=y},
name = name,
relative = true
})
end
------------------------------------------------------
-- Smartfs Framework - create a form object (state)
------------------------------------------------------
function smartfs._makeState_(form, params, location, newplayer)
------------------------------------------------------
-- State - -- Object to manage players
------------------------------------------------------
local function _make_players_(newplayer)
local self = {
_list = {}
}
function self.connect(self, player)
self._list[player] = true
end
function self.disconnect(self, player)
self._list[player] = nil
end
function self.get_first(self)
return next(self._list)
end
if newplayer then
self:connect(newplayer)
end
return self
end
local state = {
_ele = {},
def = form,
players = _make_players_(newplayer),
location = location,
is_inv = (location.type == "inventory"), -- obsolete. Please use location.type="inventory" instead
player = newplayer, -- obsolete. Please use location.player
param = params or {},
show = location._show_,
}
return setmetatable(state, state_class_mt)
end
-----------------------------------------------------------------
------------------------- ELEMENTS ----------------------------
-----------------------------------------------------------------
smartfs.element("button", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "button needs valid pos")
assert(self.data.size and self.data.size.w and self.data.size.h, "button needs valid size")
assert(self.name, "button needs name")
assert(self.data.value, "button needs label")
end,
build = function(self)
local specstring
if self.data.image then
if self.data.closes then
specstring = "image_button_exit["
else
specstring = "image_button["
end
elseif self.data.item then
if self.data.closes then
specstring = "item_image_button_exit["
else
specstring = "item_image_button["
end
else
if self.data.closes then
specstring = "button_exit["
else
specstring = "button["
end
end
specstring = specstring ..
self.data.pos.x..","..self.data.pos.y..";"..
self.data.size.w..","..self.data.size.h..";"
if self.data.image then
specstring = specstring..minetest.formspec_escape(self.data.image)..";"
elseif self.data.item then
specstring = specstring..self.data.item..";"
end
specstring = specstring..self:getAbsName()..";"..
minetest.formspec_escape(self.data.value).."]"
return specstring
end,
submit = function(self, field, player)
if self._click then
self:_click(self.root, player)
end
end,
onClick = function(self,func)
self._click = func
end,
click = function(self,func)
self._click = func
end,
setText = function(self,text)
self:setValue(text)
end,
getText = function(self)
return self.data.value
end,
setImage = function(self,image)
self.data.image = image
self.data.item = nil
end,
getImage = function(self)
return self.data.image
end,
setItem = function(self,item)
self.data.item = item
self.data.image = nil
end,
getItem = function(self)
return self.data.item
end,
setClose = function(self,bool)
self.data.closes = bool
end,
getClose = function(self)
return self.data.closes or false
end
})
smartfs.element("toggle", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "toggle needs valid pos")
assert(self.data.size and self.data.size.w and self.data.size.h, "toggle needs valid size")
assert(self.name, "toggle needs name")
assert(self.data.list, "toggle needs data")
end,
build = function(self)
return "button["..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
self:getAbsName()..
";"..
minetest.formspec_escape(self.data.list[self.data.id])..
"]"
end,
submit = function(self, field, player)
self.data.id = self.data.id + 1
if self.data.id > #self.data.list then
self.data.id = 1
end
if self._tog then
self:_tog(self.root, player)
end
end,
onToggle = function(self,func)
self._tog = func
end,
setId = function(self,id)
self.data.id = id
end,
getId = function(self)
return self.data.id
end,
getText = function(self)
return self.data.list[self.data.id]
end
})
smartfs.element("label", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "label needs valid pos")
assert(self.data.value, "label needs text")
end,
build = function(self)
local specstring
if self.data.vertical then
specstring = "vertlabel["
else
specstring = "label["
end
return specstring..
self.data.pos.x..","..self.data.pos.y..
";"..
minetest.formspec_escape(self.data.value)..
"]"
end,
setText = function(self,text)
self:setValue(text)
end,
getText = function(self)
return self.data.value
end
})
smartfs.element("field", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "field needs valid pos")
assert(self.data.size and self.data.size.w and self.data.size.h, "field needs valid size")
assert(self.name, "field needs name")
self.data.value = self.data.value or ""
self.data.label = self.data.label or ""
end,
build = function(self)
if self.data.ml then
return "textarea["..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
self:getAbsName()..
";"..
minetest.formspec_escape(self.data.label)..
";"..
minetest.formspec_escape(self.data.value)..
"]"
elseif self.data.pwd then
return "pwdfield["..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
self:getAbsName()..
";"..
minetest.formspec_escape(self.data.label)..
"]"..
self:getCloseOnEnterString()
else
return "field["..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
self:getAbsName()..
";"..
minetest.formspec_escape(self.data.label)..
";"..
minetest.formspec_escape(self.data.value)..
"]"..
self:getCloseOnEnterString()
end
end,
setText = function(self,text)
self:setValue(text)
end,
getText = function(self)
return self.data.value
end,
isPassword = function(self,bool)
self.data.pwd = bool
end,
isMultiline = function(self,bool)
self.data.ml = bool
end,
getCloseOnEnterString = function(self)
if self.close_on_enter == nil then
return ""
else
return "field_close_on_enter["..self:getAbsName()..";"..tostring(self.close_on_enter).."]"
end
end,
setCloseOnEnter = function(self, value)
self.close_on_enter = value
end,
getCloseOnEnter = function(self)
return self.close_on_enter
end,
submit_key_enter = function(self, field, player)
if self._key_enter then
self:_key_enter(self.root, player)
end
end,
onKeyEnter = function(self,func)
self._key_enter = func
end,
})
smartfs.element("image", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "image needs valid pos")
assert(self.data.size and self.data.size.w and self.data.size.h, "image needs valid size")
self.data.value = self.data.value or ""
end,
build = function(self)
if self.data.imgtype == "background" then
return "" -- handled in _buildFormspec_ trough getBackgroundString()
elseif self.data.imgtype == "item" then
return "item_image["..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
minetest.formspec_escape(self.data.value)..
"]"
else
return "image["..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
minetest.formspec_escape(self.data.value)..
"]"
end
end,
setImage = function(self,text)
if self.data.imgtype == "background" then
self.data.background = text
else
self:setValue(text)
end
end,
getImage = function(self)
if self.data.imgtype == "background" then
return self.data.background
else
return self.data.value
end
end
})
smartfs.element("checkbox", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "checkbox needs valid pos")
assert(self.name, "checkbox needs name")
self.data.value = minetest.is_yes(self.data.value)
self.data.label = self.data.label or ""
end,
build = function(self)
return "checkbox["..
self.data.pos.x..","..self.data.pos.y..
";"..
self:getAbsName()..
";"..
minetest.formspec_escape(self.data.label)..
";" .. boolToStr(self.data.value) .."]"
end,
submit = function(self, field, player)
-- call the toggle function if defined
if self._tog then
self:_tog(self.root, player)
end
end,
setValue = function(self, value)
self.data.value = minetest.is_yes(value)
end,
getValue = function(self)
return self.data.value
end,
onToggle = function(self,func)
self._tog = func
end,
})
smartfs.element("list", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "list needs valid pos")
assert(self.data.size and self.data.size.w and self.data.size.h, "list needs valid size")
assert(self.name, "list needs name")
self.data.value = minetest.is_yes(self.data.value)
self.data.items = self.data.items or {}
end,
build = function(self)
if not self.data.items then
self.data.items = {}
end
return "textlist["..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
self:getAbsName()..
";"..
table.concat(self.data.items, ",")..
";"..
tostring(self.data.selected or "")..
";"..
tostring(self.data.transparent or "false").."]"
end,
submit = function(self, field, player)
local _type = string.sub(field,1,3)
local index = tonumber(string.sub(field,5))
self.data.selected = index
if _type == "CHG" and self._click then
self:_click(self.root, index, player)
elseif _type == "DCL" and self._doubleClick then
self:_doubleClick(self.root, index, player)
end
end,
onClick = function(self, func)
self._click = func
end,
click = function(self, func)
self._click = func
end,
onDoubleClick = function(self, func)
self._doubleClick = func
end,
doubleclick = function(self, func)
self._doubleClick = func
end,
addItem = function(self, item)
table.insert(self.data.items, minetest.formspec_escape(item))
-- return the index of item. It is the last one
return #self.data.items
end,
removeItem = function(self,idx)
table.remove(self.data.items,idx)
end,
getItem = function(self, idx)
return self.data.items[idx]
end,
popItem = function(self)
local item = self.data.items[#self.data.items]
table.remove(self.data.items)
return item
end,
clearItems = function(self)
self.data.items = {}
end,
setSelected = function(self,idx)
self.data.selected = idx
end,
getSelected = function(self)
return self.data.selected
end,
getSelectedItem = function(self)
return self:getItem(self:getSelected())
end,
})
smartfs.element("dropdown", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "dropdown needs valid pos")
assert(self.data.size and self.data.size.w and self.data.size.h, "dropdown needs valid size")
assert(self.name, "dropdown needs name")
self.data.items = self.data.items or {}
self.data.selected = self.data.selected or 1
self.data.value = ""
end,
build = function(self)
return "dropdown["..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
self:getAbsName()..
";"..
table.concat(self.data.items, ",")..
";"..
tostring(self:getSelected())..
"]"
end,
submit = function(self, field, player)
self:getSelected()
if self._select then
self:_select(self.root, field, player)
end
end,
onSelect = function(self, func)
self._select = func
end,
addItem = function(self, item)
table.insert(self.data.items, item)
if #self.data.items == self.data.selected then
self.data.value = item
end
-- return the index of item. It is the last one
return #self.data.items
end,
removeItem = function(self,idx)
table.remove(self.data.items,idx)
end,
getItem = function(self, idx)
return self.data.items[idx]
end,
popItem = function(self)
local item = self.data.items[#self.data.items]
table.remove(self.data.items)
return item
end,
clearItems = function(self)
self.data.items = {}
end,
setSelected = function(self,idx)
self.data.selected = idx
self.data.value = self:getItem(idx) or ""
end,
getSelected = function(self)
self.data.selected = 1
if #self.data.items > 1 then
for i = 1, #self.data.items do
if self.data.items[i] == self.data.value then
self.data.selected = i
end
end
end
return self.data.selected
end,
getSelectedItem = function(self)
return self.data.value
end,
})
smartfs.element("inventory", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "list needs valid pos")
assert(self.data.size and self.data.size.w and self.data.size.h, "list needs valid size")
assert(self.name, "list needs name")
-- Default the list name to the element name.
self.data.list = self.name
end,
build = function(self)
return "list["..
(self.data.invlocation or "current_player") ..
";"..
self.data.list ..
";"..
self.data.pos.x..","..self.data.pos.y..
";"..
self.data.size.w..","..self.data.size.h..
";"..
(self.data.index or "") ..
"]"
end,
-- available inventory locations
-- "current_player": Player to whom the menu is shown
-- "player:<name>": Any player
-- "nodemeta:<X>,<Y>,<Z>": Any node metadata
-- "detached:<name>": A detached inventory
-- "context" does not apply to smartfs, since there is no node-metadata as context available
setLocation = function(self,invlocation)
self.data.invlocation = invlocation
end,
getLocation = function(self)
return self.data.invlocation or "current_player"
end,
usePosition = function(self, pos)
self.data.invlocation = string.format("nodemeta:%d,%d,%d", pos.x, pos.y, pos.z)
end,
usePlayer = function(self, name)
self.data.invlocation = "player:" .. name
end,
useDetached = function(self, name)
self.data.invlocation = "detached:" .. name
end,
setList = function(self, list)
self.data.list = list or self.name
end,
getList = function(self)
return self.data.list
end,
setIndex = function(self,index)
self.data.index = index
end,
getIndex = function(self)
return self.data.index
end
})
smartfs.element("code", {
onCreate = function(self)
self.data.code = self.data.code or ""
end,
build = function(self)
if self._build then
self:_build()
end
return self.data.code
end,
submit = function(self, field, player)
if self._sub then
self:_sub(self.root, field, player)
end
end,
onSubmit = function(self,func)
self._sub = func
end,
onBuild = function(self,func)
self._build = func
end,
setCode = function(self,code)
self.data.code = code
end,
getCode = function(self)
return self.data.code
end
})
smartfs.element("container", {
onCreate = function(self)
assert(self.data.pos and self.data.pos.x and self.data.pos.y, "container needs valid pos")
assert(self.name, "container needs name")
local statelocation = smartfs._ldef.container._make_state_location_(self)
self._state = smartfs._makeState_(nil, self.root.param, statelocation)
end,
-- redefinitions. The size is not handled by data.size but by container-state:size
setSize = function(self,w,h)
self:getContainerState():setSize(w,h)
end,
getSize = function(self)
return self:getContainerState():getSize()
end,
-- element interface methods
build = function(self)
if self.data.relative ~= true then
return "container["..self.data.pos.x..","..self.data.pos.y.."]"..
self:getContainerState():_buildFormspec_(false)..
"container_end[]"
else
return self:getContainerState():_buildFormspec_(false)
end
end,
getContainerState = function(self)
return self._state
end,
_getSubElement_ = function(self, field)
return self:getContainerState():_get_element_recursive_(field)
end,
})
return smartfs