class Dan:
def __init__(self):
self.url = "http://www.bibud.com"
self.setupWindow()
self.setupBrowser()
main()
def setupWindow(self):
self.window_title = "Bibud"
self.window = Window()
self.window.show()
self.window.connect("destroy-event", self.browser_quit)
self.window.resize(1024,768)
self.window.set_title(self.window_title)
def setupBrowser(self):
self.browser = WebView()
self.browser.show()
self.browser.open(self.url)
self.scroller = ScrolledWindow()
self.scroller.add(self.browser)
self.window.add(self.scroller)
self.browser.connect("title-changed", self.title_changed)
self.scroller.show()
def eTitleChanged(self, webview, frame, title):
self.window.set_title(title)
def eQuit(self):
main_quit()
class Dan:
def __init__(self):
self.url = "http://www.bibud.com"
self.setupWindow()
self.setupBrowser()
main()
def setupWindow(self):
self.window_title = "Bibud"
self.window = Window()
self.window.show()
self.window.connect("destroy-event", self.browser_quit)
self.window.resize(1024, 768)
self.window.set_title(self.window_title)
def setupBrowser(self):
self.browser = WebView()
self.browser.show()
self.browser.open(self.url)
self.scroller = ScrolledWindow()
self.scroller.add(self.browser)
self.window.add(self.scroller)
self.browser.connect("title-changed", self.title_changed)
self.scroller.show()
def eTitleChanged(self, webview, frame, title):
self.window.set_title(title)
def eQuit(self):
main_quit()
def show(self):
import gtk
from gtk import Window, Label
w = Window()
w.set_size_request(*self.resolution)
l = gtk.Label('Coordinates')
w.add(l)
l.show()
w.add_events(gtk.gdk.EXPOSURE_MASK
| gtk.gdk.LEAVE_NOTIFY_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK)
def configure_event(widget, event):
pass
def button_release_event(widget, event):
if event.button == 1:
print "unclick"
self.server.send('u', 1, event.x, event.y)
return True
def button_press_event(widget, event):
if event.button == 1:
print "click"
self.server.send('d', 1, event.x, event.y)
return True
def motion_notify_event(widget, event):
if event.is_hint:
x, y, state = event.window.get_pointer()
else:
print "no hint"
x, y, state = event.x, event.y, event.state
l.set_text("(%d,%d)" % (x, y))
print "Event number %d, (%d,%d)" % (event.type, x, y)
self.server.send('.', 1, event.x, event.y)
return True
w.connect("configure_event", configure_event)
w.connect("motion_notify_event", motion_notify_event)
w.connect("button_press_event", button_press_event)
w.connect("button_release_event", button_release_event)
w.connect("delete_event", gtk.main_quit)
if self.fullscreen:
w.fullscreen()
w.show()
self.server.resolution = w.get_size()
gtk.main()
def show(self):
import gtk
from gtk import Window, Label
w = Window()
w.set_size_request(*self.resolution)
l = gtk.Label('Coordinates')
w.add(l)
l.show()
w.add_events(gtk.gdk.EXPOSURE_MASK
| gtk.gdk.LEAVE_NOTIFY_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK)
def configure_event(widget, event):
pass
def button_release_event(widget, event):
if event.button == 1:
print "unclick"
self.server.send('u', 1, event.x, event.y)
return True
def button_press_event(widget, event):
if event.button == 1:
print "click"
self.server.send('d', 1, event.x, event.y)
return True
def motion_notify_event(widget, event):
if event.is_hint:
x, y, state = event.window.get_pointer()
else:
print "no hint"
x, y, state = event.x, event.y, event.state
l.set_text("(%d,%d)" % (x,y))
print "Event number %d, (%d,%d)" % (event.type, x, y)
self.server.send('.', 1, event.x, event.y)
return True
w.connect("configure_event", configure_event)
w.connect("motion_notify_event", motion_notify_event)
w.connect("button_press_event", button_press_event)
w.connect("button_release_event", button_release_event)
w.connect("delete_event", gtk.main_quit)
if self.fullscreen:
w.fullscreen()
w.show()
self.server.resolution = w.get_size()
gtk.main()
def main():
print 'answer', input_entry_dialog("who what?", 'edit me')
gtk_info_message("hi there missy")
w = Window()
w.resize(200, 200)
w.connect( "delete-event", main_quit )
vbox = VBox()
w.add(vbox)
ONE_DAY = timedelta(days=1)
existing_list = [PersistentList(test_program_return_new_row())]
model, tv, tv_vbox = \
create_editable_type_defined_listview_and_model(
( ('date', date,),
('choose-me',
(True, str, 'yo', 'hi', 'me', 'fun')
), # end choose-me tuple
('choose-me-only',
(False, str, 'yo', 'hi', 'me', 'fun')
), # end choose-me-only tuple
('choose-me-num',
(False, int, 1, 2, 3, 4)
), # end choose-num tuple
('description', str),
('count', int),
('file_path', {'type': file,
'file_type':FILE_CHOOSER_ACTION_SELECT_FOLDER} ),
('choose-me-date',
(False, date,
date.today() - ONE_DAY, date.today(), date.today() + ONE_DAY ) ),
('choose-me-obj',
(False, (None, TestProgType(), TestProgType()),
'None', 'obj 1', 'obj 2' ) ),
('choose-me-Decimal',
(True, Decimal, '3.1', '3.4') ),
), # end type tuple
test_program_return_new_row, existing_list, test_prog_list_changed,
False
) # create_editable_type_defined_listview_and_model
vbox.pack_start( tv_vbox )
w.show_all()
gtk_main()
if machine not in self.pages:
self.append_page(text, machine)
self.set_current_page(machine)
def _print_items(self, machine, raw=True):
slines = _itemlines(self.cfg, machine, SYSOPTS, raw=raw)
dblines = _itemlines(self.cfg, machine, DBOPTS, raw=raw)
mnlines = _itemlines(self.cfg, machine, MAINOPTS, raw=raw)
mclines = _itemlines(self.cfg, machine, MACHOPTS, raw=raw)
umlines = _itemlines(self.cfg, machine, UMLOPTS, raw=raw)
xumlines = _itemlines(self.cfg, machine, XUMLOPTS, raw=raw)
alllines = [slines, dblines, mnlines, mclines, umlines, xumlines]
sep = '\n\n------------------\n\n'
text = sep.join(['\n'.join(lines) for lines in alllines]) + '\n'
return text
if __name__ == '__main__':
from gtk import Window
cfg = get_machines_config()
sections = cfg.sections()
print sections
#d.set_rows([dict(section=x) for x in sections])
m = MachineBrowser(cfg)
win = Window()
win.add(m)
win.show()
win.connect('destroy', mainquit)
mainloop()
self.vbox = VBox()
self.add_with_viewport(self.vbox)
HasRecordBox.__init__(self, self.vbox, data, name=name)
self.vbox.show()
self.show()
self.vbox.set_events(BUTTON_PRESS_MASK)
class CommandBox(VBox, HasMenuBar):
def __init__(self, name='CommandBox'):
VBox.__init__(self)
self.set_name(name)
self.tbar = HandleToolbar()
self.menubar = SimpleMenuBar()
self.pack_start(self.menubar, FALSE, FALSE, 0)
self.pack_end(self.tbar, FALSE, FALSE, 0)
self.show()
if __name__ == '__main__':
import paella.gtk
from gtk import mainloop, mainquit
from paella.base.util import file2str
from gtk import Window
tt = TextTemplater(file2str('/etc/debconf.conf'))
win = Window()
win.add(tt)
win.show()
win.connect('destroy', mainquit)
mainloop()
self.form = GeoForm()
self.result = GeoResult()
self.pack_start(self.form, False)
self.pack_start(self.result)
self.login = GeoCaching()
self.search = None
self.form.connect('search', self.do_search)
def do_search(self, widget, lat, long):
self.search = self.login.search_lat_long(lat, long)
for row in self.search.results:
self.result.add_cache(row)
self.result.show_all()
if __name__ == '__main__':
W = Window()
S = Search()
W.connect('destroy', main_quit)
W.set_title("Search for caches")
W.set_size_request(300, 200)
W.add(S)
W.show_all()
main()
class PointAndPick(object):
def __init__(self, title=TITLE, level=WINDOW_TOPLEVEL, on_exit=None):
self.title = title
self.grabbing = False
self.events = []
self.rgb = WHITE_RGB
self.on_exit = on_exit
self.window = Window(level)
self.window.set_title(title)
self.window.set_resizable(True)
self.window.add_events(POINTER_MOTION_MASK)
self.window.set_default_size(350, 150)
self.colors = []
grab_btn = Button('Grab')
grab_btn.connect_object('clicked', self.toggle_grab, self.window)
self.grab_btn = grab_btn
exit_btn = Button('Exit')
exit_btn.connect_object('clicked', self.destroy, self.window)
drawing = DrawingArea()
drawing.connect_object('expose_event', self.do_expose, self.window)
self.drawing = drawing
label = Label(rgb_to_string(WHITE_RGB))
self.label = label
table = Table(2, 2, True)
table.attach(self.drawing, 0, 1, 0, 1)
table.attach(label, 0, 1, 1, 2)
table.attach(grab_btn, 1, 2, 0, 1)
table.attach(exit_btn, 1, 2, 1, 2)
self.window.add(table)
def show(self):
self.window.show_all()
def destroy(self, *args, **kwargs):
self.window.hide_all()
self.window.do_destroy(self.window)
if self.on_exit:
self.on_exit()
def toggle_grab(self, *args, **kwargs):
"""Toggle pointer grabbing"""
{ True: self.ungrab, False: self.grab }[self.grabbing]()
def grab(self):
"""Grab pointer"""
if pointer_grab(self.window.window, True, GRAB_MASK) == GRAB_SUCCESS:
self.grabbing = True
self.grab_btn.set_label('Ungrab')
e = [ ('motion_notify_event', self.motion_notify_event),
('button_press_event', self.button_press_event) ]
self.events = [ self.window.connect(n, h) for n, h in e ]
def ungrab(self):
"""Ungrab pointer"""
pointer_ungrab()
while self.events:
self.window.disconnect(self.events.pop())
self.grabbing = False
self.grab_btn.set_label('Grab')
def do_expose(self, *args, **kwargs):
"""Expose the window"""
gc_obj = self.drawing.window.new_gc()
gc_obj.set_foreground(SYS_COLORMAP.alloc_color('black'))
self.drawing.window.draw_rectangle(gc_obj, False, 10, 10, 100, 100)
self.draw_color()
def draw_color(self):
"""Drag the color box with the pixel under the mouse pointer"""
gc_obj = self.drawing.window.new_gc()
gc_obj.set_foreground(SYS_COLORMAP.alloc_color(rgb_to_string(self.rgb),
True))
self.drawing.window.draw_rectangle(gc_obj, True, 11, 11, 99, 99)
def motion_notify_event(self, win, event):
"""Mouse motion_notify_event handler"""
pixbuf = Pixbuf(COLORSPACE_RGB, False, 8, 1, 1)
root = get_default_root_window()
xcoord, ycoord = event.get_root_coords()
from_draw = pixbuf.get_from_drawable(root, root.get_colormap(),
int(xcoord), int(ycoord),
0, 0, 1, 1)
pixel = from_draw.get_pixels_array()[0][0]
self.rgb = (pixel[0], pixel[1], pixel[2])
self.draw_color()
self.label.set_label(rgb_to_string(self.rgb).upper())
def button_press_event(self, *args, **kwargs):
"""Mouse button_press_event handler"""
self.ungrab()
return False
def _on_toggled(self, button):
if button.get_active():
self._do_show_popup()
else:
self._do_hide_popup()
def _on_expose(self, widget, event):
self._update_popup_geometry()
if __name__ == '__main__':
btn = PopupWidgetButton(label='TestMe', widget=gtk.Button('Click me'))
hb = gtk.HBox()
hb.pack_start(gtk.Button('Left'), expand=False, fill=False)
hb.pack_start(btn, expand=False, fill=False)
hb.pack_start(gtk.Button('Right'), expand=False, fill=False)
vb = gtk.VBox()
vb.pack_start(hb, expand=False, fill=False)
from gtk import Window
wnd = Window()
wnd.set_size_request(400, 300)
wnd.set_title('Pop-up Window Button Test')
wnd.add(vb)
wnd.connect('destroy', lambda *args: gtk.main_quit())
wnd.show_all()
gtk.main()
def shell_startup(config_path, config, bookset, startup_callback,
cmdline_options, cmdline_args):
window = Window()
def window_startup_event_handler(*args):
db_handle = bookset.get_dbhandle()
plugin_name = cmdline_args[PLUGIN_ARGUMENT]
if ( not startup_callback(
config_path, config,
null_function, null_function,
window) or
not db_handle.has_sub_database(GUI_STATE_SUB_DB) or
len(cmdline_args) < 0
):
main_quit()
window.disconnect(window_connection)
guistate = db_handle.get_sub_database(GUI_STATE_SUB_DB)
book = guistate.get_book()
if (book == None or
not book.has_enabled_frontend_plugin(plugin_name) ):
main_quit()
headless_state = db_handle.get_sub_database_do_cls_init(
HEADLESS_STATE_SUB_DB, HeadlessShellState)
plugin = book.get_frontend_plugin(plugin_name)
transaction_type_codes = tuple(plugin.get_transaction_type_codes())
if len(transaction_type_codes) == 0:
main_quit()
if (headless_state.current_transaction_id == None or
not plugin.has_transaction(headless_state.current_transaction_id)):
# check above is important because we sub index
# transaction_type_codes
type_code = (transaction_type_codes[0] if len(cmdline_args) == 1
else int(cmdline_args[TRANSACTION_TYPE_CODE_POS_ARG]) )
# if the user specifies a type code, it better be an available one
# should convert this to a warning some day
if type_code not in transaction_type_codes:
main_quit()
transaction_id, bokeep_transaction = \
instantiate_transaction_class_add_to_book_backend_and_plugin(
plugin.get_transaction_type_from_code(type_code),
plugin,
book)
headless_state.current_transaction_id = transaction_id
display_mode = TRANSACTION_ALL_EDIT_FIRST_TIME_HEADLESS
transaction.get().commit()
else:
bokeep_transaction = book.get_transaction(
headless_state.current_transaction_id)
# go through all the transaction type codes for this plugin
# and find one that provides class that matches the
# class of the existing transaction
#
# if none of them match (how could that happen, bad error!)
# we quit
#
# the implementation of the linear search is done as a generator
# expression filtered on what we're searching for
# by trying to iterate over that generator (.next()) we
# find out if anything matches because StopIteration is
# raised if nothing matches
# but we also manage to stop the iteration early when something
# does match
#
# yes, all this in the avoidance of doing some kind of
# imperitive loop with a break statement and some kind of
# check condition after...
try:
type_code = (
type_code_test
for type_code_test in transaction_type_codes
if (plugin.get_transaction_type_from_code(type_code_test)
== bokeep_transaction.__class__)
).next()
except StopIteration:
# should give an error msg
main_quit()
display_mode = TRANSACTION_ALL_EDIT_HEADLESS
def change_register_function():
book.get_backend_plugin().mark_transaction_dirty(
headless_state.current_transaction_id, bokeep_transaction)
def window_close(*args):
book.get_backend_plugin().flush_backend()
transaction.get().commit()
bookset.close()
# should change guistate (default shell persistent storage)
# to be on this specific trans id now
main_quit()
def transaction_edit_finished_function():
headless_state.set_no_current_transaction()
transaction.get().commit()
window_close()
window_vbox = VBox()
window.add(window_vbox)
display_hook = plugin.get_transaction_display_by_mode_hook(type_code)
display_hook(bokeep_transaction,
headless_state.current_transaction_id,
plugin, window_vbox,
change_register_function, book,
display_mode, transaction_edit_finished_function)
window.connect("delete_event", window_close)
window.show_all()
window_connection = window.connect(
"window-state-event", window_startup_event_handler)
window.show_all()
gtk.main()
return False
def _on_toggled(self, button):
if button.get_active():
self._do_show_popup()
else:
self._do_hide_popup()
def _on_expose(self, widget, event):
self._update_popup_geometry()
if __name__ == '__main__':
btn = PopupWidgetButton(label='TestMe', widget=gtk.Button('Click me'))
hb = gtk.HBox()
hb.pack_start(gtk.Button('Left'), expand=False, fill=False)
hb.pack_start(btn, expand=False, fill=False)
hb.pack_start(gtk.Button('Right'), expand=False, fill=False)
vb = gtk.VBox()
vb.pack_start(hb, expand=False, fill=False)
from gtk import Window
wnd = Window()
wnd.set_size_request(400, 300)
wnd.set_title('Pop-up Window Button Test')
wnd.add(vb)
wnd.connect('destroy', lambda *args: gtk.main_quit())
wnd.show_all()
gtk.main()
class Base(object):
def __init__(self):
from gtk import Window,WINDOW_TOPLEVEL,Button,Label,HBox,Entry,VBox,VSeparator
self.window = Window(WINDOW_TOPLEVEL)
self.window.set_title("Slideshow")
self.window.connect("delete_event", self.delete_event)
self.window.set_border_width(10)
self.vbox = VBox(False, 0)
self.window.add(self.vbox)
self.hbox1 = HBox(False, 0)
self.vbox.pack_start(self.hbox1, True, True, 1)
self.hbox = HBox(False, 0)
self.vbox.pack_start(self.hbox, False, False, 1)
self.hbox2 = HBox(False, 0)
self.vbox.pack_start(self.hbox2, True, True, 1)
self.label = Label('Identifikační číslo:')
self.hbox.pack_start(self.label, False, False, 1)
self.label.show()
self.editable = Entry()
self.editable.connect('key_press_event', self.key_press_event)
self.hbox.pack_start(self.editable, True, True, 1)
self.editable.show()
self.button = Button("Začít")
self.button.connect("clicked", self.callback)
self.button.set_receives_default(True)
self.button.set_can_focus(True)
self.hbox.pack_start(self.button, False, False, 1)
self.button.show()
self.hbox1.show()
self.hbox.show()
self.hbox2.show()
self.vbox.show()
self.window.show()
def delete_event(self, widget, event, data=None):
gtk.main_quit()
return False
def key_press_event(self, widget, event):
from gtk.gdk import keyval_from_name,keyval_name
if event.keyval in (keyval_from_name('Return'),keyval_from_name('KP_Enter')):
self.callback(widget)
def _getFilePaths(self, fileTypes, recursive=True):
import os
import re
from sys import argv
pt = re.compile(r'.*([%(0)s][^%(0)s]*)'%{'0':os.path.extsep})
path = [a for m,a in ((pt.match(os.path.basename(a)),a) for a in argv[1:]) if m and m.group(1) in fileTypes]
if not path:
path = '/home/pi/img/*.jpg'
if isinstance(path, str):
## Returns list containing paths of files in /path/ that are of a file type in /fileTypes/,
## if /recursive/ is False subdirectories are not checked.
paths = []
if recursive:
for root, folders, files in os.walk(path, followlinks=True):
for file in files:
for fileType in fileTypes:
if file.endswith(fileType):
paths.append(os.path.join(root, file))
else:
for item in os.listdir(path):
for fileType in fileTypes:
if item.endswith(fileType):
paths.append(os.path.join(root, item))
return paths
elif iterable(path):
return path
else:
return []
def _init_cb(self,trans):
from threading import Thread
if not iterable(trans):
trans = trans,
callbacks = []
for name,cb in trans:
t = Thread(target=cb, name='%sThread'%name)
t.daemon = True
t.start()
callbacks.append(cb.enqueue)
def wrap(msg):
for cb in callbacks:
if not cb(msg):
return False
return True
return wrap
def callback(self, widget):
from slideshow import SlideShow
from trans import Message,GpioTransceiver,JsonTransceiver
if not self.editable.get_text():
return False
img_cbs = self._init_cb([('ImgGpioCallback',GpioTransceiver(24)),('ImgJsonCallback',JsonTransceiver('img.json'))])
kp_cbs = self._init_cb([('KpGpioCallback',GpioTransceiver(26,bcd=False)),('KpJsonCallback',JsonTransceiver('kp.json'))])
def ordfnc(path):
from numpy.random import permutation
gray = path[0]
result = []
for p in permutation(path[1:]):
result.append(p)
result.append(gray)
return result
slide = SlideShow(
path=self._getFilePaths(('.jpg', '.jpeg', '.png')),
transition='None',
fullscreen=True,
delay=5,
order=ordfnc,
principal=self.editable.get_text(),
img_callback = img_cbs,
kp_callback = kp_cbs,
)
self.editable.set_text('')
slide()
def __call__(self):
gtk.main()
self.add_with_viewport(self.vbox)
HasRecordBox.__init__(self, self.vbox, data, name=name)
self.vbox.show()
self.show()
self.vbox.set_events(BUTTON_PRESS_MASK)
class CommandBox(VBox, HasMenuBar):
def __init__(self, name="CommandBox"):
VBox.__init__(self)
self.set_name(name)
self.tbar = HandleToolbar()
self.menubar = SimpleMenuBar()
self.pack_start(self.menubar, FALSE, FALSE, 0)
self.pack_end(self.tbar, FALSE, FALSE, 0)
self.show()
if __name__ == "__main__":
import paella.gtk
from gtk import mainloop, mainquit
from paella.base.util import file2str
from gtk import Window
tt = TextTemplater(file2str("/etc/debconf.conf"))
win = Window()
win.add(tt)
win.show()
win.connect("destroy", mainquit)
mainloop()
self.pack_start(self.form, False)
self.pack_start(self.result)
self.login = GeoCaching()
self.search = None
self.form.connect('search', self.do_search)
def do_search(self, widget, lat, long):
self.search = self.login.search_lat_long(lat, long)
for row in self.search.results:
self.result.add_cache(row)
self.result.show_all()
if __name__ == '__main__':
W = Window()
S = Search()
W.connect('destroy', main_quit)
W.set_title("Search for caches")
W.set_size_request(300,200)
W.add(S)
W.show_all()
main()
gtk.main_quit()
def project_cb(widget, event):
gtk.main_quit()
def study_cb(widget, event):
gtk.main_quit()
def life_cb(widget, event):
gtk.main_quit()
def other_cb(widget, event):
gtk.main_quit()
window = Window(gtk.WINDOW_TOPLEVEL)
window.connect("destroy", gtk.main_quit)
box = gtk.VBox(False, 0)
stamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
btn_same = Button("SAME")
btn_same.connect_object("button_press_event", same_cb, window)
box.pack_start(btn_same, True, True, 0)
btn_project = Button("project")
btn_project.connect_object("button_press_event", project_cb, window)
box.pack_start(btn_project, True, True, 0)
btn_study = Button("study")
btn_study.connect_object("button_press_event", study_cb, window)
