def main():
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_size_request(width, height)
window.connect("delete_event", gtk.mainquit)
vbox = gtk.VBox()
hbox = gtk.HBox()
w_e = gtk.Entry(max=64)
hbox.add(w_e)
hbox.add(gtk.Label("x"))
h_e = gtk.Entry(max=64)
hbox.add(h_e)
set_size_btn = gtk.Button("set size")
def set_size(*args):
w = int(w_e.get_text())
h = int(h_e.get_text())
print("resizing to %s x %s" % (w, h))
window.resize(w, h)
set_size_btn.connect('clicked', set_size)
hbox.add(set_size_btn)
vbox.add(hbox)
btn = gtk.Button("auto resize me")
def resize(*args):
global width, height
width = max(200, (width+20) % 600)
height = max(200, (height+20) % 400)
print("resizing to %s x %s" % (width, height))
window.resize(width, height)
btn.connect('clicked', resize)
vbox.add(btn)
window.add(vbox)
window.show_all()
gtk.main()
return 0
def main(self): parser = SafeConfigParser() try: parser.read(self.base_folder + '/' + self.CONFIG_FILENAME) self.server = parser.get(self.CONFIG_SECTION, 'server') self.port = parser.getint(self.CONFIG_SECTION, 'port') self.user = parser.get(self.CONFIG_SECTION, 'user') self.password = parser.get(self.CONFIG_SECTION, 'password') self.timeout = parser.getint(self.CONFIG_SECTION, 'timeout') rpc_interval = parser.getint(self.CONFIG_SECTION, 'rpc_interval') except Exception as e : print( e ); self.displayErrorAndExit( "Could not read configuration '"+self.CONFIG_FILENAME+"'\nError is: "+e.message) if parser.has_option(self.CONFIG_SECTION, "rpc_logger_level"): transmissionrpc.utils.add_stdout_logger(parser.get(self.CONFIG_SECTION, 'rpc_logger_level')); self.check_alt_speed_enabled() # The callback function is called repeatedly until it returns False, # at which point the timeout is automatically destroyed and the function will not be called again # http://www.pygtk.org/pygtk2reference/gobject-functions.html#function-gobject--timeout-add gtk.timeout_add( rpc_interval * 1000, self.check_alt_speed_enabled) gtk.main()
def test_select_clientmessage_and_xselectinput(self):
self.evs = []
self.w = self.window()
gtk.gdk.flush()
l.add_event_receiver(self.w, self)
l.add_event_receiver(self.root(), self)
data = (0x01020304, 0x05060708, 0x090a0b0c, 0x0d0e0f10, 0x11121314)
l.sendClientMessage(self.root(), False, 0, "NOMASK", *data)
l.sendClientMessage(self.w, False, 0, "NOMASK", *data)
gtk.main()
# Should have gotten message to w, not to root
assert len(self.evs) == 1
ev = self.evs[0]
assert ev.window is self.w
assert ev.message_type == "NOMASK"
assert ev.format == 32
assert ev.data == data
self.evs = []
l.sendClientMessage(self.root(), False, l.const["Button1MotionMask"],
"BAD", *data)
l.addXSelectInput(self.root(), l.const["Button1MotionMask"])
l.sendClientMessage(self.root(), False, l.const["Button1MotionMask"],
"GOOD", *data)
gtk.main()
assert len(self.evs) == 1
ev = self.evs[0]
assert ev.window is self.root()
assert ev.message_type == "GOOD"
assert ev.format == 32
assert ev.data == data
def start(name):
global logfilename, logfile, gui
logfilename = name
logfile = file(logfilename, "w")
gobject.io_add_watch(sys.stdin, gobject.IO_IN, inputhandler)
gui = GUI()
gtk.main()
def main():
parser = ConfigParser.SafeConfigParser()
config_path = os.path.join(os.getenv('HOME'), '.luksmounter')
if not parser.read(config_path):
raise Exception('Could not read configuration file: %s' % config_path)
MounterWindow(parser)
gtk.main()
def main(args):
if len(args) < 1:
print("usage: pyftinspect font...", file=sys.stderr)
sys.exit(1)
for arg in args:
Inspect(arg)
gtk.main()
def test_event_routing(self):
w1 = self.window()
w2 = self.window()
w2.reparent(w1, 0, 0)
results = set()
r1 = _EventRoutingReceiver(1, results)
r2 = _EventRoutingReceiver(2, results)
r3 = _EventRoutingReceiver(3, results)
r4 = _EventRoutingReceiver(4, results)
l.add_event_receiver(w1, r1)
l.add_event_receiver(w1, r2)
l.add_event_receiver(w2, r3)
l.add_event_receiver(w2, r4)
w1.set_events(gtk.gdk.SUBSTRUCTURE_MASK)
w2.set_events(gtk.gdk.STRUCTURE_MASK)
w2.show()
while len(results) != 4:
gtk.main()
w2.hide()
assert results == set([("child-map", 1), ("child-map", 2),
("map", 3), ("map", 4)])
l.remove_event_receiver(w1, r2)
l.remove_event_receiver(w2, r4)
results.clear()
w2.show()
while len(results) != 2:
gtk.main()
assert results == set([("child-map", 1), ("map", 3)])
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
global fin
Ventana.__init__(self, 'consulta_albaranesFacturados.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
"b_exportar/clicked": self.exportar}
self.add_connections(connections)
cols = (('Fecha','gobject.TYPE_STRING', False, True, False, None),
('Nº Albarán','gobject.TYPE_STRING', False, True, True, None),
('Cliente','gobject.TYPE_STRING', False, True, False, None),
('Num. Factura','gobject.TYPE_STRING', False, True, False,None),
('Idalbaran','gobject.TYPE_INT64', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_albaran)
temp = time.localtime()
self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
self.wids['rb_salida'].set_active(True)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'albaranes_de_entrada_repuestos.glade', objeto, usuario = self.usuario)
connections = {'b_nuevo/clicked': self.crear_nuevo_albaran,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_buscar/clicked': self.buscar_albaran,
'b_fecha/clicked': self.buscar_fecha,
'b_add_ldv/clicked': self.add_repuesto,
'b_drop_ldv/clicked': self.drop_producto,
'b_add_pedido/clicked': self.add_pedido,
'b_borrar/clicked': self.borrar_albaran,
'b_imprimir/clicked': self.imprimir,
'b_salir/clicked': self.salir,
'cbe_almacen/changed': self.guardar
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
self.clase = self.CLASE
Ventana.__init__(self, self.VENTANA, objeto)
self.dic_campos = self.__build_dic_campos()
self.adaptador = adapter.adaptar_clase(self.clase, self.dic_campos)
connections = {'b_salir/clicked': self.salir,
'b_nuevo/clicked': self.nuevo,
'b_borrar/clicked': self.borrar,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_buscar/clicked': self.buscar,
# XXX: Más widgets y señales si se necesitan.
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
gtk.main()
def __init__(self, app):
self._app = app
self._app.dew = self
icons = gtk.IconTheme()
app_icon = "tray"
try:
assert icons.has_icon(app_icon)
except AssertionError:
app_icon = "/tmp/tray.png"
icon = pkg_resources.resource_string(__name__, 'resources/tray/tray.png')
f = open(app_icon, "w")
f.write(icon)
f.close()
if not hasattr(self._app, 'statusIcon'):
self._app.statusIcon = appindicator.Indicator('Dewdrop', app_icon, appindicator.CATEGORY_APPLICATION_STATUS)
self._app.statusIcon.set_status(appindicator.STATUS_ACTIVE)
self.init_menu()
self.dapi = DAPI()
self.dapi.auth(self._app._cfg.get('email'), self._app._cfg.get('passhash'))
self.show_hide_drop()
gtk.main()
def main(options, args):
logger = log.get_logger("example2", options=options)
# Check whether user wants to use OpenCv
if options.opencv:
from ginga import trcalc
try:
trcalc.use('opencv')
except Exception as e:
logger.warning("failed to set OpenCv preference: %s" % (str(e)))
# Check whether user wants to use OpenCL
elif options.opencl:
from ginga import trcalc
try:
trcalc.use('opencl')
except Exception as e:
logger.warning("failed to set OpenCL preference: %s" % (str(e)))
fv = FitsViewer(logger)
root = fv.get_widget()
root.show_all()
if len(args) > 0:
fv.load_file(args[0])
gtk.main()
def __init__(self, callback, realm='', username=''):
"""The constructor."""
self.callback = callback
# Set the Glade file
self.gladefile = os.path.join(PREFIX, 'share', APP, 'glade/credentialsdialog.glade')
self.wTree = gtk.glade.XML(self.gladefile, domain=APP)
# Store some important widgets
self.window = self.wTree.get_widget('CredentialsDialog')
# Set the correct label containing the realm
label = self.wTree.get_widget('Label')
label.set_text(label.get_text() % realm)
# Set provided username
self.wTree.get_widget('UsernameInput').set_text(username)
# Connect all events
events = {'on_CredentialsDialog_destroy' : self.__cancel,
'on_ButtonCancel_clicked' : self.__cancel,
'on_ButtonOk_clicked' : self.__providePassword,
}
self.wTree.signal_autoconnect(events)
# Show main window
self.window.show()
# Don't know why, but threading won't work without those two line
# I would habe expected that the main thread of nautilus has
# already called gobject.threads_init() before gtk.main()
#gobject.threads_init()
gtk.main()
def run(self):
window = gtk.Window()
self.main.__window = window
window.add(self.main.widget)
window.connect('delete-event', self.quit)
window.show_all()
gtk.main()
def main(self): """Launched the main gtk loop""" try: gtk.main() except KeyboardInterrupt: app.mainWindow.destroy() print "Exited by user"
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
global fin
Ventana.__init__(self, 'consulta_entradas_almacen.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_producto/clicked': self.buscar_producto,
'b_fecha_fin/clicked': self.set_fin}
self.add_connections(connections)
utils.rellenar_lista(self.wids['cmbe_proveedor'], [(c.id, c.nombre) for c in pclases.Proveedor.select(orderBy='nombre')])
cols = (('Proveedor', 'gobject.TYPE_STRING', False, True, False, None),
('Albarán', 'gobject.TYPE_STRING', False, True, True, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Producto', 'gobject.TYPE_STRING', False, True, True, None),
('Cantidad', 'gobject.TYPE_FLOAT', False, True, False, None),
('Precio', 'gobject.TYPE_FLOAT', False, True, False, None),
('Subtotal', 'gobject.TYPE_FLOAT', False, True, False, None),
('idldc','gobject.TYPE_STRING',False,False,False,None))
utils.preparar_listview(self.wids['tv_datos'], cols)
for ncol in (4, 5, 6):
col = self.wids['tv_datos'].get_column(ncol)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
temp = time.localtime()
self.fin = datetime.date(day = temp[2], month = temp[1], year = temp[0])
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
self.producto = None
gtk.main()
def main():
logger.info('loading configuration')
import conf
debug_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR']
parser = argparse.ArgumentParser(
description="Simple panel written in Python for holding widgets")
parser.add_argument('--verbosity', '-v', dest='verbosity',
choices=debug_levels, default=None)
args = parser.parse_args()
level = args.verbosity or getattr(conf, 'VERBOSITY', 'INFO')
if level not in debug_levels:
logger.critical('Log level %s not supported!', level)
return 1
logging.basicConfig(level=level)
logger.info('creating panel')
app = PanelWindow(position=getattr(conf, 'POSITION', None),
widgets=getattr(conf, 'WIDGETS', []))
logger.info('starting main loop')
gtk.gdk.threads_init()
with GdkLock():
gtk.main()
def start(args):
global emma_instance
debug_output = False
log_file = None
log_flush = False
skip = False
for i, arg in enumerate(args):
if skip:
skip = False
continue
if arg == "-h" or arg == "--help":
usage()
elif arg == "-d" or arg == "--debug":
debug_output = True
elif arg == "-f" or arg == "--flush":
log_flush = True
elif arg == "-l" or arg == "--log":
if i + 1 == len(args):
usage()
log_file = args[i + 1]
skip = True
else:
usage()
# this singleton will be accessible as sys.stdout!
OutputHandler(debug_output, log_file, log_flush)
emma_instance = Emma()
emma_instance.start()
gtk.main()
return 0
def main():
"""Run the program."""
# Check for --loglevel, --debug, we deal with them by ourselves because
# option parser also use logging.
loglevel = None
for idx, arg in enumerate(sys.argv):
if '--loglevel' in arg:
if '=' in arg:
loglevel = arg.split('=')[1]
else:
loglevel = sys.argv[idx + 1]
level = getattr(logging, loglevel.upper(), None)
if level is None:
raise ValueError('Invalid log level: %s' % loglevel)
loglevel = level
else:
if '--debug' in sys.argv or '-d' in sys.argv:
loglevel = logging.DEBUG
logging.basicConfig(
level=loglevel,
format='%(filename)s [%(lineno)d]: %(levelname)s %(message)s')
if loglevel is None:
# Disabling warning, info, debug messages
logging.disable(logging.WARNING)
opts = create_options()
desc = 'Usage: %prog [Options...]'
opts.parse_args(desc, sys.argv)
keymon = KeyMon(opts)
try:
gtk.main()
except KeyboardInterrupt:
keymon.quit_program()
def main():
gtk.gdk.threads_init()
gui = GUI()
gui.window.connect('destroy', gtk.main_quit)
gui.window.show()
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'resultados_fibra.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self._salir,
'b_lote/clicked': self.set_loteCem,
'b_fecha/clicked': self.fecha,
'b_add/clicked': self.add,
'b_drop/clicked': self.drop,
'sp_tolerancia/value-changed': self.cambiar_tolerancia,
'b_guardar_obs/clicked': self.guardar_obs,
'b_imprimir/clicked': self.imprimir,
'ventana/delete_event': self._salir
}
self.add_connections(connections)
self.activar_widgets(False)
self.inicializar_ventana()
if objeto == None:
self.loteCem = None
else:
self.loteCem = objeto
self.actualizar_ventana()
gtk.main()
def __init__(self, file_paths, platform):
"""
ActionHandler constructor.
Create the main window, setup the message handler, import the preferences,
and connect all of the action handlers. Finally, enter the gtk main loop and block.
@param file_paths a list of flow graph file passed from command line
@param platform platform module
"""
self.clipboard = None
for action in Actions.get_all_actions(): action.connect('activate', self._handle_action)
#setup the main window
self.main_window = MainWindow(platform)
self.main_window.connect('delete-event', self._quit)
self.main_window.connect('key-press-event', self._handle_key_press)
self.get_page = self.main_window.get_page
self.get_flow_graph = self.main_window.get_flow_graph
self.get_focus_flag = self.main_window.get_focus_flag
#setup the messages
Messages.register_messenger(self.main_window.add_report_line)
Messages.send_init(platform)
#initialize
self.init_file_paths = file_paths
Actions.APPLICATION_INITIALIZE()
#enter the mainloop
gtk.main()
def main():
import logging
logging.basicConfig(format="%(message)s")
logging.root.setLevel(logging.DEBUG)
gl_backing_test(gl_client_window_class=GLSimpleClientWindow, w=640, h=480)
gtk.main()
def __init__(self, clase, objeto = None, usuario = None):
"""
Recibe la clase base para construir la ventana.
Opcionalmente recibe un objeto para mostrar en la misma y
el usuario registrado en el sistema.
Construye la ventana e inicia el bucle Gtk.
"""
self.usuario = usuario
self.clase = clase
self.objeto = objeto
ventana_marco = os.path.join('..', 'formularios', 'ventana_generica.glade')
Ventana.__init__(self, ventana_marco, objeto, usuario)
# Botones genéricos:
connections = {'b_salir/clicked': self.salir,
'b_actualizar/clicked': self.actualizar_ventana,
'b_nuevo/clicked': self.nuevo,
'b_borrar/clicked': self.borrar,
'b_buscar/clicked': self.buscar,
'b_guardar/clicked': self.guardar
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(self.objeto)
gtk.main()
def run(self):
"""Start Nex"""
splash = Splash(self.appath)
splash.show_all()
gobject.timeout_add(1000, splash.hide) # 5*1000 miliseconds
gobject.idle_add(self.setup_app)
gtk.main()
def __init__(self, objeto=None, usuario=None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, os.path.join("ui",
'cobro_facturas_venta.glade'), objeto)
connections = {'b_salir/clicked': self.salir,
'b_add_cobro/clicked': self.add_cobro,
'b_remove_cobro/clicked': self.remove_cobro}
self.add_connections(connections)
cols = (('ID', 'gobject.TYPE_INT', False, True, True, None),
('Número', 'gobject.TYPE_STRING', False, True, True, None),
('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Importe', 'gobject.TYPE_STRING', False, True, False, None),
('Estado', 'gobject.TYPE_STRING', False, True, False, None),
('Fecha vto', 'gobject.TYPE_STRING', False, True, False, None),
('Pagado en', 'gobject.TYPE_STRING', False, True, False, None),
('id', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
#self.wids['tv_datos'].connect("row-activated", self.abrir_factura,
# self.usuario, self)
col = self.wids['tv_datos'].get_column(3)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col = self.wids['tv_datos'].get_column(4)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 0.5)
self.rellenar_widgets()
self.wids['ventana'].resize(800, 600)
gtk.main()
def draw_gtk(p):
win = gtk.Window()
win.set_title('Family tree')
win.connect('destroy', lambda widget: gtk.main_quit())
sw = gtk.ScrolledWindow()
win.add(sw)
da = gtk.DrawingArea()
def draw(widget, event):
global ctx
ctx = da.window.cairo_create()
draw_tree(p)
w = int(p.get('w') + 1)
h = int(p.get('h') + 1)
da.set_size_request(w, h)
w = min(w, 1200)
sw.set_size_request(w, h + 60)
da.connect('expose_event', draw)
sw.add_with_viewport(da)
win.show_all()
gtk.main()
def main():
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_name("Test Input")
vbox = gtk.VBox(False, 0)
window.add(vbox)
vbox.show()
window.connect("destroy", lambda w: gtk.main_quit())
# Create the drawing area
drawing_area = gtk.DrawingArea()
drawing_area.set_size_request(200, 200)
vbox.pack_start(drawing_area, True, True, 0)
# now let's draw a point
style = drawing_area.get_style()
gc = style.fg_gc[gtk.STATE_NORMAL]
drawing_area.show()
window.show()
drawing_area.window.draw_point(gc, 20, 30)
gtk.main()
return 0
def input_box(title="Input Box", message="", default_text='',
modal= True):
win = EntryDialog(message, default_text, modal=modal)
win.set_title(title)
win.show()
gtk.main()
return win.ret
def run(self):
try:
gtk.gdk.threads_init()
self.window.show()
gtk.main()
finally:
self.shutdown()
def main(self):
self.thread.start()
gtk.gdk.threads_init() ## run threads
gtk.main()
def main():
gtk.main()
gtkmvc3.adapters.containers.watch_items_in_tree(self.list)
def on_button1__clicked(self, widget):
self.undo.undo()
def on_button2__clicked(self, widget):
self.undo.redo()
def on_button3__clicked(self, widget):
self.undo.begin_grouping()
for row in self.list:
row[0].hours = int(random.random() * 10)
self.undo.set_action_name("random hours")
self.undo.end_grouping()
def on_window1__delete_event(self, widget, event):
gtk.main_quit()
def register_adapters(self):
self.setup_columns()
adapt_availability(self.undo, 'undoable', self.view['button1'])
adapt_availability(self.undo, 'redoable', self.view['button2'])
adapt_label(self.undo, 'undo_label', self.view['button1'])
adapt_label(self.undo, 'redo_label', self.view['button2'])
Controller(gtkmvc3.Model(), gtkmvc3.View(builder='undo.ui'), handlers='class')
gtk.main()
def run(self):
gtk.main()
def main():
ApplicationMainWindow()
gtk.main()
def main(self):
gtk.gdk.threads_enter()
self.create()
gtk.main()
gtk.gdk.threads_leave()
def mainLoop():
gtk.main()
def startGUI(self):
print "GUI Started"
## Main Window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_border_width(10)
self.version = self.settings.get_version()
self.window.set_title("Shredder " + self.version)
self.window.set_default_size(650, 400)
self.window.connect("destroy", self.destroy)
self.window.set_icon_from_file(
util().get_resource("img/shredder256.png"))
## Toolbar
self.toolbar = gtk.Toolbar()
self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
self.toolbar.set_style(gtk.TOOLBAR_BOTH)
self.toolbar.set_border_width(5)
## Labels
self.statuslbl = gtk.Label("Idle")
self.statuslbl.set_line_wrap(True)
self.iterationlbl = gtk.Label("Shred Iterations: ")
self.zerolbl = gtk.Label("Zero-ing: ")
self.removelbl = gtk.Label("Remove: ")
## Spin Buttons
self.adjustments = gtk.Adjustment(
int(self.settings.get_shred_iterations()), 1,
sys.float_info.max, 1, 10, 0)
self.check_iterations = gtk.SpinButton()
self.check_iterations.set_adjustment(self.adjustments)
## Image Icons
# Shred image
self.shredimg = gtk.Image()
self.shredimg.set_from_file(
util().get_resource("img/shredder24.png"))
# Filechooser image
self.fileimg = gtk.Image()
self.fileimg.set_from_file(util().get_resource("img/file.png"))
# Folderchooser image
self.folderimg = gtk.Image()
self.folderimg.set_from_file(util().get_resource("img/folder.png"))
# Trash image
self.trashimg = gtk.Image()
self.trashimg.set_from_file(util().get_resource("img/trash.png"))
# Remove image
self.rmimg = gtk.Image()
self.rmimg.set_from_file(util().get_resource("img/remove.png"))
# Clear image
self.clrimg = gtk.Image()
self.clrimg.set_from_file(util().get_resource("img/clear.png"))
# Preferences image
self.prefimg = gtk.Image()
self.prefimg.set_from_file(
util().get_resource("img/preferences.png"))
# About image
self.abtimg = gtk.Image()
self.abtimg.set_from_file(util().get_resource("img/about.png"))
## Check Boxes
self.zero = gtk.CheckButton(label=None)
self.zero.set_active(self.settings.is_zero())
self.remove = gtk.CheckButton(label=None)
self.remove.set_active(self.settings.is_remove_shredded())
## Tree with scrolling
self.scrolltree = gtk.ScrolledWindow()
self.liststore = gtk.ListStore(str)
self.tree = gtk.TreeView(self.liststore)
self.cell = gtk.CellRendererText()
self.tvcolumn = gtk.TreeViewColumn(
"Files and folders for shredding... (You can drag and drop files and folders below)",
self.cell,
text=0)
self.tree.append_column(self.tvcolumn)
self.tree.enable_model_drag_source(
gtk.gdk.BUTTON1_MASK, self.TARGETS,
gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_MOVE)
self.tree.enable_model_drag_dest(self.TARGETS,
gtk.gdk.ACTION_DEFAULT)
self.tree.connect("drag_data_get", self.drag_data_get_data)
self.tree.connect("drag_data_received",
self.drag_data_received_data)
self.scrolltree.add(self.tree)
## Adding items to toolbar
self.toolbar.append_item("Shred", "Begin shredding files",
"Private", self.shredimg, self.do_shred)
self.toolbar.append_item("Add File", "Choose a file", "Private",
self.fileimg,
self.get_filechooser_callback)
self.toolbar.append_item("Add Folder", "Choose a folder",
"Private", self.folderimg,
self.get_folderchooser_callback)
self.toolbar.append_item("Add Trash", "Shred Trash bin", "Private",
self.trashimg, self.shred_trash)
self.toolbar.append_item("Remove Item",
"Remove file/folder from shredding list",
"Private", self.rmimg,
self.clear_selected)
self.toolbar.append_item("Clear List", "Clear shredding list",
"Private", self.clrimg,
self.clear_treeview)
self.toolbar.append_item("Preferences",
"Shredder settings and preferences",
"Private", self.prefimg,
self.on_open_pref)
self.toolbar.append_item("About", "About Shredder", "Private",
self.abtimg, self.about)
## An About Dialog, where the developers get to show off.
# If you're a contributor, please add yourself here.
self.about_dialog = gtk.AboutDialog()
self.about_dialog.set_program_name("Shredder")
self.about_dialog.set_website("http://code.google.com/p/shredder")
self.about_dialog.set_license(self.license)
self.about_dialog.set_authors([
"Tay Thotheolh <*****@*****.**>",
"Michael Rawson <*****@*****.**>"
])
self.about_dialog.set_version(self.version)
## Progress bar
self.progress = gtk.ProgressBar()
## Packing widgets into window
# Vertical box to contain all boxes
self.vbox = gtk.VBox(homogeneous=False, spacing=0)
# toolbox to contain toolbar
self.toolbox = gtk.HBox(homogeneous=False, spacing=0)
self.vbox.pack_start(self.toolbar,
expand=False,
fill=False,
padding=0)
# treebox to contain treeview
self.treebox = gtk.HBox(homogeneous=False, spacing=0)
self.vbox.pack_start(self.scrolltree,
expand=True,
fill=True,
padding=0)
# Overall VBox
self.mainbox = gtk.VBox(homogeneous=False, spacing=0)
self.mainbox.pack_start(self.vbox,
expand=True,
fill=True,
padding=0)
self.statusbox = gtk.HBox(homogeneous=False, spacing=0)
self.statusbox.pack_start(self.statuslbl,
expand=False,
fill=False,
padding=0)
self.separator = gtk.HSeparator()
self.mainbox.pack_start(self.separator,
expand=False,
fill=False,
padding=0)
self.mainbox.pack_start(self.progress,
expand=False,
fill=False,
padding=5)
self.mainbox.pack_end(self.statusbox,
expand=False,
fill=False,
padding=0)
## Presenting window
self.progress.show()
self.toolbar.show()
self.window.add(self.mainbox)
self.window.show_all()
gtk.main()
return None
def main(self):
gtk.main()
def main():
searchWindow = SearchWindow('/home/sevka')
searchWindow.show_all()
gtk.main()
return 0
def main():
# And of course, our main loop.
gtk.main()
# Control returns here when main_quit() is called
return 0
def main():
game = Game2Controller()
gtk.main()
def show(self):
self.fill()
self._window.show()
gtk.main()
self._window.hide()
def main():
UIManagerDemo()
gtk.main()
def main(self):
"""Start GTK mainloop."""
gtk.main()
def mainloop(self):
if gtk.main_level() == 0:
gtk.main()
def main(self):
self.window.show()
gtk.main()
def main():
TooltipDemo()
gtk.main()
def run(self):
""" run is called to set off the GTK mainloop """
gtk.main()
return
def main():
SpinnerDemo()
gtk.main()
def run(self):
gtk.main()
return 0
def _run():
"""
Fills the hook for L{Application.run}
"""
gtk.main()
def main(window):
"""
Test code
"""
import traceback
successors = {'a':['c','e'],
'b':['d'],
'c':[],
'd':[],
'e':['d'],
}
successors2 = {'a':['c','e','d'],
'b':['d'],
'c':['f'],
'd':['f','g'],
'e':['g'],
'f':['h'],
'g':['h'],
'h':['i','j','k'],
'i':['l'],
'j':['l'],
'k':[],
'l':[],
}
## print graph.reversed_prelation_table(pert2[0])
## for n in range(1,6):
## print inActivitiesR(pert2, graph.reversed_prelation_table(pert2[0]), n)
## print "OUT"
## for n in range(1,6):
## print outActivitiesR(pert2, n)
## window.images.append( graph.pert2image(pert4) )
## print equivalentRemovingDummy(pert4, (3,4) )
## removeDummy(pert4, (3,4) )
## pertP = pert5
## window.images.append( graph.pert2image(pertP) )
## makePrelation( pertP, (1,5), (3,4) )
## addActivity( pertP, 'nueva' )
## makePrelation( pertP, (1,2), (7,8) )
## makePrelation( pertP, (9,8), (6,4) )
# window.images.append( graph.pert2image(pert.Pert(pert4)) )
# window.images.append( graph2image(successors2) )
# window.images.append( graph2image(successors3) )
try:
pertP = Pert()
pertP.construct(successors2)
window.images.append( graph.pert2image(pertP) )
except Exception:
traceback.print_exception(*sys.exc_info())
## s = pertSuccessors(pertP)
## window.images.append( graph2image( roy(s) ) )
gtk.main()
def run(self):
self.show_all()
gtk.main()
def __init__(self, konf, svbe):
"""
:type konf: str
"""
self.konf = konf
gtk.Builder.__init__(self)
self.container = None
""" :type: Container """
self.amplitude = None
""" :type: numpy.multiarray.ndarray """
self.phase = None
""" :type: numpy.multiarray.ndarray """
self.add_from_file(os.path.join(svbe, 'laden.glade'))
self.ui = self.window('fenster_laden')
self.ff = self.window('fenster_fortschritt')
self.connect_signals({
'ende': gtk.main_quit,
'fit_starten': self.fit_starten,
'abbrechen': lambda _: Fit.stopp(),
'vorschau': self.vorschau
})
self.fortschritt = self.get_object('fortschritt')
""" :type: gtk.ProgressBar """
self.parser = DefaultParser()
self.parser.read(konf)
self.parser.getint = lambda sektion, option: int(self.parser.get(sektion, option).rsplit(',', 1)[0])
self.version = self.parser.getint(opt, 'Version')
if self.version >= 3:
self.sv = os.path.dirname(svbe)
if Dialog(self.sv).frage("Kanal", "Den gewünschten Kanal wählen:", "elstat.", "elmech."):
self.kanal = 'elstat'
else:
self.kanal = 'elmech'
else:
self.kanal = 'Untitled'
self.pixel = self.spinbutton('pixel')
self.pixel.set_value(self.parser.getint(rst, 'Pixel'))
self.dim = self.spinbutton('dim')
self.dim.set_value(self.parser.getfloat(rst, 'Dimension'))
self.df = self.spinbutton('df')
self.df.set_value(self.parser.getfloat(sgl, 'Rate') / self.parser.getfloat(sgl, 'Sample'))
self.mittelungen = self.spinbutton('mittelungen')
self.mittelungen.set_value(1)
self.fmin = self.spinbutton('fmin')
self.bereich_min = self.spinbutton('bereich_min')
fmin = self.parser.getint(sgn, 'f_start')
self.fmin.set_value(fmin)
self.bereich_min.set_value(fmin)
self.fmax = self.spinbutton('fmax')
self.bereich_max = self.spinbutton('bereich_max')
fmax = self.parser.getint(sgn, 'f_ende')
self.fmax.set_value(fmax)
self.bereich_max.set_value(fmax)
self.plotter = Plotter("Frequenz (Hz)", "Amplitude (V)")
self.get_object('vorschau').add(self.plotter)
self.ui.show_all()
gtk.main()
def main():
gtk.main()
return 0
def main():
KeyboardStateInfoWindow()
gtk.main()
def start(self):
gtk.main()
def main():
StockItemAndIconBrowserDemo()
gtk.main()
def main():
"""Run the program."""
# Check for --loglevel, --debug, we deal with them by ourselves because
# option parser also use logging.
loglevel = None
for idx, arg in enumerate(sys.argv):
if '--loglevel' in arg:
if '=' in arg:
loglevel = arg.split('=')[1]
else:
loglevel = sys.argv[idx + 1]
level = getattr(logging, loglevel.upper(), None)
if level is None:
raise ValueError('Invalid log level: %s' % loglevel)
loglevel = level
else:
if '--debug' in sys.argv or '-d' in sys.argv:
loglevel = logging.DEBUG
logging.basicConfig(
level=loglevel,
format='%(filename)s [%(lineno)d]: %(levelname)s %(message)s')
if loglevel is None:
# Disabling warning, info, debug messages
logging.disable(logging.WARNING)
opts = create_options()
opts.read_ini_file(os.path.join(settings.get_config_dir(), 'config'))
desc = _('Usage: %prog [Options...]')
opts.parse_args(desc, sys.argv)
if opts.version:
show_version()
sys.exit(0)
if opts.smaller:
opts.scale = 0.75
elif opts.larger:
opts.scale = 1.25
opts.themes = settings.get_themes()
if opts.list_themes:
print _('Available themes:')
print
theme_names = sorted(opts.themes)
name_len = max(len(name) for name in theme_names)
for theme in theme_names:
print(' - %%-%ds: %%s' % name_len) % (theme, opts.themes[theme][0])
raise SystemExit()
elif opts.theme and opts.theme not in opts.themes:
print _('Theme %r does not exist') % opts.theme
print
print _('Please make sure %r can be found in '
'one of the following directories:') % opts.theme
print
for theme_dir in settings.get_config_dirs('themes'):
print ' - %s' % theme_dir
sys.exit(-1)
if opts.reset:
print _('Resetting to defaults.')
opts.reset_to_defaults()
opts.save()
keymon = KeyMon(opts)
try:
gtk.main()
except KeyboardInterrupt:
keymon.quit_program()
