XFC Test Build: v0.0.3 Build: 1

1aTabOrder

XFC Tab Order Version: 0.0.3
------------------------------
This file should not be included in the Codea project.
#Main
#XFC000
#XFC001_history
#XFC005_autoinstall
#XFC010_MenuItem
#XFC011_ChoiceItem
#XFC011_LinkItem
#XFC011_yesNoMenu
#XFC012_InfoItem
#XFC013_DocItem1
#XFC013_InfoBox
#XFC014_DocItem2
#XFC015_FIleIO
#XFC016_DownloadItem
#XFC017_UploadItem
#XFC018_RemoveItem
#XFC019_downloadList
#XFC021_FunctionItem
#XFC030_unitTests
#XFC031_functionsMenu
#XFC032_linksMenu
#XFC033_settingsMenu
#XFC050_Menu

Main.lua

-- main
--VERSION = "X.X.X" -- Use this to set Version Numbers Or set Version in class creation
--PROJECTNAME = "Your project Name"
--BUILD = false -- Include this Global if you want a separate Gist for builds *true* creates a build gist

VERSION = "0.0.3" 
PROJECTNAME = "XFC" --Do not change this, your project should be named AutoGist
BUILD = true
        --If Build is true version number is ignored and a Private gist is created for builds
        --If Build is false or nil the Version checks for a Release gist update
PUBLIC = false
        -- Create a public Gist = true, private gist is false
        
function setup()
VersionUpdateChecker.check()


--    if XFC then XFC.init() end     -- dont change this line!

    
    --create an instance of AutoGist
    --Add this to the project that you would like to backup
    --@param ProjectName -- must match your project use PROJECTNAME at the top
    --@param Description of your project
    --@param version number. I like using a global VERSION at the top.
    --@param [true|false] true will add an update checker to the gist
    
    local autoGist = AutoGist(
        PROJECTNAME,
        "eXtensions For Codea",
        VERSION,
        BUILD)--Do not edit this one
 

    --This must be called to check for backups
     
    autoGist:backup(PUBLIC)

-- displayMode(FULLSCREEN)



    -- this is just an example:
    parameter.action("start loop to test wait",loop)
    -- end of example
end

function loop()
    -- function for tests
    --XFC.wait(1,loop)
    
    local ok,err = pcall( XFC.functions.wait,1,loop )
    if ok then 
        print("hello from XFC.wait fonction")
    else
        print("wait function not available")
    end
    
end

function draw()
    -- *** these lines just to simulate user background
    background(40, 40, 50)
    spriteMode(CENTER)
    sprite("Cargo Bot:Codea Icon",WIDTH/2,HEIGHT/2,WIDTH,HEIGHT)
    -- ***
--    if XFC then XFC.draw() end     -- dont change this line!
end

function touched(touch)
    -- put this line at the BEGINNING of your touched()
--    if XFC and XFC.touched(touch) then return end     -- dont change this line!
end






-----------------------------
--Update Checker Code added by AutoGist
-----------------------------
VersionUpdateChecker = {}
VersionUpdateChecker.gistURL = "https://api.github.com/gists/6218525"
VersionUpdateChecker.check = function()
    local jsonURL = "https://dl.dropboxusercontent.com/s/9e4nvqeu4hsux2q/Json.lua?token_hash=AAFyMB98j4bnt_1gawf9wSke52hsoC7hsIvARcTuZNeOEw&dl=1"
local jsonSuccess = function(data)
   local jsonCode = data
    if jsonCode then local l = loadstring(jsonCode) l() end
    local handleSuccess = function(data)
        local gist = json.decode(data)
        local version = string.match(gist.description,"%d+%.%d+%.%d+")
        if VERSION ~= version then 
        displayMode(STANDARD)
        print("Click Update_Project.")
        alert("New Update Availiable! Click Update.","Update")
        parameter.action("Update_Project",function() VersionUpdateChecker.GetProject() end)
        end    
    end
http.request(VersionUpdateChecker.gistURL,handleSuccess,function() print("Update Failed") end)     
end
http.request(jsonURL,jsonSuccess,function() print("Check Internet Connection") end)
end
function VersionUpdateChecker.GetProject()
   local handleSuccess = function(data,i,j)
        if listProjectTabs(PROJECTNAME) == nil then
            error("Check Project Name")
        end
        local gist = json.decode(data)
        local projName = PROJECTNAME
        if gist.files["1aTabOrder"] then
            print("***Tab Order Found***")
            local taborder = gist.files["1aTabOrder"].content
            local strStart =1
            local strEnd =0
            strStart = string.find(taborder,"#",strEnd)
            strEnd = string.find(taborder,"\n",strStart)
            while strStart do
                local tmp = string.sub(taborder,strStart+1,strEnd-1)
                local name = PROJECTNAME..":"..tmp
                tmp = tmp..".lua"
                saveProjectTab(name,gist.files[tmp].content)
                strStart = string.find(taborder,"#",strEnd)
                strEnd = string.find(taborder,"\n",strStart)
            end    
        else
            for k,v in pairs(gist.files) do
                local name = PROJECTNAME .. ":" .. string.gsub(k,".lua","")
                saveProjectTab(name, v.content)
            end
        end
        if gist.files["ChangeLog.lua"] then
            local str = gist.files["ChangeLog.lua"].content
            alert(str,"Version Notes")
        end
        sound(SOUND_PICKUP, 24058)
        print("Reload Project to finish update!")
    end
    http.request(VersionUpdateChecker.gistURL,handleSuccess,function(data) print("Update Failed") end)
end
--End of Update Checker
--------------------------------------------------

XFC000.lua

-- XFC
-- eXtensions For Codea

-- contibutors : contribution
--    @Jmv38 : project proposal - July 2013
--    @Briarfox : gist, documentation box.

-- this project is a library to find and import easily 
--    snippets, function, libraries or apps 
-- designed by the people of the forum, and that must be saved.

-- objectives:
--    provide the codea missing functions
--    compile those great forum posts
--    hopefuly become a 'must have' for every codea user project (mine too)

-- technical requirements:
--    not intrusive, minimal look, but nice
--    the simplest/easiest interface possible targetting the occasionnal programmer /newbee
--    updates are managed by the code, like in the appstore
--    requested code is copied into the requesting project 
--        (no dependencies needed in the finished version of the code)
--    the user doesnt have to think about it (similar to built-in codea functions)
--    clean code: no globals created, good fps, low memory load, clear code.
--    documentation included, codea-alike if possible
--    adding / updating snippets for the XFC developpers is easy
--    (maybe) access the code via a web server to monitor and share activity
--    (maybe) collaborative additions possible, with or w/o a control board approval.



-- only global variable

