A TkInter wrapper for python inspired by the GUI library Shoes for Ruby.
This is intended to make it easier to create simple GUI interfaces quickly. All these classes inheret from their TkInter counterparts so you can use them just as you would their original TkInter counterparts if need be.
To use this library you can star import to get access to all classes and functions;
from sneakers import *
How to create windows
Context managers are used to create windows, stacks (columns) and flows (rows).
For example, this is how a context manager is used to make a window;
from sandals import * with window("My window"): label("Hello world")
The way stacks and flows work was intended to be the same as with the Ruby library Shoes, but it's not quite there yet. Info on how they're meant to work can be found on the Ruby Shoes website: http://shoesrb.com/
As mentioned below, the library needs to be ideally be rewritten to use TkInter grids, rather than just packing elements in different ways, which is something I'm working on at the moment. The @button and other GUI decorators
Adding the decorator
to a function adds a button that triggers that function. The button is located in whatever context manager the function is defined in.
For example, this code will create a window with a button, which when clicked will create a popup;
from sandals import * with window(): @button("Create a popup box") def makePopupBox(): showInfo(message = "You clicked the button")
Checkboxes, radio buttons, spin boxes, scale bars, and option menus can all be applied as decorators in a similar way. They are also located in whatever context manager (window, stack or flow) the function is defined in. For example, here is a simple implementation of a check box to change a boolean;
@checkBox("Is the oven on?", checked = True) def ovenOn(checked): theOvenIsOn = checked
And here is a simple example of how to implement an options menu;
label("How's the oven?") @optionMenu("clean", "dirty", "broken") def ovenState(option): print "The oven is", option
All these decorators can also be used as classes where this is more convenient. Manipulating buttons
Because these decorators inherit from their TkInter classes, they can be used as normal (i.e. not as decorators) and then configured using e.g.
Buttons can be altered even when created as a decorator, as they are added as a function attribute of the function they are applied to, so can be accessed via e.g.
All the TkInter adjectives used to modify buttons - such as
NORMAL which describe the state of a disabled and enabled button respectively - are imported as well.
Here is an example where this method is used to disable a button created using a decorator;
from sandals import * with window(): @button("This button does nothing") def doNothing(): pass @button("Disable button") def disableButton(): doNothing.button.config(state = DISABLED)
The @repeat and @loop decorators
Two new decorators are included which you might not necessarily associate with a GUI library;
These create a thread that repeats or loops the function the decorator is applied to. Once the context the decorated function is defined in is destroyed (e.g. closing a window) then that thread is stopped and the function will stop repeating or looping. As an example, here is a function that repeats once a minute;
@repeat(60) def clock(): print "A minute has passed"
The repeat and loop decorators are inspired by similar methods in Shoes, which turn out to be more useful than you might expect when designing a GUI.
Changing and reading text in GUI elements
How the text in labels and other GUI elements is changed to try and make them easier to work with.
A slightly more complex example that demonstrates this;
example.py has a more complete example of how to use the different methods, context managers, etc. which should look like this;
TO DO LIST
- Add to pip.
- Add support for ttk
- Rewrite to use tkinter grids as well as pack.
- Retools this readme.
- Add attribution from previous repositories.