999 lines
30 KiB
Python
999 lines
30 KiB
Python
# snack.py: maps C extension module _snack to proper python types in module
|
|
# snack.
|
|
# The first section is a very literal mapping.
|
|
# The second section contains convenience classes that amalgamate
|
|
# the literal classes and make them more object-oriented.
|
|
|
|
"""
|
|
This module provides the NEWT Windowing toolkit API for Python
|
|
This is a lightweight text-mode windowing library, based on slang.
|
|
|
|
Classes:
|
|
|
|
- Widget
|
|
- Button
|
|
- CompactButton
|
|
- Checkbox
|
|
- SingleRadioButton
|
|
- Listbox
|
|
- Textbox
|
|
- TextboxReflowed
|
|
- Label
|
|
- Scale
|
|
- Entry
|
|
- Form
|
|
- Grid
|
|
- SnackScreen
|
|
- RadioGroup
|
|
- RadioBar
|
|
- ButtonBar
|
|
- GridFormHelp
|
|
- GridForm
|
|
- CheckboxTree
|
|
- Clistbox
|
|
|
|
Functions:
|
|
|
|
- ListboxChoiceWindow
|
|
- ButtonChoiceWindow
|
|
- EntryWindow
|
|
"""
|
|
|
|
|
|
from __future__ import absolute_import, print_function, unicode_literals
|
|
import _snack
|
|
import string
|
|
import sys
|
|
|
|
from _snack import FLAG_DISABLED, FLAGS_SET, FLAGS_RESET, FLAGS_TOGGLE, FD_READ, FD_WRITE, FD_EXCEPT
|
|
|
|
LEFT = (-1, 0)
|
|
DOWN = (-1, -1)
|
|
CENTER = (0, 0)
|
|
UP = (1, 1)
|
|
RIGHT = (1, 0)
|
|
|
|
snackArgs = {"append":-1}
|
|
|
|
class Widget:
|
|
"""Base class for NEWT toolkit - Do not use directly
|
|
|
|
methods:
|
|
|
|
- Widget(self)
|
|
- setCallback(self, obj, data = None) :
|
|
The callback for when object activated.
|
|
data is passed to obj.
|
|
"""
|
|
def setCallback(self, obj, data = None):
|
|
if data:
|
|
self.w.setCallback(obj, data)
|
|
else:
|
|
self.w.setCallback(obj)
|
|
|
|
def __init__(self):
|
|
raise NotImplementedError
|
|
|
|
class Button(Widget):
|
|
"""Basic button class, takes button text as parameter
|
|
|
|
method:
|
|
|
|
- Button(self, text): returns a button
|
|
"""
|
|
def __init__(self, text):
|
|
self.w = _snack.button(text)
|
|
|
|
class CompactButton(Widget):
|
|
"""Compact Button class (less frilly button decoration).
|
|
|
|
methods:
|
|
|
|
- CompactButton(self,text) : create button, with text.
|
|
"""
|
|
def __init__(self, text):
|
|
self.w = _snack.compactbutton(text)
|
|
|
|
class Checkbox(Widget):
|
|
"""A checkbox.
|
|
|
|
methods:
|
|
|
|
- Checkbox(self, text, isOn = 0) : text, and boolean as to default value
|
|
- setValue(self) : set value
|
|
- value(self, value) : return checkbox value
|
|
- selected(self) : returns boolean
|
|
- setFlags(self, flag, sense) : set flags
|
|
|
|
flags: FLAG_DISABLED, FLAGS_SET, FLAGS_RESET
|
|
"""
|
|
def value(self):
|
|
return self.w.checkboxValue
|
|
|
|
def selected(self):
|
|
return self.w.checkboxValue != 0
|
|
|
|
def setFlags (self, flag, sense):
|
|
|
|
return self.w.checkboxSetFlags(flag, sense)
|
|
|
|
def setValue (self, value):
|
|
return self.w.checkboxSetValue(value)
|
|
|
|
def __init__(self, text, isOn = 0):
|
|
self.w = _snack.checkbox(text, isOn)
|
|
|
|
class SingleRadioButton(Widget):
|
|
"""Single Radio Button.
|
|
|
|
methods:
|
|
|
|
- SingleRadioButton(text, group, isOn = 0) : create button
|
|
- selected(self) : returns bool, whether or not is selected.
|
|
"""
|
|
|
|
def selected(self):
|
|
return self.w.key == self.w.radioValue;
|
|
|
|
def __init__(self, text, group, isOn = 0):
|
|
if group:
|
|
self.w = _snack.radiobutton(text, group.w, isOn)
|
|
else:
|
|
self.w = _snack.radiobutton(text, None, isOn)
|
|
|
|
class Listbox(Widget):
|
|
"""Listbox class.
|
|
|
|
methods:
|
|
|
|
- Listbox(self, height, scroll = 0, returnExit = 0, width = 0, showCursor = 0, multiple = 0, border = 0)
|
|
- insert(self, text, item, before) : insert element; before = key to item to insert before, or None.
|
|
- delete(self, item) : delete item from list.
|
|
- replace(self, text,item) : Replace a given item's text
|
|
- current(self) : returns currently selected item
|
|
- getSelection(self) : returns a list of selected items
|
|
- setCurrent(self,i tem) : select current.
|
|
- clear(self) : clear listbox
|
|
"""
|
|
|
|
def append(self, text, item):
|
|
key = self.w.listboxAddItem(text)
|
|
self.key2item[key] = item
|
|
self.item2key[item] = key
|
|
|
|
def insert(self, text, item, before):
|
|
if (not before):
|
|
key = self.w.listboxInsertItem(text, 0)
|
|
else:
|
|
key = self.w.listboxInsertItem(text, self.item2key[before])
|
|
self.key2item[key] = item
|
|
self.item2key[item] = key
|
|
|
|
def delete(self, item):
|
|
self.w.listboxDeleteItem(self.item2key[item])
|
|
del self.key2item[self.item2key[item]]
|
|
del self.item2key[item]
|
|
|
|
def replace(self, text, item):
|
|
key = self.w.listboxInsertItem(text, self.item2key[item])
|
|
self.w.listboxDeleteItem(self.item2key[item])
|
|
del self.key2item[self.item2key[item]]
|
|
self.item2key[item] = key
|
|
self.key2item[key] = item
|
|
|
|
def current(self):
|
|
return self.key2item[self.w.listboxGetCurrent()]
|
|
|
|
def getSelection(self):
|
|
selection = []
|
|
list = self.w.listboxGetSelection()
|
|
for key in list:
|
|
selection.append(self.key2item[key])
|
|
return selection
|
|
|
|
def setCurrent(self, item):
|
|
self.w.listboxSetCurrent(self.item2key[item])
|
|
|
|
def clear(self):
|
|
self.key2item = {}
|
|
self.item2key = {}
|
|
self.w.listboxClear()
|
|
|
|
def __init__(self, height, scroll = 0, returnExit = 0, width = 0, showCursor = 0, multiple = 0, border = 0):
|
|
self.w = _snack.listbox(height, scroll, returnExit, showCursor, multiple, border)
|
|
self.key2item = {}
|
|
self.item2key = {}
|
|
if (width):
|
|
self.w.listboxSetWidth(width)
|
|
|
|
class Textbox(Widget):
|
|
"""Textbox, container for text.
|
|
|
|
methods:
|
|
|
|
- Textbox(self, width, height, scroll = 0, wrap = 0): scroll, wrap are flags
|
|
include scroll bars, or text wrap.
|
|
- setText(text) : set text.
|
|
- setHeight(height): set height.
|
|
"""
|
|
|
|
def setText(self, text):
|
|
self.w.textboxText(text)
|
|
|
|
def setHeight(self, height):
|
|
self.w.textboxHeight(height)
|
|
|
|
def __init__(self, width, height, text, scroll = 0, wrap = 0):
|
|
self.w = _snack.textbox(width, height, text, scroll, wrap)
|
|
|
|
class TextboxReflowed(Textbox):
|
|
|
|
def __init__(self, width, text, flexDown = 5, flexUp = 10, maxHeight = -1):
|
|
(newtext, width, height) = reflow(text, width, flexDown, flexUp)
|
|
if maxHeight != -1 and height > maxHeight:
|
|
Textbox.__init__(self, width, maxHeight, newtext, 1)
|
|
else:
|
|
Textbox.__init__(self, width, height, newtext, 0)
|
|
|
|
class Label(Widget):
|
|
"""A Label (simple text).
|
|
|
|
methods:
|
|
|
|
- Label(self,text) : create label
|
|
- setText(self,text) : change text.
|
|
- setColors(self, colorset) : change individual colors
|
|
"""
|
|
def setText(self, text):
|
|
self.w.labelText(text)
|
|
|
|
def __init__(self, text):
|
|
self.w = _snack.label(text)
|
|
|
|
def setColors(self, colorset):
|
|
self.w.labelSetColors(colorset)
|
|
|
|
class Scale(Widget):
|
|
"""A Scale (progress bar).
|
|
|
|
methods:
|
|
|
|
- Scale(self,width, total) : create scale; width: size on screen, fullamount: integer.
|
|
- set(self,amount) : set amount to integer.
|
|
"""
|
|
def set(self, amount):
|
|
self.w.scaleSet(amount)
|
|
|
|
def __init__(self, width, total):
|
|
self.w = _snack.scale(width, total)
|
|
|
|
class Entry(Widget):
|
|
"""Entry widget.
|
|
|
|
methods:
|
|
|
|
- Entry(self, width, text = "", hidden = 0, password = 0, scroll = 1, returnExit = 0)
|
|
constructor. hidden doesn't show text, password stars it out,
|
|
scroll includes scroll bars;
|
|
if returnExit is set, return from Form when exiting this element, else
|
|
proceed to next entry widget.
|
|
- value(self): return value.
|
|
- set(text, cursorAtEnd = 1) : set the text
|
|
- setFlags (flag, sense) : flags can be FLAG_DISABLED, FLAGS_SET, FLAGS_RESET, FLAGS_TOGGLE
|
|
"""
|
|
def value(self):
|
|
return self.w.entryValue
|
|
|
|
def set(self, text, cursorAtEnd = 1):
|
|
return self.w.entrySetValue(text, cursorAtEnd)
|
|
|
|
def setFlags (self, flag, sense):
|
|
return self.w.entrySetFlags(flag, sense)
|
|
|
|
def __init__(self, width, text = "", hidden = 0, password = 0, scroll = 1,
|
|
returnExit = 0):
|
|
self.w = _snack.entry(width, text, hidden, password, scroll, returnExit)
|
|
|
|
|
|
# Form uses hotkeys
|
|
hotkeys = { "F1" : _snack.KEY_F1, "F2" : _snack.KEY_F2, "F3" : _snack.KEY_F3,
|
|
"F4" : _snack.KEY_F4, "F5" : _snack.KEY_F5, "F6" : _snack.KEY_F6,
|
|
"F7" : _snack.KEY_F7, "F8" : _snack.KEY_F8, "F9" : _snack.KEY_F9,
|
|
"F10" : _snack.KEY_F10, "F11" : _snack.KEY_F11,
|
|
"F12" : _snack.KEY_F12, "ESC" : _snack.KEY_ESC,
|
|
"ENTER": _snack.KEY_ENTER, "SUSPEND" : _snack.KEY_SUSPEND,
|
|
"BACKSPACE": _snack.KEY_BACKSPACE, "DELETE": _snack.KEY_DELETE,
|
|
"INSERT": _snack.KEY_INSERT, "RESIZE": _snack.KEY_RESIZE,
|
|
" " : ord(" ") }
|
|
|
|
for n in list(hotkeys.keys()):
|
|
hotkeys[hotkeys[n]] = n
|
|
for o,c in [ (ord(c),c) for c in string.ascii_letters+string.digits ]:
|
|
hotkeys[c] = o
|
|
hotkeys[o] = c
|
|
|
|
class Form:
|
|
""" Base Form class, from which Grid, etc. inherit
|
|
|
|
methods:
|
|
|
|
- Form(self, helpArg = None) : constructor.
|
|
- addHotKey(self, keyname) : keynames of form "F1" through "F12", "ESC"
|
|
- add(self, widget) : Add a widget
|
|
- run(self): run a form, expecting input
|
|
- draw(self): draw form.
|
|
- setTimer(self, timer) : add a timer
|
|
- watchFile(self, file, flags) : watch a named file
|
|
- setCurrent (self, co): Set a given widget as the current focus
|
|
"""
|
|
def addHotKey(self, keyname):
|
|
self.w.addhotkey(hotkeys[keyname])
|
|
|
|
def add(self, widget):
|
|
if 'hotkeys' in widget.__dict__:
|
|
for key in widget.hotkeys.keys():
|
|
self.addHotKey(key)
|
|
|
|
if 'gridmembers' in widget.__dict__:
|
|
for w in widget.gridmembers:
|
|
self.add(w)
|
|
elif 'w' in widget.__dict__:
|
|
self.trans[widget.w.key] = widget
|
|
return self.w.add(widget.w)
|
|
return None
|
|
|
|
def run(self):
|
|
(what, which) = self.w.run()
|
|
if (what == _snack.FORM_EXIT_WIDGET):
|
|
return self.trans[which]
|
|
elif (what == _snack.FORM_EXIT_TIMER):
|
|
return "TIMER"
|
|
elif (what == _snack.FORM_EXIT_FDREADY):
|
|
return self.filemap[which]
|
|
elif (what == _snack.FORM_EXIT_HOTKEY):
|
|
return hotkeys[which]
|
|
raise RuntimeError("EOF or IO error")
|
|
|
|
def draw(self):
|
|
self.w.draw()
|
|
return None
|
|
|
|
def __init__(self, helpArg = None):
|
|
self.trans = {}
|
|
self.filemap = {}
|
|
self.w = _snack.form(helpArg)
|
|
# we do the reference count for the helpArg in python! gross
|
|
self.helpArg = helpArg
|
|
|
|
def setCurrent (self, co):
|
|
self.w.setcurrent (co.w)
|
|
|
|
def setTimer (self, timer):
|
|
self.w.settimer (timer)
|
|
|
|
def watchFile (self, file, flags):
|
|
self.filemap[file.fileno()] = file
|
|
self.w.watchfd (file.fileno(), flags)
|
|
|
|
class Grid:
|
|
"""Grid class.
|
|
|
|
methods:
|
|
|
|
- place(self,x,y): Return what is placed at (x,y)
|
|
- setField(self, what, col, row, padding = (0, 0, 0, 0),
|
|
anchorLeft = 0, anchorTop = 0, anchorRight = 0,
|
|
anchorBottom = 0, growx = 0, growy = 0):
|
|
used to add widget 'what' to grid.
|
|
- Grid(self, *args): eg. g = Grid(2,3) for 2x3 grid
|
|
"""
|
|
def place(self, x, y):
|
|
return self.g.place(x, y)
|
|
|
|
def setField(self, what, col, row, padding = (0, 0, 0, 0),
|
|
anchorLeft = 0, anchorTop = 0, anchorRight = 0,
|
|
anchorBottom = 0, growx = 0, growy = 0):
|
|
self.gridmembers.append(what)
|
|
anchorFlags = 0
|
|
if (anchorLeft):
|
|
anchorFlags = _snack.ANCHOR_LEFT
|
|
elif (anchorRight):
|
|
anchorFlags = _snack.ANCHOR_RIGHT
|
|
|
|
if (anchorTop):
|
|
anchorFlags = anchorFlags | _snack.ANCHOR_TOP
|
|
elif (anchorBottom):
|
|
anchorFlags = anchorFlags | _snack.ANCHOR_BOTTOM
|
|
|
|
gridFlags = 0
|
|
if (growx):
|
|
gridFlags = _snack.GRID_GROWX
|
|
if (growy):
|
|
gridFlags = gridFlags | _snack.GRID_GROWY
|
|
|
|
if 'g' in what.__dict__:
|
|
return self.g.setfield(col, row, what.g, padding, anchorFlags,
|
|
gridFlags)
|
|
else:
|
|
return self.g.setfield(col, row, what.w, padding, anchorFlags)
|
|
|
|
def __init__(self, *args):
|
|
self.g = _snack.grid(*args)
|
|
self.gridmembers = []
|
|
|
|
colorsets = { "ROOT" : _snack.COLORSET_ROOT,
|
|
"BORDER" : _snack.COLORSET_BORDER,
|
|
"WINDOW" : _snack.COLORSET_WINDOW,
|
|
"SHADOW" : _snack.COLORSET_SHADOW,
|
|
"TITLE" : _snack.COLORSET_TITLE,
|
|
"BUTTON" : _snack.COLORSET_BUTTON,
|
|
"ACTBUTTON" : _snack.COLORSET_ACTBUTTON,
|
|
"CHECKBOX" : _snack.COLORSET_CHECKBOX,
|
|
"ACTCHECKBOX" : _snack.COLORSET_ACTCHECKBOX,
|
|
"ENTRY" : _snack.COLORSET_ENTRY,
|
|
"LABEL" : _snack.COLORSET_LABEL,
|
|
"LISTBOX" : _snack.COLORSET_LISTBOX,
|
|
"ACTLISTBOX" : _snack.COLORSET_ACTLISTBOX,
|
|
"TEXTBOX" : _snack.COLORSET_TEXTBOX,
|
|
"ACTTEXTBOX" : _snack.COLORSET_ACTTEXTBOX,
|
|
"HELPLINE" : _snack.COLORSET_HELPLINE,
|
|
"ROOTTEXT" : _snack.COLORSET_ROOTTEXT,
|
|
"EMPTYSCALE" : _snack.COLORSET_EMPTYSCALE,
|
|
"FULLSCALE" : _snack.COLORSET_FULLSCALE,
|
|
"DISENTRY" : _snack.COLORSET_DISENTRY,
|
|
"COMPACTBUTTON" : _snack.COLORSET_COMPACTBUTTON,
|
|
"ACTSELLISTBOX" : _snack.COLORSET_ACTSELLISTBOX,
|
|
"SELLISTBOX" : _snack.COLORSET_SELLISTBOX }
|
|
|
|
class SnackScreen:
|
|
"""A Screen;
|
|
|
|
methods:
|
|
|
|
- Screen(self) : constructor
|
|
- finish(self)
|
|
- resume(self)
|
|
- suspend(self)
|
|
- doHelpCallback(self,arg) call callback with arg
|
|
- helpCallback(self,cb): Set help callback
|
|
- suspendcallback(self,cb, data=None) : set callback. data=data to pass to cb.
|
|
- openWindow(self,left, top, width, height, title): Open a window.
|
|
- pushHelpLine(self,text): put help line on screen. Returns current help line if text=None
|
|
- setColor(self, colorset, fg, bg): Set foreground and background colors;
|
|
colorset = key from snack.colorsets,
|
|
fg & bg = english color names defined by S-Lang
|
|
(ref: S-Lang Library C Programmer's Guide section:
|
|
8.4.4. Setting Character Attributes)
|
|
"""
|
|
def __init__(self):
|
|
_snack.init()
|
|
(self.width, self.height) = _snack.size()
|
|
self.pushHelpLine(None)
|
|
|
|
def finish(self):
|
|
return _snack.finish()
|
|
|
|
def resume(self):
|
|
_snack.resume()
|
|
|
|
def suspend(self):
|
|
_snack.suspend()
|
|
|
|
def doHelpCallback(self, arg):
|
|
self.helpCb(self, arg)
|
|
|
|
def helpCallback(self, cb):
|
|
self.helpCb = cb
|
|
return _snack.helpcallback(self.doHelpCallback)
|
|
|
|
def suspendCallback(self, cb, data = None):
|
|
if data:
|
|
return _snack.suspendcallback(cb, data)
|
|
return _snack.suspendcallback(cb)
|
|
|
|
def openWindow(self, left, top, width, height, title):
|
|
return _snack.openwindow(left, top, width, height, title)
|
|
|
|
def pushHelpLine(self, text):
|
|
if (not text):
|
|
return _snack.pushhelpline("*default*")
|
|
else:
|
|
return _snack.pushhelpline(text)
|
|
|
|
def popHelpLine(self):
|
|
return _snack.pophelpline()
|
|
|
|
def drawRootText(self, left, top, text):
|
|
return _snack.drawroottext(left, top, text)
|
|
|
|
def centeredWindow(self, width, height, title):
|
|
return _snack.centeredwindow(width, height, title)
|
|
|
|
def gridWrappedWindow(self, grid, title, x = None, y = None):
|
|
if x and y:
|
|
return _snack.gridwrappedwindow(grid.g, title, x, y)
|
|
|
|
return _snack.gridwrappedwindow(grid.g, title)
|
|
|
|
def popWindow(self, refresh = True):
|
|
if refresh:
|
|
return _snack.popwindow()
|
|
return _snack.popwindownorefresh()
|
|
|
|
def refresh(self):
|
|
return _snack.refresh()
|
|
|
|
def setColor(self, colorset, fg, bg):
|
|
if colorset in colorsets:
|
|
return _snack.setcolor(colorsets[colorset], fg, bg)
|
|
else:
|
|
# assume colorset is an integer for the custom color set
|
|
return _snack.setcolor(colorset, fg, bg)
|
|
|
|
def reflow(text, width, flexDown = 5, flexUp = 5):
|
|
""" returns a tuple of the wrapped text, the actual width, and the actual height
|
|
"""
|
|
return _snack.reflow(text, width, flexDown, flexUp)
|
|
|
|
# combo widgets
|
|
|
|
class RadioGroup(Widget):
|
|
""" Combo widget: Group of Radio buttons
|
|
|
|
methods:
|
|
|
|
- RadioGroup(self): constructor.
|
|
- add(self,title, value, default = None): add a button. Returns button.
|
|
- getSelection(self) : returns value of selected button | None
|
|
"""
|
|
def __init__(self):
|
|
self.prev = None
|
|
self.buttonlist = []
|
|
|
|
def add(self, title, value, default = None):
|
|
if not self.prev and default == None:
|
|
# If the first element is not explicitly set to
|
|
# not be the default, make it be the default
|
|
default = 1
|
|
b = SingleRadioButton(title, self.prev, default)
|
|
self.prev = b
|
|
self.buttonlist.append((b, value))
|
|
return b
|
|
|
|
def getSelection(self):
|
|
for (b, value) in self.buttonlist:
|
|
if b.selected(): return value
|
|
return None
|
|
|
|
|
|
class RadioBar(Grid):
|
|
""" Bar of Radio buttons, based on Grid.
|
|
|
|
methods:
|
|
|
|
- RadioBar(self, screen, buttonlist) : constructor.
|
|
- getSelection(self): return value of selected button
|
|
"""
|
|
|
|
def __init__(self, screen, buttonlist):
|
|
self.list = []
|
|
self.item = 0
|
|
self.group = RadioGroup()
|
|
Grid.__init__(self, 1, len(buttonlist))
|
|
for (title, value, default) in buttonlist:
|
|
b = self.group.add(title, value, default)
|
|
self.list.append((b, value))
|
|
self.setField(b, 0, self.item, anchorLeft = 1)
|
|
self.item = self.item + 1
|
|
|
|
def getSelection(self):
|
|
return self.group.getSelection()
|
|
|
|
|
|
# you normally want to pack a ButtonBar with growx = 1
|
|
|
|
class ButtonBar(Grid):
|
|
""" Bar of buttons, based on grid.
|
|
|
|
methods:
|
|
|
|
- ButtonBar(screen, buttonlist,buttonlist, compact = 0):
|
|
- buttonPressed(self, result): Takes the widget returned by Form.run and looks to see
|
|
if it was one of the widgets in the ButtonBar.
|
|
"""
|
|
def __init__(self, screen, buttonlist, compact = 0):
|
|
self.list = []
|
|
self.hotkeys = {}
|
|
self.item = 0
|
|
Grid.__init__(self, len(buttonlist), 1)
|
|
for blist in buttonlist:
|
|
if isinstance(blist, str if sys.version >= '3' else basestring):
|
|
title = blist
|
|
value = blist.lower()
|
|
elif len(blist) == 2:
|
|
(title, value) = blist
|
|
else:
|
|
(title, value, hotkey) = blist
|
|
self.hotkeys[hotkey] = value
|
|
|
|
if compact:
|
|
b = CompactButton(title)
|
|
else:
|
|
b = Button(title)
|
|
self.list.append((b, value))
|
|
self.setField(b, self.item, 0, (1, 0, 1, 0))
|
|
self.item = self.item + 1
|
|
|
|
def buttonPressed(self, result):
|
|
if result in self.hotkeys:
|
|
return self.hotkeys[result]
|
|
|
|
for (button, value) in self.list:
|
|
if result == button:
|
|
return value
|
|
return None
|
|
|
|
|
|
class GridFormHelp(Grid):
|
|
""" Subclass of Grid, for the help form text.
|
|
|
|
methods:
|
|
|
|
- GridFormHelp(self, screen, title, help, *args) :
|
|
- add (self, widget, col, row, padding = (0, 0, 0, 0),
|
|
anchorLeft = 0, anchorTop = 0, anchorRight = 0,
|
|
anchorBottom = 0, growx = 0, growy = 0):
|
|
- runOnce(self, x = None, y = None): pop up the help window
|
|
- addHotKey(self, keyname):
|
|
- setTimer(self, keyname):
|
|
- create(self, x = None, y = None):
|
|
- run(self, x = None, y = None):
|
|
- draw(self):
|
|
- runPopup(self):
|
|
- setCurrent (self, co):
|
|
"""
|
|
def __init__(self, screen, title, help, *args):
|
|
self.screen = screen
|
|
self.title = title
|
|
self.form = Form(help)
|
|
self.childList = []
|
|
self.form_created = 0
|
|
args = list(args)
|
|
args[:0] = [self]
|
|
Grid.__init__(*tuple(args))
|
|
|
|
def add(self, widget, col, row, padding = (0, 0, 0, 0),
|
|
anchorLeft = 0, anchorTop = 0, anchorRight = 0,
|
|
anchorBottom = 0, growx = 0, growy = 0):
|
|
self.setField(widget, col, row, padding, anchorLeft,
|
|
anchorTop, anchorRight, anchorBottom,
|
|
growx, growy);
|
|
self.childList.append(widget)
|
|
|
|
def runOnce(self, x = None, y = None):
|
|
result = self.run(x, y)
|
|
self.screen.popWindow()
|
|
return result
|
|
|
|
def addHotKey(self, keyname):
|
|
self.form.addHotKey(keyname)
|
|
|
|
def setTimer(self, keyname):
|
|
self.form.setTimer(keyname)
|
|
|
|
def create(self, x = None, y = None):
|
|
if not self.form_created:
|
|
self.place(1,1)
|
|
for child in self.childList:
|
|
self.form.add(child)
|
|
self.screen.gridWrappedWindow(self, self.title, x, y)
|
|
self.form_created = 1
|
|
|
|
def run(self, x = None, y = None):
|
|
self.create(x, y)
|
|
return self.form.run()
|
|
|
|
def draw(self):
|
|
self.create()
|
|
return self.form.draw()
|
|
|
|
def runPopup(self):
|
|
self.create()
|
|
self.screen.gridWrappedWindow(self, self.title)
|
|
result = self.form.run()
|
|
self.screen.popWindow()
|
|
return result
|
|
|
|
def setCurrent (self, co):
|
|
self.form.setCurrent (co)
|
|
|
|
class GridForm(GridFormHelp):
|
|
""" GridForm class (extends GridFormHelp):
|
|
|
|
methods:
|
|
|
|
- GridForm(self, screen, title, *args):
|
|
"""
|
|
def __init__(self, screen, title, *args):
|
|
myargs = (self, screen, title, None) + args
|
|
GridFormHelp.__init__(*myargs)
|
|
|
|
class CheckboxTree(Widget):
|
|
""" CheckboxTree combo widget,
|
|
|
|
methods:
|
|
|
|
- CheckboxTree(self, height, scroll = 0, width = None, hide_checkbox = 0, unselectable = 0)
|
|
constructor.
|
|
- append(self, text, item = None, selected = 0):
|
|
- addItem(self, text, path, item = None, selected = 0):
|
|
- getCurrent(self):
|
|
- getSelection(self):
|
|
- setEntry(self, item, text):
|
|
- setCurrent(self, item):
|
|
- setEntryValue(self, item, selected = 1):
|
|
- getEntryValue(self, item):
|
|
"""
|
|
def append(self, text, item = None, selected = 0):
|
|
self.addItem(text, (snackArgs['append'], ), item, selected)
|
|
|
|
def addItem(self, text, path, item = None, selected = 0):
|
|
if item is None:
|
|
item = text
|
|
key = self.w.checkboxtreeAddItem(text, path, selected)
|
|
self.key2item[key] = item
|
|
self.item2key[item] = key
|
|
|
|
def getCurrent(self):
|
|
curr = self.w.checkboxtreeGetCurrent()
|
|
return self.key2item[curr]
|
|
|
|
def __init__(self, height, scroll = 0, width = None, hide_checkbox = 0, unselectable = 0):
|
|
self.w = _snack.checkboxtree(height, scroll, hide_checkbox, unselectable)
|
|
self.key2item = {}
|
|
self.item2key = {}
|
|
if (width):
|
|
self.w.checkboxtreeSetWidth(width)
|
|
|
|
def getSelection(self):
|
|
selection = []
|
|
list = self.w.checkboxtreeGetSelection()
|
|
for key in list:
|
|
selection.append(self.key2item[key])
|
|
return selection
|
|
|
|
def setEntry(self, item, text):
|
|
self.w.checkboxtreeSetEntry(self.item2key[item], text)
|
|
|
|
def setCurrent(self, item):
|
|
self.w.checkboxtreeSetCurrent(self.item2key[item])
|
|
|
|
def setEntryValue(self, item, selected = 1):
|
|
self.w.checkboxtreeSetEntryValue(self.item2key[item], selected)
|
|
|
|
def getEntryValue(self, item):
|
|
return self.w.checkboxtreeGetEntryValue(self.item2key[item])
|
|
|
|
def ListboxChoiceWindow(screen, title, text, items,
|
|
buttons = ('Ok', 'Cancel'),
|
|
width = 40, scroll = 0, height = -1, default = None,
|
|
help = None):
|
|
"""
|
|
- ListboxChoiceWindow(screen, title, text, items,
|
|
buttons = ('Ok', 'Cancel'),
|
|
width = 40, scroll = 0, height = -1, default = None,
|
|
help = None):
|
|
"""
|
|
if (height == -1): height = len(items)
|
|
|
|
bb = ButtonBar(screen, buttons)
|
|
t = TextboxReflowed(width, text)
|
|
l = Listbox(height, scroll = scroll, returnExit = 1)
|
|
count = 0
|
|
for item in items:
|
|
if type(item) == tuple:
|
|
(text, key) = item
|
|
else:
|
|
text = item
|
|
key = count
|
|
|
|
if (default == count):
|
|
default = key
|
|
elif (default == item):
|
|
default = key
|
|
|
|
l.append(text, key)
|
|
count = count + 1
|
|
|
|
if (default != None):
|
|
l.setCurrent (default)
|
|
|
|
g = GridFormHelp(screen, title, help, 1, 3)
|
|
g.add(t, 0, 0)
|
|
g.add(l, 0, 1, padding = (0, 1, 0, 1))
|
|
g.add(bb, 0, 2, growx = 1)
|
|
|
|
rc = g.runOnce()
|
|
|
|
return (bb.buttonPressed(rc), l.current())
|
|
|
|
def ButtonChoiceWindow(screen, title, text,
|
|
buttons = [ 'Ok', 'Cancel' ],
|
|
width = 40, x = None, y = None, help = None):
|
|
"""
|
|
- ButtonChoiceWindow(screen, title, text,
|
|
buttons = [ 'Ok', 'Cancel' ],
|
|
width = 40, x = None, y = None, help = None):
|
|
"""
|
|
bb = ButtonBar(screen, buttons)
|
|
t = TextboxReflowed(width, text, maxHeight = screen.height - 12)
|
|
|
|
g = GridFormHelp(screen, title, help, 1, 2)
|
|
g.add(t, 0, 0, padding = (0, 0, 0, 1))
|
|
g.add(bb, 0, 1, growx = 1)
|
|
return bb.buttonPressed(g.runOnce(x, y))
|
|
|
|
def EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
|
|
entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
|
|
"""
|
|
EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
|
|
entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
|
|
"""
|
|
bb = ButtonBar(screen, buttons);
|
|
t = TextboxReflowed(width, text)
|
|
|
|
count = 0
|
|
for n in prompts:
|
|
count = count + 1
|
|
|
|
sg = Grid(2, count)
|
|
|
|
count = 0
|
|
entryList = []
|
|
for n in prompts:
|
|
if type(n) == tuple:
|
|
(n, e) = n
|
|
if isinstance(e, str if sys.version >= '3' else basestring):
|
|
e = Entry(entryWidth, e)
|
|
else:
|
|
e = Entry(entryWidth)
|
|
|
|
sg.setField(Label(n), 0, count, padding = (0, 0, 1, 0), anchorLeft = 1)
|
|
sg.setField(e, 1, count, anchorLeft = 1)
|
|
count = count + 1
|
|
entryList.append(e)
|
|
|
|
g = GridFormHelp(screen, title, help, 1, 3)
|
|
|
|
g.add(t, 0, 0, padding = (0, 0, 0, 1))
|
|
g.add(sg, 0, 1, padding = (0, 0, 0, 1))
|
|
g.add(bb, 0, 2, growx = 1)
|
|
|
|
result = g.runOnce()
|
|
|
|
entryValues = []
|
|
count = 0
|
|
for n in prompts:
|
|
entryValues.append(entryList[count].value())
|
|
count = count + 1
|
|
|
|
return (bb.buttonPressed(result), tuple(entryValues))
|
|
|
|
class CListbox(Grid):
|
|
"""Clistbox convenience class.
|
|
|
|
methods:
|
|
|
|
- Clistbox(self, height, cols, cols_widths, scroll = 0) : constructor
|
|
- colFormText(self, col_text, align = None, adjust_width = 0) : column text.
|
|
- append(self, col_text, item, col_text_align = None) :
|
|
- insert(self, col_text, item, before, col_text_align = None)
|
|
- delete(self, item)
|
|
- replace(self, col_text, item, col_text_align = None)
|
|
- current(self) : returns current item
|
|
- setCurrent(self, item): sets an item as current
|
|
- clear(self): clear the listbox
|
|
|
|
Alignments may be LEFT, RIGHT, CENTER, None
|
|
"""
|
|
def __init__(self, height, cols, col_widths, scroll = 0,
|
|
returnExit = 0, width = 0, col_pad = 1,
|
|
col_text_align = None, col_labels = None,
|
|
col_label_align = None, adjust_width=0):
|
|
|
|
self.cols = cols
|
|
self.col_widths = col_widths[:]
|
|
self.col_pad = col_pad
|
|
self.col_text_align = col_text_align
|
|
|
|
if col_labels != None:
|
|
Grid.__init__(self, 1, 2)
|
|
box_y = 1
|
|
|
|
lstr = self.colFormText(col_labels, col_label_align,
|
|
adjust_width=adjust_width)
|
|
self.label = Label(lstr)
|
|
self.setField(self.label, 0, 0, anchorLeft=1)
|
|
|
|
else:
|
|
Grid.__init__(self, 1, 1)
|
|
box_y = 0
|
|
|
|
|
|
self.listbox = Listbox(height, scroll, returnExit, width)
|
|
self.setField(self.listbox, 0, box_y, anchorRight=1)
|
|
|
|
def colFormText(self, col_text, align = None, adjust_width=0):
|
|
i = 0
|
|
str = ""
|
|
c_len = len(col_text)
|
|
while (i < self.cols) and (i < c_len):
|
|
|
|
cstr = col_text[i]
|
|
cstrlen = _snack.wstrlen(cstr)
|
|
if self.col_widths[i] < cstrlen:
|
|
if adjust_width:
|
|
self.col_widths[i] = cstrlen
|
|
else:
|
|
cstr = cstr[:self.col_widths[i]]
|
|
|
|
delta = self.col_widths[i] - _snack.wstrlen(cstr)
|
|
|
|
if delta > 0:
|
|
if align == None:
|
|
a = LEFT
|
|
else:
|
|
a = align[i]
|
|
|
|
if a == LEFT:
|
|
cstr = cstr + (" " * delta)
|
|
if a == CENTER:
|
|
cstr = (" " * (delta / 2)) + cstr + \
|
|
(" " * ((delta + 1) / 2))
|
|
if a == RIGHT:
|
|
cstr = (" " * delta) + cstr
|
|
|
|
if i != c_len - 1:
|
|
pstr = (" " * self.col_pad)
|
|
else:
|
|
pstr = ""
|
|
|
|
str = str + cstr + pstr
|
|
|
|
i = i + 1
|
|
|
|
return str
|
|
|
|
def append(self, col_text, item, col_text_align = None):
|
|
if col_text_align == None:
|
|
col_text_align = self.col_text_align
|
|
text = self.colFormText(col_text, col_text_align)
|
|
self.listbox.append(text, item)
|
|
|
|
def insert(self, col_text, item, before, col_text_align = None):
|
|
if col_text_align == None:
|
|
col_text_align = self.col_text_align
|
|
text = self.colFormText(col_text, col_text_align)
|
|
self.listbox.insert(text, item, before)
|
|
|
|
def delete(self, item):
|
|
self.listbox.delete(item)
|
|
|
|
def replace(self, col_text, item, col_text_align = None):
|
|
if col_text_align == None:
|
|
col_text_align = self.col_text_align
|
|
text = self.colFormText(col_text, col_text_align)
|
|
self.listbox.replace(text, item)
|
|
|
|
def current(self):
|
|
return self.listbox.current()
|
|
|
|
def setCurrent(self, item):
|
|
self.listbox.setCurrent(item)
|
|
|
|
def clear(self):
|
|
self.listbox.clear()
|
|
|
|
def customColorset(x):
|
|
return 30 + x
|