XFC = {}
XFC.remove = {}
XFC.tabInit = {}
XFC.tabs = {} -- all tabs here
XFC.developper = false
    
XFC.init = function()
    XFC.main = XFC.menu.root()
    --XFC.functions = XFC.Functions()
end

XFC.draw = function()
    XFC.main:draw()
end

XFC.touched = function(touch)
    local touchIntercepted = XFC.main:touched(touch)
    return touchIntercepted
end
    
    
    

XFC001_history.lua

--[[

HISTORY OF CHANGES

------------------
still to be done
------------------

- prototype a runnable example (in function doc)
- make the doc sections scrollable? (to use the runnable example in the doc)
- then add a cross top right to close the box (touch should not close)
- functions submenu: all gist url stored in one tab?
- check for XFC updates
- check for content updates (new functions)
- count installed tabs that changed => red pastilla
- count new tabs => green pastllia
- each tab has a version number
- each content tab has an install function
- each content tab has an uninstall function
- tab list is managed
- how to have several solutions for one function?
- how to show several versions of one function? std,beta
- how to check how many installs? update checks? (monitor user activity)
- make a link to XFC user requests / feedback

------------------
version 0.0.3
------------------
- autoinstall in a project with just dependancy check to XFC
- decide what to put in minimal proto
------------------
version 0.0.2
------------------
- make first version of a function template
- make a clean menu item class
- make function question - yes - no
- introduce developper only permissions (for upload for instance)
------------------
version 0.0.1
------------------
- install autogist inside XFC 

------------------
version 0.0.0
------------------
first version not saved
--]]

XFC005_autoinstall.lua

-- function to auto-install XFC with a single dependency
local autoinstall= function()
    XFC.init()
    if draw then
        local draw0 = draw
        draw = function() draw0() XFC.draw() end
    end
    if touched then
        local touched0 = touched
        touched = function(touch)
            if XFC.touched(touch) then return end
            touched0(touch)  
        end
    else
        touched = XFC.touched
    end
end

-- this waits 3s then tries to install XFC. Delay needed for Main tab to be available
tween(1,{a=0},{a=1},linear,autoinstall)

local autoinstallOld= function()

    local lineSetup = 
    [[    if XFC then XFC.init() end     -- dont change this line!
    ]]
    local lineDraw = 
    [[    if XFC then XFC.draw() end     -- dont change this line!
    ]]
    local lineTouched = 
    [[    if XFC and XFC.touched(touch) then return end     -- dont change this line!
    ]]
    local drawTouched = 
    [[    if XFC then XFC.draw() end     -- dont change this line!
end

function touched(touch)
    -- put this line at the BEGINNING of your touched()
    if XFC and XFC.touched(touch) then return end     -- dont change this line!
    ]]
    
    -- look for lineSetup, and cancel if already there
    local mainTab = readProjectTab("Main")
    local s = string.find(mainTab,"XFC.init()")
    if s then return end
    -- otherwise, 
    alert("XFC in not installed. It will install automatically in your Main tab")
    -- paste lineSetup
    mainTab = string.gsub(mainTab,"function setup()",lineSetup)
    -- paste lineDraw
    -- paste lineTouched
    mainTab = string.gsub(mainTab,
    [[end

function touched(touch)]]
    ,drawTouched)
    -- finalize Main tab
    print(mainTab)
end

XFC010_MenuItem.lua

local MenuItem = class()
XFC.MenuItem = MenuItem
XFC.MenuItemNames = {} -- a table to manage items via their names
XFC.itemClass = {} -- a table to store all various item classes
XFC.itemClass["basic"] = MenuItem

function MenuItem:init(data)
    self:setup(data)
end

function MenuItem:setup(data)
    -- generic menu item class
    -- self.parent = otherMenuItem required
    -- self.name = a string to access easily this item (optionnal)
    -- self.iconLetter = a string (1 letter or emoticon, but more is possible)
    -- self.txt = data.txt a short text display aside the icon
    -- self.permission: if present, then shown only if XFC[self.permission] is true
    -- save all inputs
    for i,v in pairs(data) do self[i]=v end
    -- if parent defined by its name, then replace it by parent object
    if self.parent and type(self.parent) == "string" then 
        local str = self.parent
        self.parent = XFC.MenuItemNames[str]
        if self.parent == nil then 
            print("error: the item name "..str.." is not registered")
        end
    end
    -- all items must have a parent, except "root"
    if self.parent then 
        self.parent:addChild(self) -- register to parent
    else 
        if self.name ~= "root" then 
            print("error: menuItem "..tostring(self.name).." has no parent defined!")
        end
    end
    -- register item in list
    if self.name ~= nil then 
        if XFC.MenuItemNames[self.name] then 
            print("error: the item name "..self.name.." is already used")
        end
        XFC.MenuItemNames[self.name] = self 
    end
    -- check other inputs to avoid errors
    if self.iconLetter == nil then self.iconLetter = "" end
    if self.txt == nil then self.txt = "" end

    -- a table to store all children
    self.children = {}
    self.childrenVisible = false
    -- draw and touch position is computed from parent position
    self:computePosition()    
    self:hide()
end

function MenuItem:valid()    
    -- ok by default (to be implemented by derived classes)
    return true
end

function MenuItem:update()    
    self.disabled = false
end

function MenuItem:callback()    
    if self.disabled then return end
    -- default callback: toggle children visibility on/off
    if self.childrenVisible then self:hideChildren() else self:showChildren() end
    self:hideAllTxt()
end 

function MenuItem:createIcon()
    local w,h = self.w,self.h 
    local dy = 0
    local icon = image(w,w)
    local tfont = self.tfont or "AmericanTypewriter-Bold"
    local fsize = self.fsize or 32
    local bgcolor = self.bgcolor or color(218, 218, 218, 255)
    local tcolor = self.tcolor or color(0, 0, 0, 255)
    if tfont == "AppleColorEmoji" then 
        tcolor = color(255, 255, 255, 255)
        dy=-w/10
    end
    setContext(icon)
        resetStyle() resetMatrix()
        background(bgcolor)
        font(tfont)
        fontSize(fsize)
        fill(tcolor)
        textMode(CENTER)
        text(self.iconLetter,w/2,w/2+dy)
    setContext()
    self.icon = icon
end

function MenuItem:computePosition()    
    local w0,h0,w,h,dw,dh = 70,70,40,40,5,5
    local x,y = WIDTH - w0,HEIGHT - h0
    if self.parent then 
        if self.childIndex == 1 then
            local pos = self.parent.position
            x,y = pos.x,pos.y -- child start from parent
            x = x - w - dw
            y = y 
        else
            local previousBrotherIndex = self.childIndex - 1
            local pos = self.parent.children[previousBrotherIndex].position
            x,y = pos.x,pos.y -- item starts from previous brother
            x = x 
            y = y - h - dh
        end
    end
    local mypos = vec2(x,y)
    self.position = mypos

    -- touch coordinates
    self.tx, self.ty, self.tw, self.th = x+w/2, y+h/2, w/2, h/2
    -- size definition
    self.w0,self.h0,self.w,self.h,self.dw,self.dh = w0,h0,w,h,dw,dh
    
