def main():
gobject.threads_init()
gtk.threads_init()
DBusGMainLoop(set_as_default=True)
session_bus = dbus.SessionBus()
system_bus = dbus.SystemBus()
name = dbus.service.BusName('org.freedesktop.Cozy', session_bus)
mainloop = gobject.MainLoop()
config = Configuration()
backup_provider = BackupProvider()
location_manager = LocationManager(config, system_bus)
backup_location = location_manager.get_backup_location()
with RestoreBackend(config, backup_provider, backup_location) as restore_backend:
standard_fallback_restore_client_loader = StandardFallbackRestoreClientLoader(config.data_path)
restore_control_center = RestoreControlCenter(restore_backend)
wait_until_event_loop_is_running_thread = WaitUntilEventLoopIsRunningThread(mainloop, restore_control_center, standard_fallback_restore_client_loader)
wait_until_event_loop_is_running_thread.start()
restore_frontend = RestoreFrontend(restore_control_center, mainloop.quit)
mainloop.run()
restore_control_center.go_to_present()
def get_instance():
if not VirtualHal.instance:
vhi = VirtualHal()
VirtualHal.instance = vhi
gtk.threads_init()
thread.start_new_thread(gtk.main, ())
return VirtualHal.instance
def main():
import logging
import gtk
settings = gtk.settings_get_default()
# Use a button ordering more consistent with Windows
print 'Use a button ordering more consistent with Windows'
settings.set_property('gtk-alternative-button-order', True)
logging.basicConfig(format='%(asctime)s [%(levelname)s:%(name)s]: '
'%(message)s', datefmt=r'%Y-%m-%d %H:%M:%S',
level=logging.INFO)
initialize_core_plugins()
from app import App
from app_context import get_app
gtk.threads_init()
gtk.gdk.threads_init()
gtk.gdk.threads_enter()
my_app = get_app()
sys.excepthook = except_handler
my_app.run()
gtk.gdk.threads_leave()
def __init__ (self):
self.letter = {}
self.guibuilder = gtk.Builder()
self.guibuilder.add_from_file("/usr/share/pyshared/sbw/ui/braille.glade")
self.window = self.guibuilder.get_object("window")
self.textview = self.guibuilder.get_object("textview")
self.label = self.guibuilder.get_object("label")
self.textbuffer = self.textview.get_buffer()
self.language_and_code = {}
self.punctuation_and_name = {".":"Dot","!":"Exclamation",":":"Colon",",":"Coma","-":"Hyphen",";":"Semi-Colon",
"?":"Question-mark","'":"quote/apostrophe","(":"Opening bracket",")":"Closing bracket","<":"Lessthan",">":"Greaterthan","[":"Left square bracket",
"]":"Right square bracket","{":"Left Brace","}":"Right Brace",'"':"Double Quote"}
self.delete_list = {'minus','backslash','equal','bracketright','bracketleft','apostrophe',\
'slash','period','comma','grave','exclam','at','numbersign','dollar','percent','asciicircum','ampersand'\
,'asterisk','parenleft','parenright','underscore','plus','bar','braceright','braceleft','quotedbl','colon',\
'question','greater','less'}
self.language_code_one = {"english":0,"spanish":1,"hindi":2,"malayalam":3,"tamil":4,"kannada":5}
self.language_code_two = {0:"english",1:"spanish",2:"hindi",3:"malayalam",4:"tamil",5:"kannada"}
self.get_configuration()
self.activate_configuration()
self.capitol_switch = False
self.run = 0
self.c_count = 0
self.stick = False
#Language and contractions
self.dot_one_three_five_six_language_list = {"malayalam"}
self.dot_one_five_six_language_list = {"malayalam"}
self.dot_three_language_list = {"malayalam"}
self.dot_three_six_language_list = {"malayalam","hindi"}
self.dot_four_language_list = {"english"}
self.dot_four_five_language_list = {"english"}
self.dot_four_five_six_language_list = {"english"}
self.dot_four_six_language_list = {"english"}
self.dot_five_language_list = {"english","malayalam"}
self.dot_five_six_language_list = {"english"}
self.dot_six_language_list = {"english","malayalam"}
#self.dot__language_list = {"english","malayalam"}
# Intiating thred in PyGtk
gtk.threads_init()
self.guibuilder.connect_signals(self)
self.textview.grab_focus()
self.window.maximize()
self.window.show()
gtk.main()
def run (self):
gtk.timeout_add (self.TIMEOUT, self.code_exec)
try:
if gtk.gtk_version[0] == 2:
gtk.threads_init()
except:
pass
gtk.main ()
def main(self):
self.connect_with_server()
self.update_liststore()
self.listWindow.show()
gtk.threads_init()
gtk.threads_enter()
gtk.main()
gtk.threads_leave()
def __init__(self):
trayicon.TrayIcon.__init__(self, "Ilenia-notifier")
self.ilenia = None
w_event = gtk.EventBox()
self.w_icon = gtk.Image()
self.w_icon.set_from_stock(gtk.STOCK_DIALOG_WARNING,
gtk.ICON_SIZE_MENU)
w_event.set_events(gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.POINTER_MOTION_MASK |
gtk.gdk.POINTER_MOTION_HINT_MASK |
gtk.gdk.CONFIGURE)
w_event.add(self.w_icon)
self.w_menu = gtk.Menu()
self.w_update = gtk.ImageMenuItem(gtk.STOCK_REFRESH, _("Update"))
self.w_update.connect("button_press_event", self.on_update)
self.w_menu.add(self.w_update)
w_update_repos = gtk.ImageMenuItem(gtk.STOCK_CONNECT,
_("Update Repos"))
w_update_repos.connect("button_press_event", self.on_update_repos)
self.w_menu.add(w_update_repos)
self.w_menu.add(gtk.SeparatorMenuItem())
w_show_details = gtk.ImageMenuItem(gtk.STOCK_INFO,
_("Show Details Window"))
w_show_details.connect("button_press_event", self.on_show_details)
self.w_menu.add(w_show_details)
self.w_menu.add(gtk.SeparatorMenuItem())
self.w_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT, _("Quit"))
self.w_quit.connect("button_press_event", self.on_quit)
self.w_menu.add(self.w_quit)
self.w_menu.show_all()
w_event.connect("button_press_event", self.on_event);
self.w_tooltips = gtk.Tooltips()
self.w_tooltips.set_tip(self, "Ilenia-notifier")
self.w_tooltips.enable()
self.add(w_event)
self.show_all()
self.updating_repos = False
self.updating_ilenia = False
self.working = False
self.w_details = Details()
gtk.threads_init()
thread.start_new_thread(self.init_ilenia, ())
thread.start_new_thread(self.ipc_start, ())
gtk.main()
def downloading(url,final):
p = ProgressBar(url)
Test(url, open(final, 'wb'), p.progress).start()
# Enter the GTK mainloop
gtk.threads_init()
try:
p.mainloop()
except KeyboardInterrupt:
pass
def main(self):
self.FrameOfMspApi.set_visible(True)
self.window.show_all()
self.not_from_parent_gtk = 1
gtk.threads_init()
gtk.threads_enter()
gtk.main()
gtk.threads_leave()
def init(self):
gtk.threads_init()
if self.load_last_crawled() and datetime.date.today().day <= self.last_crawled.day and agromaret.load_prices() and bulog.load_prices():
self.update_bulog_table()
self.update_agromaret_table(1)
self.show_prices()
else:
thread.start_new_thread(self.crawl, (True,))
thread.start_new_thread(self.crawl_periodically, ())
gtk.main()
def mainloop(self):
self.start()
gobject.timeout_add(self.TIMEOUT, self.shell.runcode)
try:
if gtk.gtk_version[0] >= 2:
gtk.threads_init()
except AttributeError:
pass
gtk.main()
self.join()
def main(args=None):
gtk.threads_init()
args = parse_args(args)
schema = json.loads(args.schema)
device_name = re.split(r",\s+", args.device_name) if args.device_name else None
try:
results = schema_dialog(schema, device_name=device_name, max_width=args.max_width, max_fps=args.max_fps)
except ValueError, exception:
print >> sys.stderr, "Error: {}".format(exception)
raise SystemExit(-1)
def testDialog (self):
self.ibd = ImageBrowserDialog()
self.ibd.add_images_from_uris_w_progress(
['http://ideasinfood.typepad.com/ideas_in_food/images/katzs_pastrami_reuben.jpg'] \
# + ['file:///home/tom/pictures/'+image for image in ['Caneel beach.JPG','Cinnamon beach.JPG','dsc00258.jpg']]
)
#for image in []:
# self.ibd.add_image_from_uri()
import os
if os.name!='nt':
gtk.threads_init()
self.ibd.run()
def __init__(self, argv):
self.init_default();
self.handle_argv(argv);
self.trayIcon = gtk.StatusIcon();
self.trayIcon.connect('popup-menu', self.make_menu);
self.set_updates(0);
self.trayIcon.set_visible(True);
self.p = Thread(target=self.loop_process);
self.p.daemon = True;
self.p.start();
gtk.threads_init();
gtk.main();
def main():
inputThread = InputThread()
graph = rtgraph.HScrollLineGraph(range=(-1.0, 1.0))
win = rtgraph.GraphUIWindow(inputThread.channels, graph, valueUpdateInterval=500)
win.connect("destroy", gtk.mainquit)
inputThread.start()
try:
gtk.threads_init()
gtk.main()
finally:
inputThread.running = False
def main(configFunc):
"""Run the provided configuration function then the gtk main loop,
terminating all threads cleanly on exit
"""
try:
gtk.threads_init()
configFunc()
gtk.main()
finally:
for thread in threading.enumerate():
if isinstance(thread, MeterThread):
thread.stop()
thread.join()
def __init__(self, dao, timeout=0.0,
start_simulation_method = None):
gtk.threads_init()
self.visulaiser_main = None
self.visulaiser_listener = None
threading.Thread.__init__(self)
self.bufsize = 65536
self.done = False
self.dao = dao
self.port = None
self.start_simulation_method = start_simulation_method
self.finish_event = threading.Event()
if timeout > 0:
thread.start_new_thread(_timeout, (self, timeout))
def __init__(self, settings):
gtk.threads_init()
self.settings = settings
self.builder = gtk.Builder()
self.builder.add_from_file("gui.glade")
self.window = self.builder.get_object ("windowMain")
if self.window:
self.window.connect("destroy", gtk.main_quit)
self.resetPixelCache()
self.drawingArea = self.builder.get_object ("drawingArea")
self.listStore = self.builder.get_object ("liststore1")
self.treeView = self.builder.get_object ("treeviewPaths")
handlers = {
"onDeleteWindow": gtk.main_quit,
"on_treeviewPaths_cursor_changed" : self.on_treeviewPaths_cursor_changed,
"on_drawingArea_expose_event" : self.on_drawingArea_expose_event,
"on_drawingArea_configure_event" : self.on_drawingArea_configure_event,
"on_toolbuttonOpen_clicked" : self.on_toolbuttonOpen_clicked,
"on_toolbuttonCalcAll_clicked" : self.on_toolbuttonCalcAll_clicked,
"on_toolbuttonSaveGcode_clicked" : self.on_toolbuttonSaveGcode_clicked,
"on_toolbuttonShowSettings_clicked" : self.on_toolbuttonShowSettings_clicked,
"on_windowSettings_delete_event" : self.on_windowSettings_delete_event,
"on_buttonSaveSettings_clicked" : self.on_buttonSaveSettings_clicked,
"on_pathSettings_changed" : self.on_pathSettings_changed,
"on_buttonCalcSinglePath_clicked" : self.on_buttonCalcSinglePath_clicked,
"on_drawingArea_scroll_event" : self.on_drawingArea_scroll_event,
"on_drawingArea_motion_notify_event" : self.on_drawingArea_motion_notify_event,
"on_drawingArea_button_press_event" : self.on_drawingArea_button_press_event,
"on_drawingArea_button_release_event" : self.on_drawingArea_button_release_event,
"on_menuitemAbout_button_press_event" : self.on_menuitemAbout_button_press_event,
"on_treeviewPaths_key_press_event" : self.on_treeviewPaths_key_press_event,
"on_buttonSimplifyPaths_clicked" : self.on_buttonSimplifyPaths_clicked,
"on_imagemenuitemNew_button_press_event" : self.on_imagemenuitemNew_button_press_event
}
self.builder.connect_signals(handlers)
self.drawingArea.set_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 )
self.treeView.add_events(gtk.gdk.KEY_PRESS_MASK)
def main():
channels = [AdcChannel(name="Analog channel %d" % i) for i in xrange(8)]
graph = rtgraph.HScrollLineGraph(range=(0.0, 255.0))
win = rtgraph.GraphUIWindow(channels, graph, valueUpdateInterval=500)
win.connect("destroy", gtk.mainquit)
analogThread = AnalogUpdaterThread(channels)
try:
# Windows just hangs in gtk.threads_init()
if os.name != 'nt':
gtk.threads_init()
gtk.main()
finally:
analogThread.running = False
def __init__(self):
gtk.threads_init()
gtk.threads_enter()
self._callback = None
if HAS_APPINDICATOR:
self._icon = None
else:
self._menu = None
self._icon = gtk.StatusIcon()
self._icon.connect('activate', self._on_activate)
self._icon.connect('popup_menu', self._on_popup_menu)
icons = gtk.icon_theme_get_default()
icons.connect('changed', self._on_theme_change)
def __init__(self):
gtk.threads_init()
gtk.threads_enter()
self._callback = None
if HAS_APPINDICATOR:
self._icon = None
else:
self._menu = None
self._icon = gtk.StatusIcon()
self._icon.connect('activate', self._on_activate)
self._icon.connect('popup_menu', self._on_popup_menu)
icons = gtk.icon_theme_get_default()
icons.connect('changed', self._on_theme_change)
def run(file_manager):
'''
Odpala GUI programu.
Do działania potrzebuje klasy zarządzającej tekstami oraz klasy dekodującej zawartość plików
'''
seeker = SeekerGUI(file_manager) #@UnusedVariable
try:
gtk.threads_init()
except:
print "W trakcie kompilacji nie była włączona obsługa wątków pyGTK!"
import sys #@Reimport
sys.exit(1)
gtk.threads_enter()
gtk.main()
gtk.threads_leave()
def __init__(self):
# initialize the feedbackloop
gtk.threads_init()
gtk.threads_enter()
self.feedbackloop = feedbackLoop()
self.feedbackloop.active = False
self.feedbackloop.start()
gtk.threads_leave()
# create a window
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.win.set_size_request(600,500)
self.win.connect('destroy', gtk.main_quit)
#vbox to put everything in
self.vbox = gtk.VBox()
self.win.add(self.vbox)
# add a graph
self.figure = Figure(figsize=(10,4))
self.figureCanvas = FigureCanvas(self.figure)
self.vbox.pack_start(self.figureCanvas, expand=True, fill=True)
# graph
self.axes = self.figure.add_subplot(111)
self.axes.grid()
self.line, = self.axes.plot([1,2,3,4,5],[5,3,5,2,5],'-^', label='output signal PID')
# topline
self.topline, = self.axes.plot([-1e99, 1e99], 2*[self.feedbackloop.max_signal], label='upper lim')
self.botline, = self.axes.plot([-1e99, 1e99], 2*[self.feedbackloop.min_signal], label='lower lim')
self.figureCanvas.draw()
self.axes.legend(loc=2)
# button start/stop
self.buttonBox = gtk.HButtonBox()
self.vbox.pack_end(self.buttonBox, expand=False, fill=True)
self.startStopButton = gtk.ToggleButton('Start/Stop')
self.startStopButton.connect('toggled', self.activateFeedbackLoop)
self.buttonBox.pack_start(self.startStopButton)
self.win.show_all()
gobject.idle_add(self.update_graph)
def main():
channels = [
rtgraph.Channel(name="Vector"),
rtgraph.Channel(name="Magnitude"),
]
graph = rtgraph.IsometricVectorGraph()
win = rtgraph.GraphUIWindow(channels, graph, valueUpdateInterval=500)
win.connect("destroy", gtk.main_quit)
device = sys.argv[1]
thread = rfaccel.ReceiverThread(PacketGrapher(channels, device))
try:
gtk.threads_init()
gtk.main()
finally:
thread.running = False
def setup_gtk(self):
gtk.threads_init()
# Create a new window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
# Quit when window is closed
self.window.connect("destroy", self.destroy)
# Creates a new button
self.button = gtk.Button("Push me!")
self.button.connect("clicked", self.clicked, None)
# Show widgets and window
self.window.add(self.button)
self.button.show()
self.window.show()
def __init__(self):
"""
This start the gui in a asynchronous thread. We are in the "main" thread of the application, wich will later be used by the gui as well. We spawn a new thread for the worker.
"""
gtk.threads_init()
self.qIn=Queue.Queue()
self.qOut=Queue.Queue()
self.gui=GuiPart(self.qIn,self.qOut)
self.running=True
self.incomingThread=threading.Thread(target=self.processIncoming)
#print "plop=",self.incomingThread
self.incomingThread.setDaemon(True)
self.incomingThread.start()
#print "pika=",pika
#gtk.threads_enter()
gtk.main()
self.running=False
def main():
channels = [
rtgraph.Channel(name="X"),
rtgraph.Channel(name="Y"),
rtgraph.Channel(name="Z"),
rtgraph.Channel(name="-X"),
]
graph = rtgraph.HScrollLineGraph(range=(0.0, 65535.0))
win = rtgraph.GraphUIWindow(channels, graph, valueUpdateInterval=500)
win.connect("destroy", gtk.main_quit)
device = sys.argv[1]
thread = rfaccel.ReceiverThread(PacketGrapher(channels, device))
try:
gtk.threads_init()
gtk.main()
finally:
thread.running = False
def run(animation, texture, getFrameRect, size=(200, 200), offset=(0, 0)):
gtk.threads_init()
gtk.threads_enter()
window = gtk.Window()
widget = Screen(animation, texture, getFrameRect, offset)
widget.show()
def on_size_allocate(wind, rect):
#print("walloc")
shapemap = widget.shapemap()
if shapemap:
window.input_shape_combine_mask(shapemap, 0, 0)
#window.reset_shapes()
#print("walloc with bitmap")
window.connect("delete-event", gtk.main_quit)
window.connect("size-allocate", on_size_allocate)
window.add(widget)
window.set_decorated(False)
window.set_skip_taskbar_hint(True)
window.set_skip_pager_hint(True)
window.set_keep_above(True)
window.stick()
window.set_default_size(*size)
#the other function doesn't work on windows
#which sadly means that transparency doesn't work on windows
if os.name=="nt":
colormap = gtk.gdk.colormap_get_system()
else:
colormap = window.get_screen().get_rgba_colormap()
gtk.widget_set_default_colormap(colormap)
window.present()
refresher = Refresher(window)
refresher.start()
try:
gtk.main()
finally:
gtk.threads_leave()
def __init__(self, config):
self.dirs = config['dirs']
self.ahead_icon = config['ahead_icon']
self.synced_icon = config['synced_icon']
self.ind = appindicator.Indicator("GitCheck",
"",
appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status (appindicator.STATUS_ACTIVE)
self.ind.set_attention_icon ("indicator-messages-new")
# create a menu
menu = gtk.Menu()
Check = gtk.MenuItem("Check if any directories are ahead")
Check.connect("activate", lambda s: self.SetIcon())
Check.show()
menu.append(Check)
dirs_items = []
for dir in self.dirs:
item = gtk.CheckMenuItem(dir)
item.set_active(True)
item.show()
menu.append(item)
dirs_items.append(item)
self.dirs_items = dirs_items
quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
quit.connect("activate", self.quit)
quit.show()
menu.append(quit)
self.ind.set_menu(menu)
self.SetIcon() # Initialise the icon
gobject.timeout_add_seconds(10, self.SetIcon)
gtk.threads_init()
def main():
channels = []
analogThread = AnalogUpdaterThread(channels)
# Wait for our channel list to be populated
while not channels:
time.sleep(0.1)
graph = rtgraph.HScrollLineGraph(range=(0.0, 30.0), scrollRate=10)
win = rtgraph.GraphUIWindow(channels, graph, valueUpdateInterval=500)
win.connect("destroy", gtk.mainquit)
try:
# Windows just hangs in gtk.threads_init()
if os.name != 'nt':
gtk.threads_init()
gtk.main()
finally:
analogThread.running = False
def main():
pyCast=gtk.glade.XML (conf.GLADEFILE,"pycast")
dic = { "on_pycast_destroy" : (Exit),
"on_addcast" : (castdlgs.AddCast,pyCast),
"on_aboutdialog" : miscdlgs.About,
"on_castlist_click" : casttree.CastlistClick,
"on_removecast" : (castdlgs.RemoveCast,pyCast)}
pyCast.signal_autoconnect (dic)
casttree.ListCasts(pyCast)
gtk.threads_init()
conf.Load()
thread.start_new_thread(casts.DownloadRSS,(pyCast,''))
gtk.threads_enter()
gtk.main()
gtk.threads_leave()
def __init__(self):
gtk.threads_init()
# Create window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", self.destroy)
self.window.set_border_width(10)
# Create menus
menu = gtk.Menu()
buf = "Open File"
menu_items = gtk.MenuItem("Start Patch")
menu.append(menu_items)
menu_items.connect("activate", self.menuitem_response, buf)
menu_items.show()
root_menu = gtk.MenuItem("File")
root_menu.show()
root_menu.set_submenu(menu)
vbox = gtk.VBox(gtk.FALSE, 0)
self.window.add(vbox)
vbox.show()
menu_bar = gtk.MenuBar()
vbox.pack_start(menu_bar, gtk.FALSE, gtk.FALSE, 0)
menu_bar.append(root_menu)
menu_bar.show()
connection = FtsSocketConnection()
rootPatcher = FtsObject(connection, None, 0)
connection.putObject(0, rootPatcher)
self.console_stream = FtsConsoleStream(self.window, vbox, connection,
rootPatcher, "console_stream")
self.console_stream.send("set_default")
self.clientPatcher = FtsObject(connection, rootPatcher, 1)
JMaxApplication.connection = connection
JMaxApplication.rootPatcher = rootPatcher
def startapp():
if platform.system() == 'Windows':
set_locale()
else:
gtk.threads_init()
install_gettext("sanaviron")
if '--debug' in sys.argv:
import gc
gc.enable()
gc.set_debug(gc.DEBUG_LEAK)
print(get_summary())
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
os.chdir(os.path.dirname(os.path.abspath(__file__)))
from ui.application import Application
application = Application()
if '--sample' in sys.argv:
application.editor.canvas.load_from_xml(
os.path.join("..", "examples", "invoice.xml"))
application.run()
def run(self):
gtk.threads_init()
gtk.main()
def __init__(self, maxthreads=3):
VBox.__init__(self)
self.threads = []
self.queue = DownloadQueue()
self.show()
for i in range(maxthreads):
thread = _DownloadStatus(self.queue)
thread.start()
self.threads.append(thread)
self.pack_end(thread, FALSE, FALSE, 0)
def put(self, url, path):
self.queue.put(url, path)
if __name__ == '__main__':
threads_init()
win = MenuWindow()
win.connect('destroy', mainquit)
win.set_usize(200, 100)
#url = 'http://paella/debian/dists/sid/Release'
mirror = 'paella'
#mirror = 'ftp.us.debian.org'
url = 'http://%s/debian/dists/sid/main/binary-i386/Packages.gz' % mirror
dl = DownloadStatus(url, 'hellothere')
win.vbox.add(dl)
#threads_enter()
#dl.start()
mainloop()
#threads_leave()
def show(self):
self.window.show_all()
gtk.threads_init()
gtk.main()
def run():
gtk.threads_init()
gui = GUI()
thread.start_new_thread(gui.do_strobes, ())
gtk.main()
def main():
gtk.threads_init()
gtk.main()
def main(argv):
a = Application()
gtk.threads_init()
gtk.main()
def main():
gtk.threads_init()
warnings.filterwarnings("ignore", category=DeprecationWarning)
app = application()
app.start()
def init_gtk(self):
try:
gtk.threads_init()
except:
print "No threading was enabled when you compiled pyGTK!"
sys.exit(1)
def __init__(self,
dirs,
args,
update_period=300,
update_period_remote=3600):
self.args = args
self.dirs = dirs
self.update_period = update_period
self.update_period_remote = update_period_remote
self.remote = False # Flag to update the remote
self.ind = appindicator.Indicator(
"checkgit", "", appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status(appindicator.STATUS_ACTIVE)
self.ind.set_attention_icon("indicator-messages-new")
self.IconMenuDictionary = {
'ahead': gtk.STOCK_GO_UP,
'diverged': gtk.STOCK_REFRESH,
'behind': gtk.STOCK_GO_DOWN,
'up-to-date': gtk.STOCK_YES,
'no-state': gtk.STOCK_HELP
}
# create a menu
menu = gtk.Menu()
ManualCheck = gtk.ImageMenuItem(gtk.STOCK_REFRESH)
ManualCheck.set_always_show_image(True)
ManualCheck.show()
ManualCheck.connect("activate", self.SetIconAndMenuRemote2)
menu.append(ManualCheck)
ManualUpdate = gtk.ImageMenuItem(gtk.STOCK_HOME)
ManualUpdate.set_always_show_image(True)
ManualUpdate.show()
ManualUpdate.connect("activate", self.PullPushAll)
ManualUpdate.connect("activate", self.SetIconAndMenuRemote2)
menu.append(ManualUpdate)
dirs_items = []
for dir in self.dirs:
label_name = self.ClearDirName(dir)
item = gtk.ImageMenuItem(gtk.STOCK_YES, label_name)
item.show()
item.set_always_show_image(True)
menu.append(item)
dirs_items.append(item)
self.dirs_items = dirs_items
quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
quit.connect("activate", self.quit)
quit.set_always_show_image(True)
quit.show()
menu.append(quit)
self.ind.set_menu(menu)
# Update the custom labels: must be done after `set_menu`.
ManualCheck.set_label("Check status")
ManualUpdate.set_label("Pull/Push")
self.SetIconAndMenu(remote=True) # Initialise the icon
gobject.timeout_add_seconds(int(self.update_period),
self.SetIconAndMenu)
gobject.timeout_add_seconds(int(self.update_period_remote),
self.SetIconAndMenuRemote)
gtk.threads_init()
def __init__(self, url):
# Fenster + Inhalt zusammenbasteln
self.windowMain = gtk.Window(gtk.WINDOW_TOPLEVEL)
vboxMain = gtk.VBox()
vboxInOut = gtk.VBox(False, 6)
hboxAddress = gtk.HBox(False, 6)
labelAddress = gtk.Label("_Adress:")
labelAddress.set_use_underline(True)
self.inputAddress = gtk.Entry()
buttonCheck = gtk.Button("_Check")
buttonCheck.connect("clicked", self.button_check_clicked)
buttonClear = gtk.Button("C_lear all")
buttonClear.connect("clicked", self.button_clear_clicked)
self.inputAddress.connect("changed", self.input_address_changed,
buttonCheck)
self.inputAddress.connect("key_press_event",
self.input_address_keypress)
labelAddress.set_mnemonic_widget(self.inputAddress)
hboxAddress.pack_start(labelAddress, False, True)
hboxAddress.add(self.inputAddress)
hboxAddress.pack_end(buttonClear, False, True)
hboxAddress.pack_end(buttonCheck, False, True)
# Tastenkürzelgruppe mit Fenster verbinden
accel = gtk.AccelGroup()
self.windowMain.add_accel_group(accel)
# Menu zusammenbasteln
menuBar = gtk.MenuBar()
rootMenu = gtk.MenuItem("_GPharmcheck")
mainMenu = gtk.Menu()
menuItemAbout = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
menuItemQuit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
menuItemQuit.add_accelerator("activate", accel, ord("Q"),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
mainMenu.append(menuItemAbout)
mainMenu.append(gtk.SeparatorMenuItem())
mainMenu.append(menuItemQuit)
menuItemAbout.connect("activate", self.menu_item_about_activate)
menuItemQuit.connect("activate", self.menu_item_quit_activate)
rootMenu.set_submenu(mainMenu)
menuBar.append(rootMenu)
vboxMain.pack_start(menuBar, False, True, 0)
self.output = gtk.TextView()
outputScroll = gtk.ScrolledWindow()
outputScroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
outputScroll.add(self.output)
outputScroll.set_shadow_type(gtk.SHADOW_IN)
vboxInOut.pack_start(hboxAddress, False, True)
vboxInOut.pack_end(outputScroll, True, True)
vboxInOut.set_border_width(6)
vboxMain.add(vboxInOut)
buttonCheck.set_sensitive(False)
# Mit Signalen verbinden
self.windowMain.connect("delete_event", self.delete_event)
self.windowMain.add(vboxMain)
self.windowMain.move(200, 100)
self.windowMain.resize(400, 300)
self.windowMain.set_title("GPharmcheck " + __version__)
self.windowMain.show_all()
gtk.threads_init()
gtk.threads_enter()
gtk.main()
gtk.threads_leave()
def __init__(self, basedir, embed=False, poster=""):
""" Main window class """
self.basedir = basedir
self.embed = embed
self.poster = poster
self.window = gtk.Window()
self.window.set_title("Pyimagedownloader %s" % __version__)
self.window.set_size_request(500, 200)
self.window.connect("delete-event", self.close)
self.window.connect("destroy", self.close)
# let's have a scrobllbar
self.scrolledwindow = gtk.ScrolledWindow()
self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scrolledwindow.set_size_request(400, 150)
# ListStore and its TreeView
self.liststore = gtk.ListStore(str)
self.treeview = gtk.TreeView(self.liststore)
self.treeview.set_fixed_height_mode(
True) # all columns have same height
# CellRender to render the data
self.cell = gtk.CellRendererText()
# TreeViewColumn to display text in a single column
self.tvcolumn = gtk.TreeViewColumn('URL', self.cell, text=0)
# this must be set for set_fixed_height_mode of TreeView to work
self.tvcolumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
self.tvcolumn.set_clickable(False) # column header won't be clickable
# add column to the treeview
self.treeview.append_column(self.tvcolumn)
# make treeview searchable and allow sorting
self.treeview.set_search_column(0)
self.tvcolumn.set_sort_column_id(0)
# add grid lines
self.treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_HORIZONTAL)
# make the column header not clickable
self.tvcolumn.set_clickable(False)
# Clipboard
self.clipboard = gtk.Clipboard(gtk.gdk.display_get_default(),
"PRIMARY")
# Buttons
self.basedir_button = gtk.Button("Set save directory")
self.filelist_button = gtk.Button("Load file")
self.cut_button = gtk.Button("Cut")
self.copy_button = gtk.Button("Copy")
self.paste_button = gtk.Button("Paste")
self.start_button = gtk.Button("Start")
self.close_button = gtk.Button("Close")
self.basedir_button.set_size_request(30, 30)
self.filelist_button.set_size_request(30, 30)
self.cut_button.set_size_request(50, 50)
self.copy_button.set_size_request(50, 50)
self.paste_button.set_size_request(50, 50)
self.start_button.set_size_request(50, 50)
self.close_button.set_size_request(50, 50)
self.hbox1 = gtk.HBox(False, 5)
self.hbox2 = gtk.HBox(False, 5)
self.vbox = gtk.VBox(False, 5)
self.hbox1.pack_start(self.basedir_button)
self.hbox1.pack_start(self.filelist_button)
self.vbox.pack_start(self.hbox1)
self.vbox.pack_start(self.scrolledwindow)
self.hbox2.pack_start(self.start_button)
self.hbox2.pack_start(self.cut_button)
self.hbox2.pack_start(self.copy_button)
self.hbox2.pack_start(self.paste_button)
self.hbox2.pack_start(self.close_button)
self.vbox.pack_start(self.hbox2)
self.scrolledwindow.add(self.treeview)
self.window.add(self.vbox)
self.basedir_button.connect("clicked", self.basedir_dialog)
self.filelist_button.connect("clicked", self.filelist_dialog)
self.cut_button.connect("clicked", self.copy, "cut")
self.copy_button.connect("clicked", self.copy, "copy")
self.paste_button.connect("clicked", self.paste)
self.start_button.connect("clicked", self.sequential_downloader,
self.liststore, self.basedir, self.embed,
self.poster)
self.close_button.connect("clicked", self.close)
# Tooltips
self.cut_button.set_tooltip_text("Cut url(s)")
self.copy_button.set_tooltip_text("Copy url(s) into the clipboard")
self.paste_button.set_tooltip_text("Paste url(s) from the clipboard")
self.window.show_all()
gtk.threads_init()
gtk.main()
Metoda pomocnicza dla kodu obsługi zdarzenia kliknięcia:
umieszcza komunikat w obszarze tekstowym i przesuwa obszar na sam dół.
"""
message=message+enter
buffer = self.logwindow
iter = buffer.get_end_iter()
#obsługa różnych wersji GTK
if color != "black":
tag = buffer.create_tag()
tag.set_property("foreground", color)
self.logwindow.insert_with_tags(buffer.get_end_iter(), message, tag)
else:
self.logwindow.insert(iter, message)
#gtk.FALSE i gtk.TRUE w starszych pyGTK
mark = buffer.create_mark("end", buffer.get_end_iter(), False)
self.logwindowview.scroll_to_mark(mark,0.05,True,0.0,1.0)
#print "Koniec funkcji log"
if __name__ == '__main__':
PyRAPGUI()
try:
gtk.threads_init()
except:
print "W trakcie kompilacji pyGTK nie były włączone wątki!"
import sys
sys.exit(1)
gtk.threads_enter()
gtk.main()
gtk.threads_leave()
def main():
gtk.threads_init()
gtk.threads_enter()
gtk.main()
gtk.threads_leave()
return 0
def main():
# Configure options
parser = OptionParser(usage='usage: %prog [options]')
parser.set_defaults(debug=False)
parser.set_defaults(capture_log=False)
parser.add_option('-d',
'--debug',
action='store_true',
dest='debug',
help='start in debug mode')
parser.add_option('-c',
'--capture-log',
action='store_true',
dest='capture_log',
help='Capture device logs.')
(options, args) = parser.parse_args()
del args
# Option debug for logging
if options.debug:
level = logging.DEBUG
else:
level = logging.INFO
logfilename = '/var/tmp/hermes-hardware-' + \
os.environ['USER'] + str(os.getuid()) + \
'.log'
logging.basicConfig(level=level,
format='%(asctime)s %(levelname)s %(message)s',
filename=logfilename,
filemode='a')
# Set capture log
if options.capture_log:
filepath = '/var/tmp/filenotification-' + \
os.environ['USER'] + str(os.getuid()) + \
'.log'
iface = FileNotification(filepath)
capture_log_gui = CaptureLogGui()
else:
iface = NotificationDaemon()
global DeviceActor
from actors.deviceactor import DeviceActor
##################################################################
# Init application. #
#######################
logging.getLogger().info("----------------------------- Hermes init.")
DeviceListener(iface)
gtk.threads_init()
try:
gtk.main()
except:
if 'capture_log_gui' in locals():
# Close file for write in hd.
capture_log_gui.logfile.close()
logging.getLogger().info(
"----------------------------- Hermes finish.")
def main(argv):
Application().startup()
gtk.threads_init()
gtk.main()
def __init__(self):
self.name = self.plugin_name
self.ignore_warnings = {}
gtk.threads_init()
