Luce – A GUI Module for Lua Based on JUCE
来自： https://github.com/peersuasive/luce
Luce 0.3.3 ebb and flow released !
Downloadsfor Linux, Windows, OS X, iOS and Android are available.
What is Luce ?
Luce is a Lua module for GUI programming based on the portable, embeddable, remarkable C++ library JUCE .
It can be used as an ordinary module for pure lua 5.1/lua 5.2/luajit 2.X scripts or as a library for C++/Lua projects.
Although based on JUCE, Luce isn't aiming at becoming a binding for JUCE, though the low level API free of Luce features could be used as such.
Luce has Lua in mind and will be developped for lua developpers.
Lua essence is to be " a powerfull, fast, lightweight embeddable scripting language. " And so would Luce be too.
Luce is light, fast andeasily portable, thanks to Lua and JUCE itself.
As of now, it's supported on Linux, Windows and Mac OS X, with partial support for iOS and Android.
Getting started
- downloadthe lua module for your environment
- put it somewhere in your lua modules path (ex: /usr/local/share/lua/5.1 )
-
if you're on Linux, you can also use the providedluarock
-
if you don't know JUCE, you should consider having a look at its documentation as Luce low level API matches for the most part JUCE's own API.
For more explanations, seeDifferences with JUCEandLuce design
A first app: say hello
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 A more complete example using only the low level API
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 ) More examples
For more examples, see theexamples folder of the repository.
ProjectslTox andLecture are also good starting points.
Requirements and dependencies
To simply use Luce as a module,
- lua 5.1 / lua 5.2 / luajit 2.X
to compile the module and for C++ projects
- C++11
- GCC 4.6+ / CLANG 3.3+
To extend with new JUCE classes
- JUCE 4.0.1+
Downloads
As of v0.3.1, modules are available for both lua5.1/luajit2.X and lua5.2. As of v0.3.3, lua5.3 is supported under linux.
To use with lua scripts as a module, pick the module download.
If you want to contribute and help debugging, get the debug version of the module also.
And if you want to useLuce/Embedded or develop with C++, get the static library (or use the module as a shared library, if you prefer to).
For iOS, only the static library is available as Apple policies wouldn't allow a shared version but if you'd like to deploy on jailbroken devices, just ask, I'll provide it with the next release.
For Android, at the opposite, only the shared library/module is available, as a static library wouldn't really make sense, but feel free to ask also.
v0.3.3 (alpha)
Linux64 5.1
Linux64 5.2
Linux64 5.3
Win32 5.1
Win32 5.2
OS X 5.1
OS X 5.2
iOS 5.1+ 5.1
iOS 5.1+ 5.2
Android 4.4 5.1 (luajit)
What's implemented so far ?
Basically, most of the core components are implemented, as well as OpenGL.
Most of the Graphics painting operations are also implemented, as well as the most usefull math/geometry classes.
Some components you might find usefull may be missing, so don't hesitate to ask for adding (or fork the repo and follow the guideAdding new classes to Lucethen send a pull request ).
Luce design
All Luce classes start with a L .
Luce design is close to JUCE's, but often simplfied when it doesn't make sense in lua to keep some if its behaviour or features.
For the general GUI design, see JUCE.
All widgets are derived from Juce's Component class and Luce's LComponent class. All non-widgets classes are derived from LBase. LComponent itself is derived from LBase. LBase offers the required link to Lua while LComponent offers the required links to Juce.
Most of the callbacks existing in Juce also exist in Luce; in the same manner they need to be overriden in Juce to take effect, they also need to be overriden in Luce, that is, as for Luce, that a lua function needs to be provided for the callback to be effective. If no callback is provided, the default Juce action is called, if any.
All L* classes map their Juce equivalent or are specific to Luce (like LBase).
All L* classes are overridable within lua code, like any pure lua modules, and most of them are partly implemented in Lua. This is particularly useful for callback declarations or to add actions to native methods or simply to specialise a component with new functionnalities. This is the mechanism we use to implement C++ classes directly in Lua.
There's a limitation, though, unless it's a callback, as it's not possible to reimplement a native method in lua -- hence the use of a lua class wrapping the native one.
Differences with JUCE
For simplicity and reference, Luce usually uses the same method names than JUCE . However, where JUCE uses getters/setters, Luce offers a direct value attribution, whenever possible and obvious, that is. For instance, setName("...") and getName() would be replaced with name [= "..."] , though set/get methods are still accessible.
Another different is for JUCE's overloaded methods for both; wherever a more compact form exists that can be substituted with tables, Luce will always implement this compact form, leaving the detailed one.
For instance, if a method can accept both a Rectangle and four number x,y,w,h, Luce will accept either a LRectangle or the table {x,y,w,h} but not the four numbers.
So JUCE documentation is applicable for most of the Luce's low level components.
Luce doesn't provide any listener class directly (and probably won't) but instead wraps the listeners, where relevant, on the C++ side; as such, there's no point in having addListener and removeListener functions taking a listener class as argument; but one would be able to enable or disable such listeners so these methods still exist in Luce though they just activate/deactivate the wrapped Listener.
Some future use cases may reveal the need for such an availability but at the moment, we haven't found any.
Another difference is with Rectangle and Point objects, for which we didn't find any use to provide natively. These classes are provided as pure lua indexed tables and recreated wherever needed. So where a JUCE method needs a Rectangle or Point object, a table containing the values must be provided instead. Order is always x, y [, w, h ]. In general speaking, it respects the order declared in the class constructor. Later on, there'll probably be a lua implementation of these classes, to offer some of their most useful methods, like :reduce() .
Adding new classes to Luce
There are two kinds of classes in Luce : full classes and wrapper classes.
Full classes are just JUCE classes extended to be integrated with Luce , while wrapper classes are there to create some kind of inheritence between Luce components.
For the 1st one, see LLabel , LTextEditor or LTextButton , while the only example for the 2nd kind is LComponent .
LLabel , LTextEditor and LTextButton extend their respective JUCE component while inheriting LComponent , which in turn wraps all JUCE 's Component base class methods.
This allows simulating inheritence in Luce components, as it wouldn't be possible in a simple way otherwise. Like previously said, we're not aiming at a 1 to 1 binding to JUCE , so more complex mechanisms would be oversized here (unless someone knows a simple way to achieve this, of course !).
There is a helper script, microparser , which greatly simplify the job of creating new classes for Luce . It won't generate a new "ready to use" class but gives a great help by generating the class template and headers with all available methods and callbacks and pre-implementing them. The most obvious ones are fully generated.
To add pseudo-inheritence, use the script create_inh.sh :
./create_inh.sh <Luce_CLASS_BASE_NAME>
which generates the LCLASS_inh.h header to be included in the class.
Once the class is created, include it in luce.cpp , luce.h and reference it in Main.cpp :
int l_NewClass(lua_State *L) { Luna<LNewClass>::Register(L); return 1; } static const luaL_reg luce_lib [] = { { "NewClass", l_NewClass }, [...] {NULL, NULL} }; Luce Roadmap
Luce is now stable and complete enough to implement some GUI applications.
It's still lacking a high level API to hide the relative complexity of JUCE, though.
- documentation
- high level API (to create classes, maybe inheritence (@see30log, for instance.)
- integrate debugging facilities
- events broadcasting, be it JUCE's or something else
- portability: finalise Windows and OSX, optimisations for Android and iOS, start *BSD
- ease look-and-feel customisation
Related Projects
Luce Embeddable, to create standalone or bundled applications.
Luce Squishable, to concatenate Luce's lua classes to one, portable file.
License.
For open source projects, Luce is licensed under the terms of the GPLv3 with some parts being AGPLv3 .
For commercial projects and professional support, please contact us at
contact
_at
peersuasive.com .