end

function MenuItem:show()
    if self.permission and XFC[self.permission] == false then
        self:hide()
        return
    end
    -- these 2 variables are the same exactly, except inverted, but more clear for me
    self.hidden = false
    self.visible = true
--    self.icon = self:createIcon()
    self:createIcon()
    self:showIcon()
    -- this is an animation
    if self.parent then
        local y = self.position.y 
        local ty = self.ty 
        local y0 = self.parent.position.y 
        local ty0 = self.parent.ty
        self.position.y = y0
        self.ty = ty0
        local n = #self.parent.children
        local duration = 0.5
        if n<10 then duration = 0.4 *n/10 +0.1 end
        tween(duration, self.position, {y=y})
        tween(duration, self, {ty=ty})
    end
end
function MenuItem:hide()
    self.hidden = true
    self.visible = false
    self:hideChildren()
    self:hideTxt()
    self.icon = nil    -- free memory from this image
    collectgarbage()
end
-- details
function MenuItem:showIcon()
    self.displayIcon = true
end
function MenuItem:hideIcon()
    self.displayIcon = false
end
function MenuItem:showTxt()
    self.displayTxt = true
    -- a little animation
end
function MenuItem:hideTxt()
    self.displayTxt = false
end
function MenuItem:showAllTxt()    
    local p = self.parent
    if p then
        for _,child in pairs(p.children) do child:showTxt() end
    end
end 
function MenuItem:hideAllTxt()    
    local p = self.parent
    if p then
        for _,child in pairs(p.children) do child:hideTxt() end
    end
end 

function MenuItem:tabExist(tabName)
    local list = listProjectTabs()
    local exist = false
    for i,name in pairs(list) do if name==tabName then exist = true end end
    return exist
end

function MenuItem:eraseAllTheseFields(fields)
    for _,field in pairs(fields) do self[field] = nil end
    for _,child in pairs(self.children) do child:eraseAllTheseFields(fields) end
end

function MenuItem:updateField(field,value)
    self[field] = value 
    for _,child in pairs(self.children) do child:updateField(field,value) end
end
-- children functions
function MenuItem:addChild(item)
    table.insert(self.children,item)
    item.childIndex = #self.children
end
function MenuItem:removeChildren()
    self.children = {}
end
function MenuItem:updateChildren()
    for _,child in pairs(self.children) do child:update() end
end
function MenuItem:showChildren()
    -- compute dynamic position
    self:shiftChildrenUp()    
    -- show children
    if #self.children > 0 then
        self.childrenVisible = true
        for _,child in pairs(self.children) do child:show() end
        self.children[1]:showAllTxt()
    else
        self.childrenVisible = false
    end
    -- hide children of other items
    local p = self.parent
    if p then
        for _,child in pairs(p.children) do 
            if child ~= self then child:hideChildren() end
        end
    end
end
function MenuItem:hideChildren()
    self.childrenVisible = false
    for _,child in pairs(self.children) do child:hide() end
end
function MenuItem:shiftChildrenUp(shift)    
    -- if no children, return
    local n = #self.children
    if n == 0 then return end
    -- if no problem, return
    local lastChild = self.children[n]
    local yn = lastChild.position.y
    local ymin = 30
    if yn > ymin and shift==nil then return end
    -- compute shift if not provided
    local forced = (shift ~= nil)
    if not forced then
        shift = ymin - yn
        local y0 = HEIGHT - self.h0
        local firstChild = self.children[1]
        local y1 = firstChild.position.y
        if y1 + shift > y0 then shift = y0-y1 end
    end
    -- apply this shift to children
    for _,child in pairs(self.children) do
        local newy = child.position.y + shift
        local newty = child.ty + shift
        child.position.y = newy
        child.ty = newty
        child:shiftChildrenUp(shift)    
    end
end


-- draw functions
function MenuItem:drawIcon()
    local position = self.position
    local x,y = position.x, position.y
    noSmooth() noStroke()
    spriteMode(CORNER)
    if self.disabled then tint(200) else tint(255) end
    sprite(self.icon,x,y)
    tint(255) 
end
function MenuItem:drawTxt()
    local position = self.position
    local w,h = 400,40
    local x,y = position.x - w -5, position.y
    if x<0 then w = w + x - 5 ; x = 5 end
    rectMode(CORNER)
    textMode(CORNER)
    if self.disabled then 
        fill(192)
    else 
        fill(238)
    end

    rect(x,y,w,h)
    font("ArialMT")
    fontSize(18)
    fill(0, 0, 0, 255)
    text(self.txt,x+5,y+10)
end
function MenuItem:draw()
    if self.hidden then return end
    if self.displayIcon then self:drawIcon() end
    if self.displayTxt then self:drawTxt() end
    if self.childrenVisible then
        for _,child in pairs(self.children) do child:draw() end
    end
end

function MenuItem:touched(touch)
    local touchIntercepted = false
    if self.hidden then return touchIntercepted end
    local x,y = touch.x, touch.y
    local abs = math.abs
    -- check if item touched
    if abs(x- self.tx)<self.tw and abs(y- self.ty)<self.th then
        if touch.state == BEGAN then self:callback(touch) end
        touchIntercepted = true
    else
        touchIntercepted = false
    end
    -- or if its children touched
    if self.childrenVisible then
        for _,child in pairs(self.children) do 
            if not touchIntercepted
            then touchIntercepted = child:touched(touch) end
        end
    end
    return touchIntercepted
end

XFC011_ChoiceItem.lua

local ChoiceItem = class(XFC.MenuItem)
XFC.itemClass["choice"] = ChoiceItem

function ChoiceItem:init(data)
    -- this item is a button to make choices
    -- special fields of data:
    -- data.choices = table of choice elements: {txt="comment",value=v,iconLetter=nil}
    --                 (iconLetter is optionnal)
    -- data.currentValue : optionnal
    -- data.tag : a str describing the variable
    -- data.choiceCallback(v)
    
    -- default icon (unless other required)
    if data.iconLetter == nil then data.iconLetter = '?' end
    
    -- shortcuts
    local basicItem = XFC.itemClass["basic"]
    local infoItem = XFC.itemClass["info"]

    -- top item
    self:setup(data)
    
    -- information
    local item = {}
    item.parent = self
    item.txt = data.txt
    self.info = infoItem(item)

    -- choices
    self.choiceItems = {}
    if self.choices == nil then 
        print("error : choices field missing!")
    else
        for _,choice in pairs(self.choices) do
            local item = {}
            item.parent = self
            item.txt = choice.txt
            item.value = choice.value
            item.callback = function(s) 
                self.choiceCallback(choice.value) 
                self.currentValue = choice.value
                self:update()
            end
            self.choiceItems[choice.value] = basicItem(item)  
        end
    end
    
    self:update()
