local title = "Hello World!"

local app, luce = require"luce.LApplication"(title, ...) -- create a basic Application
                                                         -- with command line parameters

local timer = luce:Timer() -- a timer for the animation

local function MainWindow(args)  -- our main component class
                                 -- will receive command line arguments or starting events

    local app, luce = app, luce    -- just to put these in the local environment
    local Colours   = luce.Colours -- id.
    local wsize     = {800,600}    -- the size of our window
    local isPaused  = false        -- holds the animation state

    local mc = luce:MainComponent("MainComponent") -- our main component
    local documentWindow = luce:Document(title)    -- create a document window to hold the main component

    local button = luce:TextButton("quit")  -- a button to close the app
    button.buttonText = "Quit"              -- visible text of the button
    button:setLookAndFeel(4)                -- change look-and-feel
    button.bounds     = { 10, 10, 100, 20 } -- and position it (x,y,w,h)

    ---
    -- set some action on button click
    ---
    button:buttonClicked(function()
        app:quit()
    end)

    ---
    -- say hello to the world with a simple animation
    ---

    -- just a dumb function to increase font size and pick a predefined colour
    local currentSize, baseSize, maxSize = 12.0, 12.0, 32.0
    local colours    = { Colours.black, Colours.red, Colours.yellow, Colours.green, Colours.blue }
    local currentCol = 1
    local function changeSize()
        currentSize = (currentSize<maxSize) and currentSize+0.5 or baseSize
        currentCol  = (currentCol>=#colours) and 1 or currentCol+1
        return currentSize, colours[currentCol]
    end

    -- draw the message
    mc:paint(function(g)
        -- draw a background
        g:fillCheckerBoard( luce:Rectangle(mc:getBounds()), 48, 48, Colours.lightgrey, Colours.white)
        -- get new font size and colour
        local size, colour = changeSize()
        -- draw text
        g:setFont(size)
        g:setColour(luce:Colour(colour))
        g:drawText("Hello World!", mc:getLocalBounds(), luce.JustificationType.centred, true);
    end)

    -- animate it a bit via the timer callback
    timer:timerCallback(function()
        if(mc:isShowing() and not(isPaused))then
            mc:repaint()
        end
    end)
    timer:startTimer (1000/60)

    ---
    -- add some key shortcuts
    ---
    local K  = string.byte
    local kc = setmetatable(
        luce.KeyPress.KeyCodes, { __index = function()return 0 end } ) -- just a little trick to always get a valid keycode
                                                                       -- see https://www.juce.com/api/classKeyPress.html for
                                                                       -- available key-codes
    documentWindow:keyPressed(function(k)
        local k, m = k:getKeyCode(), k:getModifiers() -- get current key-code and modifiers status
        if (k==K"Q" or k==K"q")
                and (m:isCommandDown() or not(app.os.osx)) then -- if Q is pressed or, on OS X, cmd+Q
            app:exit(0)     -- close the application with an normal exit state (0 by default)

        elseif (k==K"w" or k==K"W") and (m:isCommandDown() ) then -- if cmd/ctrl + W is pressed
            documentWindow:closeWindow() -- close the window
                                         -- on Linux and Windows, this has the effect of closing the application too,
                                         -- but on OS X, only the active window is closed by default
                                         -- however, if true is passed to closeWindow()
                                         -- and this is the last remaining Document
                                         -- the app will close the window and quit the application
        elseif (k==kc.spaceKey) then
            -- toggle rendering pause
            isPaused = not(isPaused)
        else
            return false -- don't consume key
                         -- returning false, nil or not returning anything
                         -- has the same effect
        end
        return true     -- tell the OS we have consumed this key
    end)

    ---
    -- add all components and display
    ---

    mc:setSize(wsize)
    mc:addAndMakeVisible(button)                -- add the component to our main component
    documentWindow:setContentOwned( mc, true )  -- add the main component to the document window

    ---
    documentWindow:closeButtonPressed(function() -- the user asked to close the current window...
        documentWindow:closeWindow()             -- so let's close it our way
                                                 -- if this action's not taken, it'll close the app by default
    end)
    documentWindow:setSize(wsize)   -- set dimensions for the window
                                    -- on iOS and Android, it'll just set a fullscreen
    documentWindow:setVisible(true) -- display the document
    return documentWindow           -- return it for the application to actually display it
end

local manual      = false       -- set true if you want to add your own process running along with the main loop
local osx_delayed = false       -- set true if you don't want your app to display a window immediatly on OS X
                                -- but wait for user input before, like providing a file,...
local poller      = function()  -- the callback you want to run in manual mode
    print "I'm in a loop!"
end
return app:start( MainWindow, manual and {poller,100}, osx_delayed ) -- returns the exit state

local luce = require"luce"()

---
--- create a default JUCEApplication
---
local mainWindow = luce:JUCEApplication("My App")

---
--- create a DocumentWindow with name "Document Window"
---
local dw = luce:DocumentWindow("Document Window")
-- rename it
dw.name = "Luce Example Application"

---
--- create a MainComponent, to be hosted by the Document Window
---
local mc = luce:MainComponent("The Main Component")

---
--- create a button named "TheButton" with text "a button"
---
local button = luce:TextButton("TheButton")
button:setButtonText( "a button" ) -- or button.buttonText = "a button", like button2 below

--- add a callback for when button is clicked
button:buttonClicked(function(...)
    print("button clicked !!")
end)

--- change component look and feel
local button2 = luce:TextButton("TheButton2")
button2.buttonText = "button with a different look and feel"

--- add a callback for when button is clicked
button2:buttonClicked(function(...)
    print("button 2 clicked !!")
end)

--- set a different look and feel for button2
button2:setLookAndFeel(3)

---
--- create a Label
---
local label = luce:Label("A Label")

--- Label's setText has an optional parameter to send a notification when its content's changed
--- by default, it sends nothing:
label.text = "a bit of content" -- default to dontSendNotification

--- set a callback for label text changes
label:labelTextChanged(function(...)
    print("Label text has changed: ", label:getText()) -- or label.text
end)
--- but we could use one of the three notification methods accepted:
--- sendNotification, sendNotificationSync or sendNotificationAsync
--- by using the setText method:
local notif = luce.NotificationType.sendNotification
label:setText( "another content", notif )

--- set label editable
label:setEditable(false, true, true) -- edit on single click, edit on double click,
                                     -- cancel changes when losing focus
--- we can attach the label to the button too
label:attachToComponent( button, true ) -- component, true: onLeft/false: above (default)
print( "is attached on left ?", label:isAttachedOnLeft())


--- set a colour for background and align text to the right
local label2 = luce:Label("Another Label")
label2.text = "(left aligned)"
label2:setColour( label2.ColourIds.backgroundColourId, luce.Colours.yellow )
label2:setJustificationType( luce.JustificationType.right )

--- centre text
local label3 = luce:Label("(left aligned text)")
label3.text = "(centered)"
label3:setColour( label3.ColourIds.backgroundColourId, luce.Colours.red )
label3:setJustificationType( luce.JustificationType.centred )

---
--- create a TextEditor
---
local te = luce:TextEditor("Text Editor")

--- directly set bounds for this component
te.bounds = { 200, 250, 200, 200 } -- x, y, w, h
-- or
-- te.setBounds{ 200, 250, 200, 200 }

--- add our Document Window and components to our main JUCE application
mainWindow:initialise(function(...)
    mc:setSize{800,600}
    mc:addAndMakeVisible( button ) -- add the button to the main component
    button:setBounds{ 200, 20, 200, 200 } -- give the button some dimensions
    mc:addAndMakeVisible( label ) -- add the label
    --label:setBounds{ 20, 250, 100, 100 } -- don't set bounds to the label
                                           -- if you want it attached to button

    mc:addAndMakeVisible(te) -- add the Text Editor

    mc:addAndMakeVisible( button2 ) -- add the second button with the different lnf
    button2:setBounds{ 410, 20, 200, 200 }

    mc:addAndMakeVisible(label2)
    label2:setBounds{ 410, 230, 150, 30 }

    mc:addAndMakeVisible(label3)
    label3:setBounds{ 410, 270, 150, 30 }

    --mc:setBounds{ 0, 0, 800, 600 } -- set the component bounds
                                     -- as this is the last component before
                                     -- DocumentWindow, it'll set the window size
                                     -- too, unless dw sets one
    dw:setContentOwned( mc, true )

    dw:centreWithSize{800, 600} -- centre window on screen with size 800x600
    --dw:setCentrePosition{ 0, 0 } -- move it to the top left corner

    --dw:setBounds{ 100, 100, 800,600 } -- sets the window bounds
                                        -- as dw is a TopWindow and, as such, the very 1st component,
                                        -- it'll be positionned
                                        -- on screen directly, so that's another way of
                                        -- doing centreWithSize/setCentrePosition
    --dw:setSize{ 800,600 } -- just show the window, top left corner
    dw:setVisible(true)

    return dw -- return the Document Window so the JUCE Application can take it
end)

--- callback on DocumentWindow :closeButtonPressed
dw:closeButtonPressed(function(...)
    print("*** DocumentWindow close button pressed")
end)

--- callback used when quit is asked
local stop_now = false
mainWindow:systemRequestedQuit(function(...)
    print("** MainWindow system requested quit")
    stop_now = true
    mainWindow:quit()
end)

--- main loop

--- there are two implementations of the main loop
--- one is the JUCE's native wrapped one
--- and the other one gives control over the loop
--- so actions can be taken during the process execution

-- luce:start( mainWindow ) -- the simplest one, everything's under
                            -- JUCE control

--- and the non automatic one
--- the function's executed in a loop within a thread,
--- so there's no need to loop here
--- it is set with the same rate than the JUCE's loop (1ms by default)
luce:start_manual( mainWindow, 1, function(...)
    -- do some stuff, like zmq:poll(), for instance
    return stop_now
end )