end

function ChoiceItem:update()    
    self.disabled = false
    if self.choices == nil then self.disabled = true end
    
    if self.disabled then 
        self.callback = function() end
    else
        self.txt = self.tag .." : " .. tostring(self.currentValue)
        self.info.txt = self.tag .." : " .. tostring(self.currentValue)
        for _,choice in pairs(self.choices) do
            local value = choice.value
            local item = self.choiceItems[value]
            if self.currentValue == value
            then item.iconLetter = '◉'
            else item.iconLetter = '○'
            end
            item:createIcon()
        end
        self.callback = XFC.MenuItem.callback

    end
end

XFC011_LinkItem.lua

local LinkItem = class(XFC.MenuItem)
XFC.itemClass["link"] = LinkItem

function LinkItem:init(data)
    -- this item is a button to open a web link
    -- default icon (unless other required)
    if data.iconLetter == nil then data.iconLetter = '' end
    if data.tfont == nil then data.tfont = "AppleColorEmoji" end
    self:setup(data)
    self:update()
end

function LinkItem:update()    
    self.disabled = false
    self.link = self.parent.link or self.link
    if self.link == nil then self.disabled = true end
    if self.disabled then 
        self.callback = function() end
    else
        self.callback = self.openLink
    end
end

function LinkItem:openLink()    
    -- standard callback (to erase other displayed)
    XFC.MenuItem.callback(self)
    -- open link
    openURL(self.link,self.internal)
end 

XFC011_yesNoMenu.lua

local function yesNoMenu(data)
    -- create a sub-menu with a yes no question
    -- data has same fields as a menuItem
    -- fires data.callback( true | false) if the user touches yes or no

    -- shortcuts
    local basicItem = XFC.itemClass["basic"]
    local infoItem = XFC.itemClass["info"]
    
    -- the question
    local info = infoItem({parent=data.parent, txt = data.txt})
    local parent = info.parent -- here it is an item, not a string
    
    -- yes answer
    local item = {}
    item.parent = data.parent
    item.tfont = "AppleColorEmoji"
    item.iconLetter = '✅'
    item.txt = "YES"
    item.callback = function()
        parent:hideChildren()
        data.callback(true)
    end
    local yes = basicItem(item)
    
    -- no answer
    local item = {}
    item.parent = data.parent
    item.tfont = "AppleColorEmoji"
    item.iconLetter = '⛔'
    item.txt = "NO"
    item.callback = function()
        parent:hideChildren()
        data.callback(false)
    end
    local no = basicItem(item)
end

XFC.menu = {}
XFC.menu["yesNoMenu"] = yesNoMenu

XFC012_InfoItem.lua

local InfoItem = class(XFC.MenuItem)
XFC.itemClass["info"] = InfoItem

function InfoItem:init(data)
    -- this item is a button to show / hide all item txt
    -- default icon (unless other required)
    if data.iconLetter == nil then data.iconLetter = 'ℹ' end
    if data.tfont == nil then data.tfont = "AppleColorEmoji" end
    self:setup(data)
    if self.txt == "" then self.txt = self.parent.txt end
    self.callback = self.toggleAllInfos
end

function InfoItem:toggleAllInfos()    
    if self.displayTxt then self:hideAllTxt() else self:showAllTxt() end
    if self.childrenVisible then self:hideChildren() else self:showChildren() end
end 

XFC013_DocItem1.lua

-- thix is obsolete. Not used any longer.
local DocItem = class(XFC.MenuItem)
-- XFC.itemClass["doc"] = DocItem

function DocItem:init(data)
    -- this item is a button to show a detailed documentation
    -- default icon (unless other required)
    if data.iconLetter == nil then data.iconLetter = "📋" end
    if data.tfont == nil then data.tfont = "AppleColorEmoji" end
    self:setup(data)
    self.callback = self.docPopup
end

function DocItem:docPopup()    
    alert(self.more,"More details")
end 

XFC013_InfoBox.lua

local InfoBox = class()
-- this tab was written by @Briarfox
XFC.InfoBox = InfoBox
XFC.InfoBox.style = {}

--#h - Header
--#c - code
--#s - syntax
--#t - text


--Styles defined
XFC.InfoBox.style.bg = {}
XFC.InfoBox.style.bg.dark = color(42,45,49, 255)
XFC.InfoBox.style.bg.medium = color(60,65,70,255)
XFC.InfoBox.style.bg.light = color(242,235,218)
local myFont = "ArialMT"
local myFontSize = 20
XFC.InfoBox.style.header = {}
XFC.InfoBox.style.header.font = myFont
XFC.InfoBox.style.header.color = color(250, 250, 250, 255)
XFC.InfoBox.style.header.size = myFontSize+4

XFC.InfoBox.style.syntax = {}
XFC.InfoBox.style.syntax.font = myFont
XFC.InfoBox.style.syntax.color = color(174,205,217,255)
XFC.InfoBox.style.syntax.size = myFontSize - 2

XFC.InfoBox.style.text = {}
XFC.InfoBox.style.text.font = myFont
XFC.InfoBox.style.text.color = color(255, 255, 255, 255)
XFC.InfoBox.style.text.size = myFontSize - 2

XFC.InfoBox.style.code = {}
XFC.InfoBox.style.code.font = myFont
XFC.InfoBox.style.code.color = color(72, 59, 48, 255)
XFC.InfoBox.style.code.size = myFontSize - 2


function InfoBox:init(str)
    self.enabled = true
    self.padding = 15
    local imgStr = str
    local height = 500
    local width = 500
    self.imgheader = {}
    self.imgsyntax = {}
    self.imgtext = {}
    self.imgcode = {}
    self.header = nil
    self.syntax = nil
    self.txt = nil
    self.code = nil
    self.returns = nil
    self:format(str)



--create Header
font(XFC.InfoBox.style.header.font)
fontSize(XFC.InfoBox.style.header.size)
textWrapWidth(400)
 self.imgheader.w,self.imgheader.h = textSize(self.header)
self.imgheader.h = self.imgheader.h + self.padding
self.imgheader.img = image(width,self.imgheader.h)
setContext(self.imgheader.img)
background(XFC.InfoBox.style.bg.medium)
fill(XFC.InfoBox.style.header.color)
textMode(CENTER)
text(self.header,width/2,self.imgheader.h/2)
setContext()
-----------------------------

--draw syntax header
font(XFC.InfoBox.style.header.font)
fontSize(20)
local synHead = {}
synHead.str = "Syntax"
synHead.w,synHead.h = textSize(synHead.str)
synHead.h = synHead.h + self.padding
synHead.img = image(width,synHead.h)
setContext(synHead.img)
background(XFC.InfoBox.style.bg.dark)
fill(XFC.InfoBox.style.syntax.color)
textMode(CENTER)
text(synHead.str,30,synHead.h/2)
setContext()
------------------------

--draw syntax
font(XFC.InfoBox.style.syntax.font)
fontSize(XFC.InfoBox.style.syntax.size)

 self.imgsyntax.w,self.imgsyntax.h = textSize(self.syntax)
self.imgsyntax.h = self.imgsyntax.h + self.padding
self.imgsyntax.img = image(width,self.imgsyntax.h)
setContext(self.imgsyntax.img)
background(XFC.InfoBox.style.bg.medium)
fill(XFC.InfoBox.style.syntax.color)
textMode(CENTER)
text(self.syntax,width/2-100,self.imgsyntax.h/2)
setContext()
----------------------------

--draw text
font(XFC.InfoBox.style.text.font)
fontSize(XFC.InfoBox.style.text.size)
textWrapWidth(500 - self.padding)
textAlign(LEFT)

 self.imgtext.w,self.imgtext.h = textSize(self.txt)

self.imgtext.h = self.imgtext.h + self.padding
self.imgtext.img = image(width,self.imgtext.h)
setContext(self.imgtext.img)
background(XFC.InfoBox.style.bg.dark)
fill(XFC.InfoBox.style.text.color)
textMode(CENTER)
text(self.txt,width/2,self.imgtext.h/2)
setContext()
---------------------------

--draw code header
font(XFC.InfoBox.style.code.font)
fontSize(18)
local codeHead = {}
codeHead.str = "Examples"
codeHead.w,codeHead.h = textSize(codeHead.str)
codeHead.h = codeHead.h + self.padding
codeHead.img = image(width,codeHead.h)
setContext(codeHead.img)
background(XFC.InfoBox.style.bg.medium)
fill(255, 255, 255, 255)
textMode(CENTER)
text(codeHead.str,45,codeHead.h/2)
setContext()
---------------------

--draw code
font(XFC.InfoBox.style.code.font)
fontSize(XFC.InfoBox.style.code.size)
textWrapWidth(500 - self.padding)
textAlign(LEFT)
textMode(CENTER)

 self.imgcode.w,self.imgcode.h = textSize(self.code)

self.imgcode.h = self.imgcode.h + self.padding
self.imgcode.img = image(width,self.imgcode.h)
setContext(self.imgcode.img)
background(XFC.InfoBox.style.bg.light)
fill(XFC.InfoBox.style.code.color)
textMode(CENTER)
text(self.code,width/2 - 100,self.imgcode.h/2)
setContext()
------------------------

--bottom
local bottom = image(width,self.imgheader.h)
setContext(bottom)
background(XFC.InfoBox.style.bg.medium)
setContext()









self.img = image(500,self.imgheader.h+synHead.h+self.imgsyntax.h+self.imgtext.h+codeHead.h+self.imgcode.h+self.imgheader.h)
setContext(self.img)
background(255, 255, 255, 255)
spriteMode(CORNER)
local y = self.img.height - self.imgheader.h
sprite(self.imgheader.img,0,y)
y = y - synHead.h
sprite(synHead.img,0,y)
y = y - self.imgsyntax.h
sprite(self.imgsyntax.img,0,y)
y = y - self.imgtext.h
sprite(self.imgtext.img,0,y)
y = y - codeHead.h
sprite(codeHead.img,0,y)
y = y - self.imgcode.h
sprite(self.imgcode.img,0,y)
y = y - self.imgheader.h
sprite(bottom,0,y)
setContext() 


end


function InfoBox:draw()
    if self.enabled then
    spriteMode(CENTER)
    sprite(self.img,WIDTH/2,HEIGHT - self.img.height/2-50)
    end
end

function InfoBox:touched(t)
   if self.enabled and t.state == BEGAN then
    if t.state == ENDED then self.enabled = false end
    end 
end


function InfoBox:format(str)
    local s
    local e
    s,e = string.find(str,"#h",1)
    e,_ = string.find(str,"%#",e)
    if s ~= nil and e ~= nil then 
        self.header = string.sub(str,s+2,e-1) 
            elseif s~= nil and e == nil then 
        self.header = string.sub(str,s+2,#str) end

    s,e = string.find(str,"#s",1)
    e,_ = string.find(str,"%#",e)
    if s ~= nil and e ~= nil then self.syntax = string.sub(str,s+2,e-1) elseif
        s~= nil and e == nil then self.syntax = string.sub(str,s+2,#str) end

    s,e = string.find(str,"#t",1)
    e,_ = string.find(str,"%#",e)
    if s ~= nil and e ~= nil then self.txt = string.sub(str,s+2,e-1) elseif
        s~= nil and e == nil then self.txt = string.sub(str,s+2,#str) end

    s,e = string.find(str,"#c",1)
    e,_ = string.find(str,"%#",e)
    if s ~= nil and e ~= nil then self.code = string.sub(str,s+2,e-1) elseif
        s~= nil and e == nil then self.code = string.sub(str,s+2,#str) end

    s,e = string.find(str,"#r",1)
    e,_ = string.find(str,"%#",e)
    if s ~= nil and e ~= nil then self.returns = string.sub(str,s+2,e-1) elseif
        s~= nil and e == nil then self.returns = string.sub(str,s+2,#str) end




end

XFC014_DocItem2.lua

-- docitem2
local DocItem = class(XFC.MenuItem)
XFC.itemClass["doc"] = DocItem

function DocItem:init(data)
    -- this item is a button to show a detailed documentation
    -- default icon (unless other required)
    if data.iconLetter == nil then data.iconLetter = "📋" end
    if data.tfont == nil then data.tfont = "AppleColorEmoji" end
    self:setup(data)
    self:update()
end

function DocItem:update()    
    self.disabled = false
    self.more = self.parent.more or self.more
    if self.more == nil then self.disabled = true end
    if self.disabled then 
        self.callback = function() end
    else
        self.callback = self.docPopup
    end
end

function DocItem:docPopup()    
    -- standard callback (to erase other displayed)
    XFC.MenuItem.callback(self)
    -- create popup window...
    self.popup = XFC.InfoBox(self.more)
    -- and bypass normal XFC draw and touch:
    self.XFCdraw = XFC.draw
    self.XFCtouched = XFC.touched
    XFC.draw = function() self.popup:draw() end
    XFC.touched = function(touch)
        if touch.state == BEGAN then
            -- in case of touch, restore previous state:
            self.popup = nil
            XFC.draw = self.XFCdraw
            XFC.touched = self.XFCtouched
            collectgarbage()
        end
        local intercepted = true  -- intercept any touch
        return intercepted
    end
end 

XFC015_FIleIO.lua

local FileIO = class()
XFC.FileIO = FileIO
XFC.FileIO.json = false

--callback will be passed gist id,tabname
--XFC.FileIO.upload(tabname,callback)
--To Download:

--XFC.FileIO.download(gistid,tabname,singletab[true | false])

--Checks for json sets XFC.downloader.json to true to avoid future checks 
XFC.FileIO.getJsonLib = function(callback)

        local handleSuccess = function(data)
            local jsonCode
            jsonCode = data
            if jsonCode then
                XFC.FileIO.json = true
                l = loadstring(jsonCode)
                l()
                callback()
               --XFC.FileIO.GetProject(gistid,tabname,single) 
            end
        end
        http.request("https://dl.dropboxusercontent.com/s/9e4nvqeu4hsux2q/Json.lua?token_hash=AAFyMB98j4bnt_1gawf9wSke52hsoC7hsIvARcTuZNeOEw&dl=1", handleSuccess)

end

--This pulls the project once json has been loaded
XFC.FileIO.getProject = function(gistid,tabname,single,callback)

   local handleSuccess = function(data,i,j)
        local gist = json.decode(data)
        local counter = 1
        if single then
            local str = ""
            for k,v in pairs(gist.files) do
                if k ~= "1aTabOrder" then
                str = str..v.content
                loadstring(v.content)()
                end
            end
            saveProjectTab(tabname, str) -- Save a single tab
        else
            for k,v in pairs(gist.files) do
                if k ~= "1aTabOrder" then
                saveProjectTab(tabname..string.format("%03d",counter), v.content)
                loadstring(v.content)()
                counter = counter + 1
                end
            end 
        end
        if callback then callback() end
        alert("Download complete. You can now run the code or inspect it by exiting and viewing the tab",
    ">> "..tabname)
    end
    local handleFailure = function(data)
        sound(SOUND_EXPLODE, 32351)
        print(data)
    end 
    http.request("https://api.github.com/gists/"..gistid,handleSuccess, handleFailure)

end




--Uploader get project
XFC.FileIO.uploadGist = function (tabname,callback)
    local gist = {}
    gist.public = public
    gist.description = tabname or nil
    gist.files = {}
    gist.files[tabname .. ".lua"] = {content = readProjectTab(tabname)}

   local projectJson = json.encode(gist)

    local opts = {
        data = projectJson,
        method = "POST"
        }

    --success callback
    local handleSuccess = function(data)
        local gistReturn = json.decode(data)
        callback(gistReturn.id,tabname)
        alert("File has been uploaded to gistid: "..gistReturn.id,"Success")
        --sound(SOUND_PICKUP, 11797)
        --openURL(gistReturn.html_url)
    end

    --fail callback
    local handleFailure = function(data)
        sound(SOUND_EXPLODE, 32351)
        print(data)
        if data == "The request timed out" then print("But your gist should be there") end
    end



    http.request("https://api.github.com/gists",
        handleSuccess,
        handleFailure,
        opts)   
end

--Gist Pull
XFC.FileIO.download = function(gistid,tabname,single,callback)
    if XFC.FileIO.json then
       -- print("Already have json")
        XFC.FileIO.getProject(gistid,tabname,single,callback) 
    else  
    XFC.FileIO.getJsonLib(function() 
        XFC.FileIO.getProject(gistid,tabname,single,callback) 
    end)
    end
end

--Gist Push
XFC.FileIO.upload = function(tabname,callback)
    if XFC.FileIO.json then
       -- print("Already have json")
       XFC.FileIO.uploadGist(tabname,callback) 
    else  
    XFC.FileIO.getJsonLib(function() XFC.FileIO.uploadGist(tabname,callback) end)
    end

end

XFC016_DownloadItem.lua

local DownloadItem = class(XFC.MenuItem)
XFC.itemClass["download"] = DownloadItem

function DownloadItem:init(data)
    -- this item is a button to download a function
    -- default icon (unless other required)
    if data.iconLetter == nil then data.iconLetter = "📥"  end
    if data.tfont == nil then data.tfont = "AppleColorEmoji" end
    if data.txt == nil then data.txt = "Download this function in this project" end
    --[[
    if data.gist == nil then 
        alert("error: you must provide a gist to download a fonction") end
    if data.tabName == nil then 
        alert("error: you must provide a tabName to download a fonction") end

    XFC.menu["yesNoMenu"]({parent=self, txt="Do you really want to download this function?",
        callback = function(confirm)
            self:downloadTab(confirm)    
        end
    })
        --]]
    self:setup(data)
    self:update()
end

function DownloadItem:update()    
    self.disabled = false
    if self.tabName == nil or self.gist == nil then self.disabled = true end

    if self.disabled then
        -- remove yes no menu
        self:removeChildren()
    elseif #self.children == 0 then
        -- create yes no menu
        local dat = {}
        dat.parent = self
        dat.txt = "Do you really want to download this function?"
        dat.callback = function(confirm)
            self:downloadTab(confirm)    
        end
        XFC.menu["yesNoMenu"](dat)
    end
end


function DownloadItem:downloadTab(confirm)    
    -- cancel download if not requested
    if confirm ~= true then return end
    -- start download otherwise
    callback = function() 
        XFC.tabInit[self.tabName]()
        self.parent:updateChildren() 
    end
    XFC.FileIO.download(self.gist,self.tabName,true,callback)
    local msg = "Download requested from web.It may take several seconds. Please be patient!"
    local boxName = ">> "..self.tabName
    alert( msg, boxName)
end 

XFC017_UploadItem.lua

local UpItem = class(XFC.MenuItem)
XFC.itemClass["upload"] = UpItem

function UpItem:init(data)
    -- this item is a button to upload a function
    -- default icon (unless other required)
    if data.iconLetter == nil then data.iconLetter = "📤" end
    if data.tfont == nil then data.tfont = "AppleColorEmoji" end
    if data.txt == nil then data.txt = "upload this function to a gist" end
    data.permission = "developper" -- this is devopper-only item
    self:setup(data)
    self:update()

end

function UpItem:update()    
    self.disabled = false
    if self.tabName == nil then self.disabled = true end
    if not self:tabExist(self.tabName) then self.disabled = true end
    if self.disabled then
        -- remove yes no menu
        self:removeChildren()
    elseif #self.children == 0 then
        -- create yes no menu
        local dat = {}
        dat.parent = self
        dat.txt = "Really want to upload tab ".. self.tabName .." ?"
        dat.callback = function(confirm)
            self:upload(confirm)    
        end
        XFC.menu["yesNoMenu"](dat)
    end
end

function UpItem:upload(confirm)    
    -- cancel download if not requested
    if confirm ~= true then return end
    -- start download otherwise
    local function callback(gist,tab)
        print("your tab " ..tab.. " has been saved to:")
        print(gist)
        -- alert("your gist has been created")
    end
    XFC.FileIO.upload(self.tabName,callback)
    alert("Upload to github requested.It may take several seconds. Please be patient!")
end 

XFC018_RemoveItem.lua

local RemoveTab = class(XFC.MenuItem)
XFC.itemClass["remove"] = RemoveTab

function RemoveTab:init(data)
    -- this item is a button to remove a tab
    -- default icon (unless other required)
    if data.iconLetter == nil then data.iconLetter = '⚠' end
    if data.tfont == nil then data.tfont = "AppleColorEmoji" end
    if data.txt == nil then data.txt = "Remove this tab" end


    
    self:setup(data)
    self:update()

end
    
function RemoveTab:update()    
    self.disabled = false
    if self.tabName == nil then self.disabled = true end
    if not self:tabExist(self.tabName) then self.disabled = true end
    if self.disabled then
        -- remove yes no menu
        self:removeChildren()
    elseif #self.children == 0 then
        -- create yes no menu
        local dat = {}
        dat.parent = self
        dat.txt = "Really want to remove tab ".. self.tabName .." ?"
        dat.callback = function(confirm)
            self:remove(confirm)    
        end
        XFC.menu["yesNoMenu"](dat)
    end
end
    


function RemoveTab:remove(confirm)    
    -- cancel remove if not requested
    if confirm ~= true then return end
    -- remove otherwise
    local list = listProjectTabs()
    local tabExist = false
    for i,name in pairs(list) do if name==self.tabName then tabExist = true end end
    if tabExist then
        local msg = "The XFC tab containing this function has been removed from this project."
        if XFC.remove[self.tabName] then
            -- the tab contains a remove function, use it:
            XFC.remove[self.tabName](self.tabName)
        else
            -- else directly erase the tab:
            saveProjectTab(self.tabName,nil)
            msg = msg 
        .."\nNote that the functions that were in this tab are still active in memory!"
        .."\nSo restart this project to really update its behavior."
        end
        -- also remove data not supposed to be available
        -- (not implemented yet: too much to do here, have to think of it)
        self.parent:eraseAllTheseFields({"link","more"})
        self.parent:updateChildren()
        alert( msg , ">> "..self.tabName)
    else
        alert("This project tab is not present in your project, so it cannot be removed!",
        ">> "..self.tabName)
    end
end 

XFC019_downloadList.lua

XFC.downloadList = {
}

XFC021_FunctionItem.lua

local FunctionItem = class(XFC.MenuItem)
XFC.itemClass["function"] = FunctionItem
    
function FunctionItem:init(data)
    -- this is a standard menu for each function
    -- data must contain special fields:
    -- txt, gist, tabName, more

    -- shortcuts
    local basicItem = XFC.itemClass["basic"]
    local infoItem = XFC.itemClass["info"]
    local linkItem = XFC.itemClass["link"]
    local docItem = XFC.itemClass["doc"]
    local dwldItem = XFC.itemClass["download"]
    local uploadItem = XFC.itemClass["upload"]
    local removeItem = XFC.itemClass["remove"]
    
    -- function item
    data.iconLetter = "f()"
    data.tfont = "Arial-ItalicMT"
    data.fsize = 25
    self:setup(data)
    
    -- sub menu
    -- function title
    local item = {}
    item.parent = self
    item.txt = data.txt
    local newItem = infoItem(item)
    
    -- install function
    local item = {}
    item.parent = self
    item.gist = data.gist
    item.tabName = data.tabName
    local newItem = dwldItem(item)
    
    -- function documentation
    local item = {}
    item.parent = self
    item.txt = "Detailed description"
    item.more = data.more
    local newItem = docItem(item)
    
    -- function credits
    local item = {}
    item.parent = self
    item.txt = "Credits: link to original code source"
    item.link = data.link
    local newItem = linkItem(item)
    
    -- function remove
    local item = {}
    item.parent = self
    item.tabName = data.tabName
    local newItem = removeItem(item)
    
    -- function upload
    local item = {}
    item.parent = self
    item.tabName = data.tabName
    local newItem = uploadItem(item)
end

XFC030_unitTests.lua

local UnitTestsMenu = class(XFC.MenuItem)
XFC.itemClass["unitTestsMenu"] = UnitTestsMenu

function UnitTestsMenu:init(parent)
    
    local basicItem = XFC.itemClass["basic"]
    local infoItem = XFC.itemClass["info"]
    local docItem = XFC.itemClass["doc"]
    local linkItem = XFC.itemClass["link"]
    
    self:setup({parent=parent, name = "tests", iconLetter = "⚒" , 
    permission = "developper", -- this is devopper-only item
    txt = "various unit tests"})
    
    infoItem({parent= "tests",})
    
    basicItem({parent= "tests", name = "yesNo", iconLetter = "?" , 
    txt = "test of menu : question - yes - no ",})
    
    XFC.menu["yesNoMenu"]({parent="yesNo",
        txt = "Do you agree?",
        callback = function(ans)
            if ans then print("yes") else print("no") end
        end
    })
    
    local str = [[#h Cool Function
#stest( color )
test( color, something )
#t Testing the text there is lots of text so it must be tested. Testing the text there is lots of text so it must be tested. Testing the text there is lots of text so it must be tested. Testing the text there is lots of text so it must be tested. 

param         This does blah blah
@parameter     This also does blah
@return        This returns something
#c function draw()
    code goes here
    end
 function test( Code )
    --do something here
    end
    ]]
    
    docItem({parent= "tests", txt = "test of docItem", more = str})
    
    docItem({parent= "tests", txt = "disabled doc item",})
    
    linkItem({parent= "tests",
    link="https://bitbucket.org/TwoLivesLeft/core/wiki/Codea%20Programming%20FAQ",
    txt = "test of linkItem with @ignatz FAQ link"})
    
    linkItem({parent= "tests",
    txt = "test of linkItem with no link"})
    
    local data = {}
    data.txt = "test choice item"
    data.parent = "tests"
    data.choices = { 
        {txt="choice 1", value=1}, 
        {txt="choice 2", value=2}, 
        {txt="choice 3", value=3} 
        }
    data.currentValue = 3
    data.tag = "test choice"
    data.choiceCallback = function(v) print(tostring(v)) end
    XFC.itemClass["choice"](data)
    
    local data = {}
    data.txt = "test download item"
    data.parent = "tests"
    data.gist = "62a0660686725b81f29b"
    data.tabName = "XFC016_test"
    XFC.itemClass["download"](data)
    
    local data = {}
    data.txt = "test upload item"
    data.parent = "tests"
    data.tabName = "XFC016_test"
    XFC.itemClass["upload"](data)
    XFC.itemClass["upload"]({parent= "tests", txt = "disabled upload item",})
    
    local data = {}
    data.txt = "remove item"
    data.parent = "tests"
    data.tabName = "XFC016_test"
    XFC.itemClass["remove"](data)
    XFC.itemClass["remove"]({parent= "tests", txt = "disabled remove item",})

    local data = {}
    data.iconLetter = "f()"
    data.tfont = "Arial-ItalicMT"
    data.fsize = 25
    data.txt = "test function wait"
    data.parent = "tests"
    data.gist = "62a0660686725b81f29b"
    data.tabName = "XFC016_test"
    data.more = str
    XFC.itemClass["function"](data)
    
end
    
XFC.menu.unitTestsMenu = unitTestsMenu

XFC031_functionsMenu.lua

local FunctionsMenu = class(XFC.MenuItem)
XFC.itemClass["functionMenu"] = FunctionsMenu

function FunctionsMenu:init(parent)
    
    local basicItem = XFC.itemClass["basic"]
    local infoItem = XFC.itemClass["info"]
    self.functionItem = XFC.itemClass["function"]
    
    local data = {}
    data.iconLetter = "f()"
    data.tfont = "Arial-ItalicMT"
    data.tfont = "Arial"
    data.fsize = 25
    data.txt = "useful functions"
    data.parent = parent
    data.name = "functions"
    self:setup(data)
    
    self.parentMenu = "functions"
    local data = {}
    data.txt = "Functions currently available"
    data.parent = self.parentMenu
    infoItem(data)
    
    self.functions = {}
    
    -- ADD your gist functions here:
    
    self:add({ txt="wait(delay,callback)", 
    tabName="XFC110_wait", gist ="f9963a32ea8f85beac90"})
    
    self:add({ txt="param_integer(name, min, max, init, cb)", 
    tabName="XFC120_param", gist ="56a89595a0a22a8a20a3"})
    
    
end

function FunctionsMenu:add(data)
    data.parent = self.parentMenu
    --table.insert(self.functions,data)
--    self.functions[data.tabName] = self.functionItem(data)
    local item = self.functionItem(data)
    XFC.tabs[data.tabName] = item
    local init = XFC.tabInit[data.tabName] 
    if init then init() item:updateChildren() end
end

--XFC.menu.functionsMenu = function(parent) return FunctionsMenu(parent) end
-- TO BE SUPPRESSED: (clean up unit test example first)
XFC.Functions = {}    -- to store functions

XFC032_linksMenu.lua

local LinksMenu = class(XFC.MenuItem)
XFC.itemClass["linksMenu"] = LinksMenu

function LinksMenu:init(parent)
    
    local basicItem = XFC.itemClass["basic"]
    local infoItem = XFC.itemClass["info"]
    local linkItem = XFC.itemClass["link"]
    
    self:setup({parent=parent, name = "webLinks", iconLetter =  ''  , 
        tfont = "AppleColorEmoji",
        txt = "links to useful web discussions or tutorials"})
        
    infoItem({parent= "webLinks", txt = "list of available useful links"})
        
    local data = {}
    data.parent = "webLinks"
    data.txt = "@ignatz book 'lua for beginners'"
    data.link = "https://www.dropbox.com/s/qh1e7ft4rvhlpt2/Lua%20for%20beginners.pdf"
    linkItem(data)
    
    local data = {}
    data.parent = "webLinks"
    data.txt = "@ignatz FAQ about code"
    data.link = "https://bitbucket.org/TwoLivesLeft/core/wiki/Codea%20Programming%20FAQ"
    data.internal = true
    linkItem(data)
    
    
end

XFC033_settingsMenu.lua

local SettingsMenu = class(XFC.MenuItem)
XFC.itemClass["settingsMenu"] = SettingsMenu

function SettingsMenu:init(parent)
    
    local basicItem = XFC.itemClass["basic"]
    local infoItem = XFC.itemClass["info"]
    local linkItem = XFC.itemClass["link"]
    
    self:setup({parent=parent, name = "settings", iconLetter = "⚙" , 
        txt = "settings of XFC"})
    
    infoItem({parent= "settings", txt = "settings of XFC"})

    local data = {}
    data.txt = "developper settings"
    data.parent = "settings"
    data.choices = { 
        {txt="enable", value=true}, 
        {txt="disable (recommended)", value=false}, 
        }
    data.currentValue = XFC.developper
    data.iconLetter = "⚒" 
    data.tag = "enable developper buttons"
    data.choiceCallback = function(v)  
        XFC.developper = v
    end
    XFC.itemClass["choice"](data)
    
    XFC.itemClass["unitTestsMenu"]("settings")
end

XFC050_Menu.lua

local Menu = class()
XFC.menu.root = Menu

function Menu:init(x)
    
    local basicItem = XFC.itemClass["basic"]
    local infoItem = XFC.itemClass["info"]
    local docItem = XFC.itemClass["doc"]
    local linkItem = XFC.itemClass["link"]
    
    -- this is the top root item menu
    local root = basicItem({name="root", iconLetter = "X" , bgcolor = color(127,127,127,21),
    txt = "hello test"})
    self.root = root
    root:show()
    
    infoItem({parent=root, txt = "Menu of XFC, eXtensions For Codea"})
    
    XFC.itemClass["functionMenu"]("root")
    
    basicItem({parent=root, name = "classes", iconLetter = "C" , disabled = true,
    txt = "useful classes"})
    basicItem({parent=root, name = "shaders", iconLetter = "S" ,  disabled = true,
    txt = "useful shaders"})
    basicItem({parent=root, name = "toolbars", iconLetter = "T" ,  disabled = true,
    txt = "useful toolbars"})
    basicItem({parent=root, name = "apps", iconLetter = "A" ,  disabled = true,
    txt = "complete stand-alone apps, games"})
        
    XFC.itemClass["linksMenu"]("root")
        
    basicItem({parent=root, name = "updates", iconLetter = '🔄' , 
        tfont = "AppleColorEmoji", disabled = true,
        txt = "check for available updates"})
        
    XFC.itemClass["settingsMenu"]("root")
end

function Menu:draw()
    self.root:draw()
end

function Menu:touched(touch)
    local touchIntercepted = self.root:touched(touch)
    return touchIntercepted
end