def post_init (self):
config_dir = os.path.expanduser ("~/.config")
if not os.path.exists (config_dir):
os.mkdir (config_dir)
self.config_parser = ConfigParser.ConfigParser ()
self.config_parser.read (config_dir + "/wallbox.conf")
if not self.config_parser.has_section ("general"):
self.config_parser.add_section ("general")
try:
self.refresh_interval = self.config_parser.getint ("general", "refresh_interval")
except ConfigParser.NoOptionError:
self.refresh_interval = 60
self.config_parser.set ("general", "refresh_interval", 60)
try:
self.notification_num = self.config_parser.getint("general", "notification_num")
except ConfigParser.NoOptionError:
self.notification_num = 10
self.config_parser.set ("general", "notification_num", 10)
self.office.set_refresh_interval (self.refresh_interval)
self.office.set_notification_num (self.notification_num)
configfile = open (config_dir + "/wallbox.conf", 'wb')
self.config_parser.write (configfile)
status_icon = gtk.status_icon_new_from_stock (gtk.STOCK_OPEN)
n = notification.Notification ()
self.status_icon = status_icon
status_icon.connect ("activate", self.show_notification, n)
n.connect ("has-unread", self.has_unread)
def __init__(self):
self.set_proc_name(APP_NAME)
#folders
self.config_folder = os.getenv('HOME')+"/.services-manager"
self.system_plugin_folder = sys.path[0]+"/plugins"
self.user_plugin_folder = self.config_folder+"/plugins"
self.plugin_folder = [self.system_plugin_folder,self.user_plugin_folder]
#plugins main module name
self.main_module = "__init__"
# create folders if dont exsist
if not os.path.exists(self.config_folder):
os.makedirs(self.config_folder)
if not os.path.exists(self.user_plugin_folder):
os.makedirs(self.user_plugin_folder)
#image files
self.image_green = sys.path[0]+"/media/green.png"
self.image_red = sys.path[0]+"/media/red.png"
#tray declaration
self.tray_icon = gtk.status_icon_new_from_stock(gtk.STOCK_INFO)
self.tray_menu = gtk.Menu()
self.update_menu()
self.tray_icon.connect('popup-menu', self.show_menu, self.tray_menu)
self.tray_icon.set_tooltip("Services Manager")
def _setup_status_icon(self):
from kupfer import kupferui
status = gtk.status_icon_new_from_stock(self.icon_name)
status.set_tooltip(_("Kupfer"))
menu = gtk.Menu()
def menu_callback(menuitem, callback):
callback()
return True
def add_menu_item(icon, callback):
mitem = gtk.ImageMenuItem(icon)
mitem.connect("activate", menu_callback, callback)
menu.append(mitem)
add_menu_item(gtk.STOCK_PREFERENCES, kupferui.show_preferences)
add_menu_item(gtk.STOCK_HELP, kupferui.show_help)
add_menu_item(gtk.STOCK_ABOUT, kupferui.show_about_dialog)
menu.append(gtk.SeparatorMenuItem())
add_menu_item(gtk.STOCK_QUIT, self.quit)
menu.show_all()
status.connect("popup-menu", self._popup_menu, menu)
status.connect("activate", self.show_hide)
return status
def __init__(self):
## Create appindicator object
if have_appindicator:
self.ind = appindicator.Indicator ("example-simple-client",
"indicator-messages",
appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status (appindicator.STATUS_ACTIVE)
self.ind.set_attention_icon ("new-messages-red")
self.ind.set_icon("distributor-logo")
else:
self.ind = gtk.status_icon_new_from_stock(gtk.STOCK_HOME)
## Create menu object
self.menu = gtk.Menu()
## Add menu items below
## About
menuItemAbout = gtk.MenuItem('About')
menuItemAbout.connect("activate", self.about_response, "About")
self.menu.append(menuItemAbout)
## Quit
menuItemQuit = gtk.MenuItem('Quit')
menuItemQuit.connect('activate', self.quit)
self.menu.append(menuItemQuit)
## Show all in menu (instead of calling .show() for each item)
self.menu.show_all()
## Add constructed menu as indicator menu
self.ind.set_menu(self.menu)
def load_status_icon(path, size_x, size_y, stock):
if os.access(path, os.R_OK):
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path, size_x, size_y)
return gtk.status_icon_new_from_pixbuf(pixbuf)
else:
# Can't find icon file
logging.warning("cannot find icon file: " + path)
return gtk.status_icon_new_from_stock(stock)
def runGTKApplet(self):
self.dialog_title = "Test"
self.STOKICON = gtk.STOCK_YES
self.icon = gtk.status_icon_new_from_stock(self.STOKICON)
gobject.timeout_add(500, self.updateStatus)
self.icon.set_tooltip("Test")
self.icon.connect("popup-menu", self.right_click)
gtk.main()
def __init__(self):
self.user_homepath = os.getenv('HOME').rstrip('/')
self.app_data_path = '%s/.brelock/' % (self.user_homepath)
os.chdir(sys.path[0])
self.hidden = False
self.compact = False
self.passwords = PassStorage()
self.config = {}
self.gladefile = "ui.glade"
self.menus = {}
self.wTree = gtk.glade.XML(self.gladefile, 'main_window')
self.window = self.wTree.get_widget("main_window")
if (self.window):
self.window.connect("destroy", gtk.main_quit)
gettext.translation('brelock', 'language', languages=['ru']).install(unicode=True)
self.check_fs()
self.load_config()
if not self.load_accounts():
raise Exception('Terminated by user')
self.wTree.signal_autoconnect({
"on_quit" : self.on_quit,
"on_about" : self.on_about,
"on_add_account" : self.on_add_account,
"on_tree_clicked" : self.on_tree_clicked,
"on_preferences" : self.on_preferences,
'on_reload': self.on_reload
})
accel = gtk.AccelGroup()
key, modif = gtk.accelerator_parse('F2')
accel.connect_group(key, modif, gtk.ACCEL_VISIBLE, lambda a,b,c,d: self.on_edit_account(None))
key, modif = gtk.accelerator_parse('<Ctrl>C')
accel.connect_group(key, modif, gtk.ACCEL_VISIBLE, lambda a,b,c,d: self.on_copy_pass(None))
key, modif = gtk.accelerator_parse('<Alt>C')
accel.connect_group(key, modif, gtk.ACCEL_VISIBLE, lambda a,b,c,d: self.on_copy_user(None))
key, modif = gtk.accelerator_parse('<Ctrl><Shift>C')
accel.connect_group(key, modif, gtk.ACCEL_VISIBLE, lambda a,b,c,d: self.on_copy_account(None))
key, modif = gtk.accelerator_parse('Delete')
accel.connect_group(key, modif, gtk.ACCEL_VISIBLE, lambda a,b,c,d: self.on_delete())
key, modif = gtk.accelerator_parse('<Ctrl>T')
accel.connect_group(key, modif, gtk.ACCEL_VISIBLE, lambda a,b,c,d: self.on_toggle())
self.window.add_accel_group(accel)
self.prepare_tree()
self.display_accounts()
self.statusbar = self.wTree.get_widget("statusbar")
icon = gtk.status_icon_new_from_stock(gtk.STOCK_DIALOG_AUTHENTICATION)
icon.connect("activate", self.on_activate)
icon.connect('popup-menu', self.on_icon_menu)
self.window.connect("delete-event", self.on_close)
gtk.gdk.threads_init()
def activate(self, shell):
self.window_is_hidden = False
self.shell = shell
self.status_icon = gtk.status_icon_new_from_stock(gtk.STOCK_MISSING_IMAGE)
self.status_icon.connect('activate', self.signal_activate)
self.status_icon.set_visible(True)
window = shell.get_window()
self.handler = window.connect('delete-event', self.signal_delete_event)
def __init__(self):
self.notedb = os.path.join( sys.path[0], 'notey.sqlite3' )
self.setup_db()
builder = gtk.Builder()
builder.add_from_file( os.path.join( sys.path[0], "notey.xml" ) )
builder.connect_signals(self)
# GtkBuilder is not really good at treeviews
# so we need to create our own cells and associate them
# see http://faq.pygtk.org/index.py?req=show&file=faq13.039.htp
# and http://zetcode.com/tutorials/pygtktutorial/advancedwidgets/
#
self.treeview1 = builder.get_object("treeview1")
cell0 = gtk.CellRendererText()
self.col0 = gtk.TreeViewColumn("Title", cell0,text=0)
self.col0.set_sort_column_id(0)
self.treeview1.append_column(self.col0)
cell1 = gtk.CellRendererText()
self.col1 = gtk.TreeViewColumn("Modified Time", cell1,text=1)
self.col1.set_sort_column_id(1)
self.treeview1.append_column(self.col1)
self.treeview1.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.liststore1 = builder.get_object("liststore1")
self.populate_liststore1()
self.window1 = builder.get_object("window1")
self.textbuffer1 = builder.get_object("textbuffer1")
self.textview1 = builder.get_object("textview1")
self.window2 = builder.get_object("window2")
self.entry2 = builder.get_object("entry2")
self.entry1 = builder.get_object("entry1")
self.vbox1 = builder.get_object("vbox1")
self.tvsw = builder.get_object("scrolledwindow1")
self.title = ""
self.liststore1.set_sort_func(0, self.compare_data, 0)
self.liststore1.set_sort_func(1, self.compare_data, 1)
#make a status icon
self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_GOTO_TOP)
self.statusicon.connect('activate', self.status_clicked )
self.statusicon.set_tooltip("the window is visible")
self.window1.show()
def activate(self, shell):
self.window_is_hidden = False
self.shell = shell
self.status_icon = gtk.status_icon_new_from_stock(
gtk.STOCK_MISSING_IMAGE)
self.status_icon.connect('activate', self.signal_activate)
self.status_icon.set_visible(True)
window = shell.get_window()
self.handler = window.connect('delete-event', self.signal_delete_event)
def __init__(self):
# fenêtre root
self.root = gtk.gdk.get_default_root_window()
self.sz = self.root.get_size()
self.x, self.y, mods = self.root.get_pointer()
self.zoom = 2
self.ignorefocuslost = False
self.isvisible = True
self.follow_mouse = True
# fenêtre principale
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_resizable(False)
self.window.set_decorated(False)
self.window.set_skip_taskbar_hint(True)
self.window.set_keep_above(True)
self.window.move(self.x, self.y)
self.window.set_border_width(1) # pour avoir une bordure noire
self.window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
self.window.add_events(gtk.gdk.KEY_PRESS_MASK |\
gtk.gdk.POINTER_MOTION_MASK | \
gtk.gdk.BUTTON_PRESS_MASK |\
gtk.gdk.SCROLL_MASK | \
gtk.gdk.LEAVE_NOTIFY)
self.window.connect("delete_event", self.quit)
self.window.connect("motion-notify-event", self.cursor_move)
self.window.connect("key-press-event", self.keypress)
self.window.connect("scroll-event", self.scroll)
self.window.connect("leave-notify-event", self.focus_lost)
# image zoomée
self.im = gtk.Image()
evbox = gtk.EventBox()
evbox.connect("button_release_event", self.clic)
evbox.add(self.im)
self.window.add(evbox)
# icone dans le tray
trayicon = gtk.status_icon_new_from_stock(gtk.STOCK_ZOOM_IN)
trayicon.set_visible(True)
trayicon.connect("button-press-event", self.trayclic)
self.window.show_all()
pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,False,8,self.sz[0],self.sz[1])
self.pb = pb.get_from_drawable(self.root,self.root.get_colormap(),0,0,0,0,self.sz[0],self.sz[1])
self.loupe()
def __init__(self):
self.config = Config.load_or_create()
if self.config.status_icon:
self.status_icon = gtk.status_icon_new_from_stock(gtk.STOCK_OK)
self.status_icon.connect("activate", self.on_activate_status)
self.status_icon.connect("popup-menu", self.on_status_menu)
agr = gtk.AccelGroup()
menu = self.context_menu = gtk.Menu()
exit_item = exit_menu_item(self.exit, agr)
menu.append(exit_item)
menu.show_all()
def __init__(self):
self._z = GnomeZoomSettings.Zoomer()
filename = "/usr/share/zoomcontrolwindow/zoomcontrolwindow.glade"
if not os.path.exists("/usr/share/zoomcontrolwindow/zoomcontrolwindow.glade") or "-l" in sys.argv:
print "Using GTKBuilder file from local directory."
filename = "zoomcontrolwindow.glade"
builder = gtk.Builder()
builder.add_from_file(filename)
builder.connect_signals(self)
self._onoffbutton = builder.get_object("zoom_on_off_button")
self._refresh_zoom_button_label()
self._window = builder.get_object("zoomcontrolwindow")
self.show_above()
# make a status icon
self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_FIND)
self.statusicon.connect("activate", self.status_clicked)
self.statusicon.connect("popup-menu", self.make_menu)
self.statusicon.set_tooltip("Zoom")
def __init__(self):
"""docstring for __init__"""
self.pymodoro = Pymodoro(self)
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_size_request(400, 300)
self.window.set_title("Pymodoro")
self.main_box = gtk.VBox(False, 5)
self.button_box = gtk.HBox(False, 5)
self.bottom_box = gtk.HBox(False, 5)
self.info_box = gtk.VBox(False, 5)
self.start_pomodoro_button = gtk.Button("Start a pomodoro...")
self.start_pomodoro_button.connect("clicked", self.pymodoro.start_pomodoro)
self.stop_button = gtk.Button("Stop and Reset")
self.stop_button.connect("clicked", self.pymodoro.stop)
self.time_left_label = gtk.Label("0:00 remaining")
self.num_pomodoros_label = gtk.Label("0 pomodoros completed")
self.num_big_breaks_label = gtk.Label("0 extended breaks taken")
self.window.add(self.main_box)
self.main_box.pack_start(self.button_box)
self.button_box.pack_start(self.start_pomodoro_button)
self.button_box.pack_start(self.stop_button)
self.main_box.pack_start(self.bottom_box)
self.bottom_box.pack_start(self.time_left_label)
self.bottom_box.pack_start(self.info_box)
self.info_box.pack_start(self.num_pomodoros_label)
self.info_box.pack_start(self.num_big_breaks_label)
self.clock_timer = gobject.timeout_add(1000, self.pymodoro.update_clocks)
self.gui_timer = gobject.timeout_add(1000, self.update_labels)
pynotify.init("Pymodoro")
self.status_icon = gtk.status_icon_new_from_stock(gtk.STOCK_GOTO_TOP)
self.status_icon.connect("activate", self.status_clicked)
self.status_icon.connect("popup-menu", self.popup)
self.window.connect("delete-event", self.delete_event)
# self.window.connect("destroy", self.on_window_destroy)
self.window.show_all()
def __init__(self):
status_icon = gtk.status_icon_new_from_stock(gtk.STOCK_MEDIA_RECORD)
status_icon.connect('activate', self._onActivate)
status_icon.connect('popup-menu', self._onPopup)
status_icon.set_tooltip(self.start_tooltip)
self.ui_manager = self._newUIManager()
self.script_buffer = ScriptBuffer(self.ui_manager)
self.script_buffer.clearBuffer()
self.script_buffer.connect('notify::recording',
self._onRecordChange, status_icon)
self.macro_preview = None
# Get program ID
global APP_ID
from gnome import program_get
_prog = program_get()
if _prog is not None:
APP_ID = _prog.get_app_id()
pyatspi.Registry.start()
def __init__(self):
status_icon = gtk.status_icon_new_from_stock(gtk.STOCK_MEDIA_RECORD)
status_icon.connect('activate', self._onActivate)
status_icon.connect('popup-menu', self._onPopup)
status_icon.set_tooltip(self.start_tooltip)
self.ui_manager = self._newUIManager()
self.script_buffer = ScriptBuffer(self.ui_manager)
self.script_buffer.clearBuffer()
self.script_buffer.connect('notify::recording', self._onRecordChange,
status_icon)
self.macro_preview = None
# Get program ID
global APP_ID
from gnome import program_get
_prog = program_get()
if _prog is not None:
APP_ID = _prog.get_app_id()
pyatspi.Registry.start()
def __init__(self, parent = None, status_icon=True):
gobject.timeout_add(1000, self.wakeup)
self.icon = gtk.status_icon_new_from_stock(gtk.STOCK_DIALOG_INFO)
self.icon.set_visible(status_icon)
self.icon.connect('activate', self.status_icon_activate)
self.icon.connect('popup-menu', self.__icon_menu)
gtk.Window.__init__(self)
self.set_title('Eve Timer')
self.set_position(gtk.WIN_POS_CENTER)
self.set_default_size(300,200)
self.connect('destroy', lambda *w: gtk.main_quit())
merge = gtk.UIManager()
self.set_data('ui-manager', merge)
merge.insert_action_group(self.__create_action_group(), 0)
self.add_accel_group(merge.get_accel_group())
mergeid = merge.add_ui_from_string(self.ui_info)
table = gtk.Table(1, 3, False)
self.add(table)
bar = merge.get_widget("/MenuBar")
table.attach(bar, 0, 1, 0, 1, gtk.EXPAND | gtk.FILL, 0, 0, 0)
self.char_notebook = gtk.Notebook()
table.attach(self.char_notebook, 0, 1, 1, 2, gtk.EXPAND | gtk.FILL, gtk.EXPAND | gtk.FILL, 0, 0)
for char in chars.get():
label = gtk.Label(char.character)
self.char_notebook.append_page(self.__char_tab(char), label)
self.statusbar = gtk.Statusbar()
table.attach(self.statusbar, 0, 1, 2, 3, gtk.EXPAND | gtk.FILL, 0, 0, 0)
self.connect("window_state_event", self.update_resize_grip)
def __init__(self):
gtk.Window.__init__(self)
self.set_title("Close to tray")
self.connect("delete-event", self.delete_event)
#create a virtical box to hold some widgets
vbox = gtk.VBox(False)
#make a quit button
quitbutton = gtk.Button("Quit")
quitbutton.connect("clicked",self.quit)
#add the quitbutton to the vbox
vbox.pack_start(quitbutton)
#create a label to say *something* and add to the vbox
label=gtk.Label("This is a test of 'close to tray' functionality")
vbox.pack_start(label)
#add the vbox to the Window
self.add(vbox)
#show all of the stuff
self.show_all()
#make a status icon
self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_GOTO_TOP)
self.statusicon.connect('activate', self.status_clicked )
self.statusicon.set_tooltip("the window is visible")
#start the gtk main loop
gtk.main()
def __init__(self,
show_kthreads=True,
show_uthreads=True,
cpus_filtered=[]):
global tuna_glade
(app, localedir) = ('tuna', '/usr/share/locale')
gtk.glade.bindtextdomain(app, localedir)
gtk.glade.textdomain(app)
if self.check_root():
sys.exit(1)
for dir in tuna_glade_dirs:
tuna_glade = "%s/tuna_gui.glade" % dir
if os.access(tuna_glade, os.F_OK):
break
self.wtree = gtk.glade.XML(tuna_glade, "mainbig_window", "tuna")
self.ps = procfs.pidstats()
self.irqs = procfs.interrupts()
self.window = self.wtree.get_widget("mainbig_window")
self.procview = procview(self.wtree.get_widget("processlist"), self.ps,
show_kthreads, show_uthreads, cpus_filtered,
tuna_glade)
self.irqview = irqview(self.wtree.get_widget("irqlist"), self.irqs,
self.ps, cpus_filtered, tuna_glade)
self.cpuview = cpuview(self.wtree.get_widget("vpaned1"),
self.wtree.get_widget("hpaned2"),
self.wtree.get_widget("cpuview"), self.procview,
self.irqview, cpus_filtered)
self.config = Config()
self.check_env()
self.commonview = commonview()
self.commonview.contentTable = self.wtree.get_widget("commonTbl")
self.commonview.configFileCombo = self.wtree.get_widget(
"profileSelector")
self.profileview = profileview()
self.profileview.config = self.config
self.commonview.config = self.config
self.profileview.commonview = self.commonview
self.commonview.profileview = self.profileview
self.profileview.setWtree(self.wtree)
self.profileview.init_default_file()
event_handlers = {
"on_mainbig_window_delete_event":
self.on_mainbig_window_delete_event,
"on_processlist_button_press_event":
self.procview.on_processlist_button_press_event,
"on_irqlist_button_press_event":
self.irqview.on_irqlist_button_press_event,
"on_loadProfileButton_clicked":
self.profileview.on_loadProfileButton_clicked,
"on_SaveButton_clicked":
self.profileview.on_SaveButton_clicked,
"on_UpdateButton_clicked":
self.profileview.on_UpdateButton_clicked,
"on_applyChanges_clicked":
self.commonview.on_applyChanges_clicked,
"on_undoChanges_clicked":
self.commonview.on_undoChanges_clicked,
"on_saveSnapshot_clicked":
self.commonview.on_saveSnapshot_clicked,
"on_saveTunedChanges_clicked":
self.commonview.on_saveTunedChanges_clicked,
"on_profileSelector_changed":
self.commonview.on_profileSelector_changed,
"on_profileTree_button_press_event":
self.profileview.on_profileTree_button_press_event
}
self.wtree.signal_autoconnect(event_handlers)
self.ps.reload_threads()
self.show()
self.timer = gobject.timeout_add(2500, self.refresh)
try:
self.icon = gtk.status_icon_new_from_stock(gtk.STOCK_PREFERENCES)
self.icon.connect("activate", self.on_status_icon_activate)
self.icon.connect("popup-menu", self.on_status_icon_popup_menu)
except AttributeError:
# Old pygtk2
pass
pixbuf = self.window.render_icon(gtk.STOCK_PREFERENCES,
gtk.ICON_SIZE_SMALL_TOOLBAR)
self.window.set_icon(pixbuf)
import cairo
import gtk
import os
import state
if os.name == "nt":
from ctypes import windll
drawwin = gtk.Window()
eventwin = drawwin if os.name != "nt" else gtk.Window()
statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_GOTO_TOP)
drawcalls = [lambda cr, c=state.color(): cr.set_source_rgb(*c)]
drawtrigger = 0
GWL_EXSTYLE = -20
SW_HIDE = 0
SW_SHOW = 5
WS_EX_LAYERED = 0x00080000
WS_EX_TOOLWINDOW = 0x00000080
LWA_ALPHA = 0x00000002
LWA_COLORKEY = 0x00000001
COLORREF_BLACK = 0x00000000
MIN_ALPHA = 1
def init():
statusicon.connect("activate", on_status_clicked)
eventwin.add_events(gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.POINTER_MOTION_MASK)
eventwin.connect("key-press-event", on_keypress)
eventwin.connect("button-press-event", on_buttonpress)
def __init__(self, node):
gtk.Window.__init__(self)
self.set_default_size(640, 480)
self.trayIcon = gtk.status_icon_new_from_stock(gtk.STOCK_FIND)
self.trayIcon.connect('popup-menu', self._trayIconRightClick)
self.trayIcon.connect('activate', self._trayIconClick)
self.node = node
self.connect("delete-event", self._hideWindow)
# Layout the window
highLevelVbox = gtk.VBox(spacing=3)
self.add(highLevelVbox)
highLevelVbox.show()
notebook = gtk.Notebook()
notebook.set_tab_pos(pos=gtk.POS_TOP)
notebook.show()
highLevelVbox.pack_start(notebook, expand=True, fill=True)
vbox = gtk.VBox(spacing=3)
vbox.show()
notebook.append_page(vbox, gtk.Label('Search P2P Network'))
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw)
# Create tree model
model = self.createListStore([])
# Create tree view
self.dhtTreeView = gtk.TreeView(model)
self.dhtTreeView.set_rules_hint(True)
self.dhtTreeView.set_search_column(0)
self.dhtTreeView.connect('row-activated', self.downloadFile)
# Add the tree view to the scrolling window
sw.add(self.dhtTreeView)
# column for file name/description
column = gtk.TreeViewColumn('File list:',
gtk.CellRendererText(),
text=0)
column.set_sort_column_id(0)
self.dhtTreeView.append_column(column)
# Add the controls
# Search for keyword
hbox = gtk.HBox(False, 8)
hbox.show()
label = gtk.Label("Search:")
hbox.pack_start(label, False, False, 0)
label.show()
entryKeyword = gtk.Entry()
hbox.pack_start(entryKeyword, expand=True, fill=True)
entryKeyword.show()
button = gtk.Button('Search')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.search, entryKeyword)
button.show()
self.progressBar = gtk.ProgressBar()
self.progressBar.show()
hbox.pack_start(self.progressBar, expand=True, fill=True)
self.progressBar.show()
vbox.pack_start(hbox, expand=False, fill=False)
######### Publish data
vbox = gtk.VBox(spacing=3)
vbox.show()
notebook.append_page(vbox, gtk.Label('Share Local Files'))
# List view
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw)
model = self.createListStore([])
self.localTreeView = gtk.TreeView(model)
self.localTreeView.set_rules_hint(True)
self.localTreeView.set_search_column(0)
self.localTreeView.connect('row-activated', self.downloadFile)
sw.add(self.localTreeView)
column = gtk.TreeViewColumn('Shared Files:',
gtk.CellRendererText(),
text=0)
column.set_sort_column_id(0)
self.localTreeView.append_column(column)
hbox = gtk.HBox(False, 8)
hbox.show()
label = gtk.Label("Share directory:")
hbox.pack_start(label, False, False, 0)
label.show()
self.entryDir = gtk.Entry()
hbox.pack_start(self.entryDir, expand=True, fill=True)
self.entryDir.show()
button = gtk.Button('Browse')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.browseDirectory, self.entryDir.get_text)
button.show()
button = gtk.Button('Publish')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.publishDirectory,
self.entryDir.get_text)
button.show()
vbox.pack_start(hbox, expand=False, fill=False)
self._setupTCPNetworking()
self.show_all()
def __init__(self):
icon = gtk.status_icon_new_from_stock(gtk.STOCK_PASTE)
icon.connect('popup-menu', self.on_right_click)
icon.connect('activate', self.on_left_click)
pynotify.init(self.APP_NAME)
def __init__(self, node):
gtk.Window.__init__(self)
self.set_default_size(640, 480)
self.trayIcon = gtk.status_icon_new_from_stock(gtk.STOCK_FIND)
self.trayIcon.connect('popup-menu', self._trayIconRightClick)
self.trayIcon.connect('activate', self._trayIconClick)
self.node = node
self.connect("delete-event", self._hideWindow)
# Layout the window
highLevelVbox = gtk.VBox(spacing=3)
self.add(highLevelVbox)
highLevelVbox.show()
notebook = gtk.Notebook()
notebook.set_tab_pos(pos=gtk.POS_TOP)
notebook.show()
highLevelVbox.pack_start(notebook,expand=True, fill=True)
vbox = gtk.VBox(spacing=3)
vbox.show()
notebook.append_page(vbox, gtk.Label('Search P2P Network'))
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw)
# Create tree model
model = self.createListStore([])
# Create tree view
self.dhtTreeView = gtk.TreeView(model)
self.dhtTreeView.set_rules_hint(True)
self.dhtTreeView.set_search_column(0)
self.dhtTreeView.connect('row-activated', self.downloadFile)
# Add the tree view to the scrolling window
sw.add(self.dhtTreeView)
# column for file name/description
column = gtk.TreeViewColumn('File list:', gtk.CellRendererText(), text=0)
column.set_sort_column_id(0)
self.dhtTreeView.append_column(column)
# Add the controls
# Search for keyword
hbox = gtk.HBox(False, 8)
hbox.show()
label = gtk.Label("Search:")
hbox.pack_start(label, False, False, 0)
label.show()
entryKeyword = gtk.Entry()
hbox.pack_start(entryKeyword, expand=True, fill=True)
entryKeyword.show()
button = gtk.Button('Search')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.search, entryKeyword)
button.show()
self.progressBar = gtk.ProgressBar()
self.progressBar.show()
hbox.pack_start(self.progressBar, expand=True, fill=True)
self.progressBar.show()
vbox.pack_start(hbox, expand=False, fill=False)
######### Publish data
vbox = gtk.VBox(spacing=3)
vbox.show()
notebook.append_page(vbox, gtk.Label('Share Local Files'))
# List view
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw)
model = self.createListStore([])
self.localTreeView = gtk.TreeView(model)
self.localTreeView.set_rules_hint(True)
self.localTreeView.set_search_column(0)
self.localTreeView.connect('row-activated', self.downloadFile)
sw.add(self.localTreeView)
column = gtk.TreeViewColumn('Shared Files:', gtk.CellRendererText(), text=0)
column.set_sort_column_id(0)
self.localTreeView.append_column(column)
hbox = gtk.HBox(False, 8)
hbox.show()
label = gtk.Label("Share directory:")
hbox.pack_start(label, False, False, 0)
label.show()
self.entryDir = gtk.Entry()
hbox.pack_start(self.entryDir, expand=True, fill=True)
self.entryDir.show()
button = gtk.Button('Browse')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.browseDirectory, self.entryDir.get_text)
button.show()
button = gtk.Button('Publish')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.publishDirectory, self.entryDir.get_text)
button.show()
vbox.pack_start(hbox, expand=False, fill=False)
self._setupTCPNetworking()
self.show_all()
def create_gui(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_border_width(15)
self.window.set_default_size(380, 130)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_title('pyIpclient by:xspyhack@guetsec')
self.window.set_keep_above(True)
self.window.set_resizable(False)
self.window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color('#CCCCCC'))
self.window.connect('delete_event',
self.delete_event_callback, self.window)
self.window.connect('destroy', self.destroy_callback)
vbox = gtk.VBox(False, 10)
self.window.add(vbox)
hbox_msg = gtk.HBox(False, 0)
hbox_usage = gtk.HBox(False, 0)
hbox_input = gtk.HBox(False, 0)
hbox_btns = gtk.HBox(False, 0)
separator = gtk.HSeparator()
vbox.pack_start(hbox_msg, False, False, 0)
vbox.pack_start(hbox_usage, False, False, 0)
vbox.pack_start(hbox_input, False, False, 0)
vbox.pack_start(separator, False, False, 0)
vbox.pack_start(hbox_btns, False, False, 0)
self.label_msg = gtk.Label(u'新闻')
self.label_ip = gtk.Label('255.255.255.255')
self.label_flow = gtk.Label(u' 流量: 0.00KB')
self.label_money = gtk.Label(u' 剩余金额: 0.00元')
self.label_guetsec = gtk.Label('GUET Sec')
label_user = gtk.Label(u' 用户:')
label_pswd = gtk.Label(u' 密码:')
self.entry_user = gtk.Entry(max = 15)
self.entry_pswd = gtk.Entry(max = 20)
self.entry_pswd.set_visibility(False)
self.btn_remember = gtk.CheckButton(u'记住用户', False)
self.btn_autologin = gtk.CheckButton(u'自动登录', False)
self.btn_remember.connect ('clicked', self.btn_togg_clicked)
self.btn_autologin.connect('clicked', self.btn_togg_clicked)
btn_open = gtk.Button(u' 开放 ')
btn_stop = gtk.Button(u' 停止 ')
btn_hide = gtk.Button(u' 隐藏 ')
btn_exit = gtk.Button(u' 退出 ')
btn_open.connect('clicked', self.btn_open_clicked)
btn_stop.connect('clicked', self.btn_stop_clicked)
btn_hide.connect('clicked', self.btn_hide_clicked)
btn_exit.connect('clicked', self.btn_exit_clicked)
hbox_msg.pack_start(self.label_msg, True, True, 10)
hbox_msg.pack_start(self.label_ip, True, True, 10)
hbox_usage.pack_start(self.label_flow, True, True, 10)
hbox_usage.pack_start(self.label_guetsec, False, False, 0)
hbox_usage.pack_start(self.label_money,True, True, 0)
hbox_input.pack_start(label_user, False, False, 0)
hbox_input.pack_start(self.entry_user, False, False, 10)
hbox_input.pack_start(label_pswd, False, False, 10)
hbox_input.pack_start(self.entry_pswd, False, False, 5)
hbox_btns.pack_end(btn_exit, False, False, 5)
hbox_btns.pack_end(btn_hide, False, False, 5)
hbox_btns.pack_end(btn_stop, False, False, 5)
hbox_btns.pack_end(btn_open, False, False, 5)
hbox_btns.pack_end(self.btn_remember, False, False, 5)
hbox_btns.pack_end(self.btn_autologin, False, False, 5)
icon_path = CONF['SOFTWARE DIR'] + CONF['ICON NAME']
try:
# self.create_icon_file()
self.window.set_icon_from_file(icon_path)
self.statusicon = gtk.status_icon_new_from_file(icon_path)
except glib.GError:
self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_GO_FORWARD)
finally:
self.statusicon.connect('activate',self.trayicon_activate)
self.statusicon.set_tooltip(COPYRIGHT['SOFTWARE'])
def _build_ui(self):
ui_elements = [
"mainWindow",
"titleEntry",
"oneNoteSyncButton",
"tocList",
"tocListView",
"noteText",
"noteTextView",
"eventProgressBar",
"keypressLabel",
"cursorPositionLabel",
"printButton"
]
builder = gtk.Builder()
builder.add_from_file( os.path.join( sys.path[0], "notey.glade" ) )
for elem in ui_elements:
setattr(self, elem, builder.get_object(elem))
if disable_print:
self.printButton.set_property('visible', False)
#
# glade cannot handle Cells and CellRenders
# create them here
#
self.titleCellRenderer = gtk.CellRendererText()
self.titleCell = gtk.TreeViewColumn(
"Title",
self.titleCellRenderer,
text=0
)
self.titleCell.set_sort_column_id(0)
self.titleCellRenderer.connect(
'edited',
self.on_titleCell_edited,
self.tocList
)
self.titleCellRenderer.connect(
'editing-canceled',
self.on_titleCell_editing_cancelled,
self.tocList
)
self.modifiedDateCellRenderer = gtk.CellRendererText()
self.modifiedDateCell = gtk.TreeViewColumn(
"Modified Date",
self.modifiedDateCellRenderer,
text=1
)
self.tocListView.append_column(self.titleCell)
self.tocListView.append_column(self.modifiedDateCell)
self.tocListView.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.tocList.set_sort_func(0, self.compare_data, 0)
#make a status icon
self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_GOTO_TOP)
self.statusicon.connect('activate', self.status_clicked )
self.statusicon.set_tooltip("Notey is not hidden")
builder.connect_signals(self)
#
# for some strange reasons destroy-event is not useful
# unfortunately that is the event that glade on fedora14 knows about
# connect the mainWindow destroy event to the handler
#
self.mainWindow.connect("destroy", self.on_mainWindow_destroy)
def create_window(self):
# GTK initialisation
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect("delete_event", self.delete_event)
window.connect("destroy", self.destroy)
window.connect("window-state-event", self.win_state_cb)
window.set_border_width(10)
window.set_title("NagMe")
window.set_resizable(False)
self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_GOTO_TOP)
self.statusicon.connect('activate', self.status_clicked)
self.statusicon.set_visible(self.mainwin_hidden)
vbox = gtk.VBox(False, 5)
self.statusbar = gtk.Statusbar()
vbox.pack_end(self.statusbar, False, True, 0)
# I need to say something
label = gtk.Label("Don't forget things, just tell me, I will nag you!!\n"
"What you want to be reminded of?")
vbox.pack_start(label, True, True, 0)
self.textentry = gtk.Entry(max = 0)
vbox.pack_start(self.textentry, True, True, 0)
self.ptimer = gobject.timeout_add(200, self.timer_timer, self)
hbox1 = gtk.HBox(True, 5)
hbox2 = gtk.HBox(True, 5)
hbox3 = gtk.HBox(True, 5)
hbox0 = gtk.HBox(True, 5)
vbox.pack_start(hbox1, True, True, 0)
vbox.pack_start(hbox2, True, True, 0)
vbox.pack_start(hbox3, True, True, 0)
window.add(vbox)
label = gtk.Label("Hour :")
label.set_alignment(0, 0.5)
hbox1.pack_start(label, False, True, 0)
adj = gtk.Adjustment(0, 0.0, 23.0, 1.0, 5.0, 0.0)
self.hourspin = gtk.SpinButton(adj, 0, 0)
self.hourspin.set_wrap(True)
hbox1.pack_start(self.hourspin, False, True, 0)
label = gtk.Label("Minute :")
label.set_alignment(0, 0.5)
hbox1.pack_start(label, False, True, 0)
adj = gtk.Adjustment(0, 0.0, 59.0, 1.0, 5.0, 0.0)
self.minspin = gtk.SpinButton(adj, 0, 0)
self.minspin.set_wrap(True)
hbox1.pack_start(self.minspin, False, True, 0)
# Add a button for OK
buttonOK = gtk.Button(label=None, stock=gtk.STOCK_ADD)
buttonOK.connect("clicked", self.get_values, None)
hbox2.pack_start(buttonOK, True, True, 0)
add_tt = gtk.Tooltips()
add_tt.set_tip(buttonOK, "Add timer", tip_private=None) # Tool tip
# Add a button for clearing
buttonClear = gtk.Button(label=None, stock=gtk.STOCK_CLEAR)
buttonClear.connect_object("clicked", self.reset_values, None)
hbox2.pack_start(buttonClear, True, True, 0)
clear_tt = gtk.Tooltips()
clear_tt.set_tip(buttonClear, "Clear Form", tip_private=None)
# Close confirmation
confirm_close_toggle = gtk.CheckButton("_Confirm Close?")
confirm_close_toggle.connect("toggled", self.confirm_close_cb)
confirm_close_toggle.set_active(self.confirm_close)
hbox3.pack_start(confirm_close_toggle, True, True, 0)
# Relative or absolute timing?
relative_time_toggle = gtk.CheckButton("_Absolute timing?")
relative_time_toggle.connect("toggled", self.relative_time_cb)
hbox3.pack_start(relative_time_toggle, True, True, 0)
# Make a display to list timers
label_exp = gtk.Label("Timers")
self.expander = gtk.Expander(None)
self.expander.set_label_widget(label_exp)
self.expander.connect("notify::expanded", self.expanded)
vbox.pack_end(self.expander, True, True, 0)
list_tt = gtk.Tooltips()
list_tt.set_tip(self.expander, "Show all timers", tip_private=None)
self.timer_counter = gtk.Label("Nothing to remind")
self.timer_counter.set_justify(gtk.JUSTIFY_CENTER)
vbox.pack_start(self.timer_counter, True, True, 0)
return window
def __init__(self):
self.icon = gtk.status_icon_new_from_stock(gtk.STOCK_ABOUT)
# gtk.STOCK_YES gtk.STOCK_NO
self.icon.connect('popup-menu', self.on_right_click)
self.icon.connect('activate', self.on_left_click)
self.icon.set_tooltip((PROGRAM))
def make_menu(icon, button, time):
image_size = gtk.ICON_SIZE_MENU
menu = gtk.Menu()
itm_add_prof = gtk.ImageMenuItem('_Add a new profile')
add_prof_img = gtk.Image()
add_prof_img.set_from_stock(gtk.STOCK_ADD, image_size)
itm_add_prof.set_image(add_prof_img)
#itm_add_prof.connect('activate', btn_add_prof_press, None)
menu.append(itm_add_prof)
itm_quit = gtk.ImageMenuItem('_Quit')
quit_img = gtk.Image()
quit_img.set_from_stock(gtk.STOCK_QUIT, image_size)
itm_quit.set_image(quit_img)
itm_quit.connect('activate', gtk.main_quit)
menu.append(itm_quit)
menu.show_all()
menu.popup(None, None, gtk.status_icon_position_menu, button,
time, icon)
if __name__ == '__main__':
notify_icon = gtk.status_icon_new_from_stock(gtk.STOCK_CONNECT)
notify_icon.connect('popup-menu', make_menu)
#notify_icon.connect('activate', btn_play_press, None)
gtk.main()
def __init__(self):
# Creo una nuova finestra
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
# Setto un titolo alla finestra
self.window.set_title("Openvpn PyGTK Gui")
# Se viene cliccata la "x" in altro a destra della finestra viene eseguita
# la funzione self.hideondel_event.
# Solitamente viene richiamata la funzione gtk.main_quit() per chiudere la finestra,
# in questo caso viene ridotta nel system tray
self.window.connect("delete_event", self.hideondel_event)
# Setto la larghezza dei bordi della finestra
self.window.set_border_width(20)
# Creo una vertical box
vbox = gtk.VBox(True, 2)
# Inserisco la vertical box nella finestra principale del programma
self.window.add(vbox)
# Se non trovo il binario dell'openvpn creo una finestra d'errore
if not self.CheckOpenvpnBin(self.openvpnclipath):
errmessage = gtk.MessageDialog(type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_OK)
errmessage.set_markup("Openvpn not found")
errmessage.set_default_response(gtk.RESPONSE_OK)
errmessage.run()
errmessage.destroy()
# Se non trovo la cartella contenente i file .ovpn creo una finestra d'errore
if not self.CheckOpenvpnDir(self.openvpnclidir):
errmessage = gtk.MessageDialog(type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_OK)
errmessage.set_markup("Openvpn conf dir not found")
errmessage.run()
errmessage.destroy()
# Tramite la funzione OvpnFileList creo una lista contenente tutti i file .ovpn
connectionlist = self.OvpnFileList()
# Creo una lista di tutti i CheckButton
# In questo modo posso gestire e modificare ogni bottone in maniera autonoma (ciclando la lista)
self.chckbuttonlist = []
# Ciclo le connessioni vpn in ordine alfabetico (sorted) per creare i CheckButtons
for vpn in sorted(connectionlist):
vpnname = vpn.split("#####")[0]
vpndir = vpn.split("#####")[1]
vpnfull = vpn.split("#####")[2]
# Creo il checkbutton dandogli il nome del file openvpn senza estensione .ovpn
self.chckbutton = gtk.CheckButton(vpnname[:-5])
# Inserisco il checkbutton nella lista completa
self.chckbuttonlist.append(self.chckbutton)
# Controllo se tra i processi del sistema ci sono gia in esecuzione le vpn
for ovpnprocess in self.CheckOpenvpnProc():
# Se trovo una connessione tra i processi setto il checkbutton come attivo
if vpnfull in str(ovpnprocess[-1:]):
self.chckbutton.set_active(True)
# Se spunto il checkbutton di una vpn, eseguo la funzione StartStopConn
# così da decidere se far partire o stoppare una connessione openvpn.
self.chckbutton.connect("toggled", self.StartStopConn, vpnfull, vpndir, self.chckbutton)
# Inserisco il bottone nella vertical box precedentemente creata
vbox.pack_start(self.chckbutton, True, True, 2)
# Mostro il bottone nella GUI.
self.chckbutton.show()
# Creo una progressbar
self.progressbar = gtk.ProgressBar()
# Inserisco la progressbar sotto i CheckButtons all'interno della vertical box
vbox.pack_start(self.progressbar, True, True, 2)
# Mostro la progressbar
self.progressbar.show()
# Creo il bottone Quit
button = gtk.Button("Quit")
# Quando il bottone Quit viene premuto chiudo la finestra principale
button.connect("clicked", lambda wid: gtk.main_quit())
# Inserisco il bottone Quit nella vertical box
vbox.pack_start(button, True, True, 2)
# Mostro il bottone Quit
button.show()
# Mostro la vertical box
vbox.show()
# Appena creata la finestra principale la riduco nel system tray.
self.window.hide_on_delete()
# Inserisco l'icona della finestra per il system tray.
self.icon = gtk.status_icon_new_from_stock(gtk.STOCK_CONNECT)
# Se viene cliccata l'icona del system tray esegui la funzione self.status_clicked
self.icon.connect('activate', self.status_clicked )
def build_gui(self):
print "Starting GUI for cyberoam-linux client.."
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.gotoTray)
self.window.connect("destroy", self.destroy)
#self.window.set_border_width(24)
self.window.set_size_request(400, 200)
self.window.set_title("Cyberoam client")
self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.window.set_resizable(False)
topwid=gtk.VBox(gtk.FALSE, 0)
mb = gtk.MenuBar()
appmenu = gtk.Menu()
app = gtk.MenuItem("App")
app.set_submenu(appmenu)
exit = gtk.MenuItem("Exit")
exit.connect("activate", self.destroy)
appmenu.append(exit)
mb.append(app)
vbox = gtk.VBox(False, 2)
vbox.pack_start(mb, False, False, 0)
topwid.pack_start(vbox)
table = gtk.Table(3, 3, True)
topwid.pack_start(table)
label = gtk.Label("Username")
table.attach(label,0,1,0,1)
label.show()
self.username=gtk.Entry(max=10)
table.attach(self.username,1,3,0,1)
self.username.show()
label1 = gtk.Label("Password")
table.attach(label1,0,1,1,2)
label1.show()
self.password=gtk.Entry(max=10)
table.attach(self.password,1,3,1,2)
self.password.set_visibility(False)
self.password.show()
self.button=gtk.Button("Login")
self.button.connect("clicked",self.click_button)
table.attach(self.button,1,3,2,3)
self.button.show()
#
table.show()
self.window.add(topwid)
topwid.show()
self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_NETWORK)
self.statusicon.connect('activate', self.status_clicked )
self.statusicon.set_name("Cyberoam")
self.window.show_all()
self.winstatus='showing'
gtk.main()
def GMailNotifier():
icon = gtk.status_icon_new_from_stock(gtk.STOCK_QUIT)
icon.set_tooltip("Hello")
#icon.connect("activate", activate)
icon.connect("popup-menu", popup_menu)
def __init__(self, node,port,groups,name,eid,guest):
gtk.Window.__init__(self)
self.set_default_size(800, 600)
self.trayIcon = gtk.status_icon_new_from_stock(gtk.STOCK_FIND)
self.trayIcon.connect('popup-menu', self._trayIconRightClick)
self.trayIcon.connect('activate', self._trayIconClick)
self.node = node
self.groups = groups
self.connect("delete-event", self._hideWindow)
# Layout the window
highLevelVbox = gtk.VBox(spacing=3)
self.add(highLevelVbox)
highLevelVbox.show()
notebook = gtk.Notebook()
notebook.set_tab_pos(pos=gtk.POS_TOP)
notebook.show()
highLevelVbox.pack_start(notebook,expand=True, fill=True)
###USER INFO
hbox2 = gtk.HBox(spacing=3)
hbox2.show()
notebook.append_page(hbox2, gtk.Label('User Information'))
vbox = gtk.VBox(spacing=3)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw)
self.userList = gtk.TreeStore(str)
# Create tree view
self.dTV = gtk.TreeView(gtk.TreeStore(str))
self.dTV.set_rules_hint(True)
self.dTV.set_search_column(0)
#self.dTV.connect('row-activated', self.downloadFile)
sw.add(self.dTV)
column = gtk.TreeViewColumn('Current Online Users:', gtk.CellRendererText(), text=0)
column.set_sort_column_id(0)
self.dTV.append_column(column)
self.dTV.set_reorderable(True)
self.dTV.set_show_expanders(False)
self.dTV.set_level_indentation(10)
vbox.show()
hbox2.pack_start(vbox, expand=True, fill=True)
vbox = gtk.VBox(spacing=3)
hbox = gtk.HBox(False, 5)
hbox.show()
if(guest):
g='YES'
else:
g='NO'
frame = gtk.Frame("Currently Logged User:"******"Name:\t"+name+"\nEmail:\t"+eid+"\nGuest Login:\t"+g)
labelgrp = gtk.Label("Groups:\t"+self.groups)
vboxLabel = gtk.VBox(spacing=3)
vboxLabel.pack_start(label,expand=False, fill=False)
vboxLabel.pack_start(labelgrp,expand=False, fill=False)
hbox.pack_start(frame, expand=True, fill=True)
label.show()
labelgrp.show()
frame.add(vboxLabel)
vboxLabel .show()
frame.show()
vbox.pack_start(hbox,expand=False, fill=False)
hbox = gtk.HBox(False, 5)
hbox.show()
aGrpTxt = gtk.Entry()
hbox.pack_start(aGrpTxt, expand=True, fill=True)
aGrpTxt.show()
aGrpBtn = gtk.Button('Add Group(s)')
hbox.pack_start(aGrpBtn, expand=True, fill=True)
vbox.pack_start(hbox,expand=False, fill=False)
hbox = gtk.HBox(False, 5)
hbox.show()
dGrpTxt = gtk.Entry()
hbox.pack_start(dGrpTxt, expand=True, fill=True)
dGrpTxt.show()
dGrpBtn = gtk.Button('Delete Group')
hbox.pack_start(dGrpBtn, expand=True, fill=True)
vbox.pack_start(hbox,expand=False, fill=False)
hbox = gtk.HBox(False, 5)
hbox.show()
#chat logs todo
frame = gtk.Frame('Chat Logs')
textview = gtk.TextView()
frame.add(textview)
textview.set_editable(False)
textbuffer = textview.get_buffer()
textbuffer.set_text('Chat Log Todo')
hbox.pack_start(frame, expand=True, fill=True)
textview.show()
frame.show()
vbox.pack_start(hbox)
vbox.show()
hbox2.pack_start(vbox, expand=True, fill=True)
###search info
vbox = gtk.VBox(spacing=3)
vbox.show()
notebook.append_page(vbox, gtk.Label('Search P2P Network'))
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw)
# Create tree model
model = self.createListStore([])
self.actualModel = []
# Create tree view
self.dhtTreeView = gtk.TreeView(model)
self.dhtTreeView.set_rules_hint(True)
self.dhtTreeView.set_search_column(0)
self.dhtTreeView.connect('row-activated', self.downloadFile)
# Add the tree view to the scrolling window
sw.add(self.dhtTreeView)
# column for file name/description
column = gtk.TreeViewColumn('File list:', gtk.CellRendererText(), text=0)
column.set_sort_column_id(0)
self.dhtTreeView.append_column(column)
#column = gtk.TreeViewColumn('Associated Group:', gtk.CellRendererText(), text=0)
#column.set_sort_column_id(1)
#self.dhtTreeView.append_column(column)
# Add the controls
# Search for keyword
hbox = gtk.HBox(False, 5)
hbox.show()
label = gtk.Label("Smart Search:")
hbox.pack_start(label, False, False, 0)
label.show()
entryKeyword = gtk.Entry()
hbox.pack_start(entryKeyword, expand=True, fill=True)
entryKeyword.show()
labelGrp = gtk.Label("in Group:")
hbox.pack_start(labelGrp, False, False, 0)
labelGrp.show()
entryKeywordGrp = gtk.Entry()
hbox.pack_start(entryKeywordGrp, expand=True, fill=True)
entryKeywordGrp.set_text(self.groups)
print groups
entryKeywordGrp.show()
button = gtk.Button('Search')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.search, entryKeyword, entryKeywordGrp)
button.show()
self.progressBar = gtk.ProgressBar()
self.progressBar.show()
hbox.pack_start(self.progressBar, expand=True, fill=True)
self.progressBar.show()
vbox.pack_start(hbox,expand=False, fill=False)
#vbox.pack_start(hboxGrp, expand=False, fill=False)
######### Publish data
vbox = gtk.VBox(spacing=3)
vbox.show()
notebook.append_page(vbox, gtk.Label('Share Local Files'))
# List view
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw)
model = self.createListStore([])
self.localTreeView = gtk.TreeView(model)
self.localTreeView.set_rules_hint(True)
self.localTreeView.set_search_column(0)
self.localTreeView.connect('row-activated', self.downloadFile)
sw.add(self.localTreeView)
column = gtk.TreeViewColumn('Shared Files:', gtk.CellRendererText(), text=0)
column.set_sort_column_id(0)
self.localTreeView.append_column(column)
hbox = gtk.HBox(False, 8)
hbox.show()
label = gtk.Label("Share directory:")
hbox.pack_start(label, False, False, 0)
label.show()
self.entryDir = gtk.Entry()
hbox.pack_start(self.entryDir, expand=True, fill=True)
self.entryDir.show()
'''
labelGrp = gtk.Label("Publisher Group:")
hbox.pack_start(labelGrp, False, False, 0)
labelGrp.show()
'''
entryKeywordGrp2 = gtk.Entry()
'''
hbox.pack_start(entryKeywordGrp2, expand=True, fill=True)
entryKeywordGrp2.show()
'''
entryKeywordGrp2.set_text(self.groups)
button = gtk.Button('Browse')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.browseDirectory, self.entryDir.get_text)
button.show()
button = gtk.Button('Publish')
hbox.pack_start(button, expand=False, fill=False)
button.connect("clicked", self.publishDirectory, self.entryDir.get_text, entryKeywordGrp2,(not guest))
button.show()
vbox.pack_start(hbox, expand=False, fill=False)
aGrpBtn.connect("clicked",self.addGroup,aGrpTxt,entryKeywordGrp2,entryKeywordGrp,labelgrp)
aGrpBtn.show()
dGrpBtn.connect("clicked",self.delGroup,dGrpTxt,entryKeywordGrp2,entryKeywordGrp,labelgrp)
dGrpBtn.show()
self._setupTCPNetworking(port)
if(not guest):
self.publishOldFiles(entryKeywordGrp2)
#no longer used
#df = self.node.publishData(name+':us3rn@me:'+self.groups.replace(',',':'),self.node.id)
#df.addCallback(self.updateUsers)
self.publishMyself(name,eid)
gobject.timeout_add(5000, self.updateUsers)
self.show_all()
def __init__(self, message):
self.tray = gtk.status_icon_new_from_stock(gtk.STOCK_QUIT)
self.msg = message
self.tray.connect('popup-menu', self.on_right_click, self.msg)
def __init__(self):
self.icon = gtk.status_icon_new_from_stock(gtk.STOCK_ABOUT)
# gtk.STOCK_YES gtk.STOCK_NO
self.icon.connect('popup-menu', self.on_right_click)
self.icon.connect('activate', self.on_left_click)
self.icon.set_tooltip((PROGRAM))
close_item.show()
#Popup the menu
menu.popup(None, None, None, event_button, event_time)
def on_right_click(data, event_button, event_time):
make_menu(event_button, event_time)
def on_left_click(event):
#win.show_all()
# open_app()
win.show()
#message("Status Icon Left Clicked")
#def main( self):
# open_app()
# gtk.main()
if __name__ == '__main__':
# self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_GOTO_TOP)
icon = gtk.status_icon_new_from_stock(gtk.STOCK_ABOUT)
icon.connect('popup-menu', on_right_click)
icon.connect('activate', on_left_click)
#m = MyGUI( "TextView example")
#m.main()
open_app()
gtk.main()
def __init__(self):
# Create appindicator object
if have_appindicator:
self.ind = appindicator.Indicator("example-simple-client",
"indicator-messages",
appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status(appindicator.STATUS_ACTIVE)
self.ind.set_icon(
os.path.abspath("biertje.svg"))
else:
self.ind = gtk.status_icon_new_from_stock(gtk.STOCK_HOME)
# Create menu object
self.menu = gtk.Menu() # create the main menu item
self.menuWeight = gtk.MenuItem(
'Het fust weegt {printWeight} Kg'.
format(printWeight=self.gewicht + self.emptyweight))
self.menuWeight.set_sensitive(False)
menuItemBeer = gtk.MenuItem('Beer')
menuItemOptions = gtk.MenuItem('Options')
menuItemQuit = gtk.MenuItem('Quit')
self.menubeer = gtk.Menu() # Create second menu for the submenu
self.menuoptions = gtk.Menu() # make options allso a menu
# Make MenuItemBeer submenuable
menuItemBeer.set_submenu(self.menubeer)
# make the menuoptions a submenu of itemoptions
menuItemOptions.set_submenu(self.menuoptions)
self.suboptionsNixie = gtk.CheckMenuItem("Nixies")
self.suboptionsLeds = gtk.CheckMenuItem("LEDs")
self.suboptionsColor = gtk.MenuItem("Select LED color")
self.suboptionsCal = gtk.MenuItem("Calibrate scale")
self.menu.append(self.menuWeight)
self.menu.append(gtk.SeparatorMenuItem())
self.menu.append(menuItemBeer)
self.menu.append(menuItemOptions)
self.menu.append(menuItemQuit)
self.menuoptions.append(self.suboptionsNixie)
self.menuoptions.append(self.suboptionsLeds)
self.menuoptions.append(self.suboptionsColor)
self.menuoptions.append(self.suboptionsCal)
self.menuoptions.append(gtk.SeparatorMenuItem())
self.beerEdit = gtk.MenuItem(label="Edit beer list")
self.menuoptions.append(self.beerEdit)
self.beerEdit.connect("activate", self.openFile, "fustlijst.json")
self.menuoptions.append(gtk.SeparatorMenuItem())
menuItemQuit.connect('activate', self.quit, "quit")
self.createBeerList()
self.createPortList()
self.suboptionsNixie.connect("activate", self.writeArduino)
self.suboptionsLeds.connect("activate", self.writeArduino)
self.colorseldlg = None
self.suboptionsColor.connect("activate", self.colorSelector)
self.suboptionsCal.connect("activate", self.calWindow)
self.loadfile()
self.menu.show_all()
# Add constructed menu as indicator menu
self.ind.set_menu(self.menu)
# Append the menu items
menu.append(open_item)
menu.append(close_item)
# add callbacks
open_item.connect_object("activate", open_app, "Open App")
close_item.connect_object("activate", close_app, "Close App")
# Show the menu items
open_item.show()
close_item.show()
# Popup the menu
menu.popup(None, None, None, event_button, event_time)
def on_right_click(data, event_button, event_time):
make_menu(event_button, event_time)
def on_left_click(event):
message("Status Icon Left Clicked")
if __name__ == "__main__":
icon = gtk.status_icon_new_from_stock(gtk.STOCK_ABOUT)
icon.connect("popup-menu", on_right_click)
icon.connect("activate", on_left_click)
gtk.main()
def __init__(self, show_kthreads = True, show_uthreads = True, cpus_filtered = []):
global tuna_glade
(app, localedir) = ('tuna', '/usr/share/locale')
gtk.glade.bindtextdomain(app, localedir)
gtk.glade.textdomain(app)
if self.check_root():
sys.exit(1)
for dir in tuna_glade_dirs:
tuna_glade = "%s/tuna_gui.glade" % dir
if os.access(tuna_glade, os.F_OK):
break
self.wtree = gtk.glade.XML(tuna_glade, "mainbig_window", "tuna")
self.ps = procfs.pidstats()
self.irqs = procfs.interrupts()
self.window = self.wtree.get_widget("mainbig_window")
self.procview = procview(self.wtree.get_widget("processlist"),
self.ps, show_kthreads, show_uthreads,
cpus_filtered, tuna_glade)
self.irqview = irqview(self.wtree.get_widget("irqlist"),
self.irqs, self.ps, cpus_filtered,
tuna_glade)
self.cpuview = cpuview(self.wtree.get_widget("vpaned1"),
self.wtree.get_widget("hpaned2"),
self.wtree.get_widget("cpuview"),
self.procview, self.irqview, cpus_filtered)
self.config = Config()
self.check_env()
self.commonview = commonview()
self.commonview.contentTable = self.wtree.get_widget("commonTbl")
self.commonview.configFileCombo = self.wtree.get_widget("profileSelector")
self.profileview = profileview()
self.profileview.config = self.config
self.commonview.config = self.config
self.profileview.commonview = self.commonview
self.commonview.profileview = self.profileview
self.profileview.setWtree(self.wtree)
self.profileview.init_default_file()
event_handlers = { "on_mainbig_window_delete_event" : self.on_mainbig_window_delete_event,
"on_processlist_button_press_event" : self.procview.on_processlist_button_press_event,
"on_irqlist_button_press_event" : self.irqview.on_irqlist_button_press_event,
"on_loadProfileButton_clicked" : self.profileview.on_loadProfileButton_clicked,
"on_SaveButton_clicked" : self.profileview.on_SaveButton_clicked,
"on_UpdateButton_clicked" : self.profileview.on_UpdateButton_clicked,
"on_applyChanges_clicked" : self.commonview.on_applyChanges_clicked,
"on_undoChanges_clicked" : self.commonview.on_undoChanges_clicked,
"on_saveSnapshot_clicked" : self.commonview.on_saveSnapshot_clicked,
"on_saveTunedChanges_clicked" : self.commonview.on_saveTunedChanges_clicked,
"on_profileSelector_changed" : self.commonview.on_profileSelector_changed,
"on_profileTree_button_press_event" : self.profileview.on_profileTree_button_press_event
}
self.wtree.signal_autoconnect(event_handlers)
self.ps.reload_threads()
self.show()
self.timer = gobject.timeout_add(2500, self.refresh)
try:
self.icon = gtk.status_icon_new_from_stock(gtk.STOCK_PREFERENCES)
self.icon.connect("activate", self.on_status_icon_activate)
self.icon.connect("popup-menu", self.on_status_icon_popup_menu)
except AttributeError:
# Old pygtk2
pass
pixbuf = self.window.render_icon(gtk.STOCK_PREFERENCES,
gtk.ICON_SIZE_SMALL_TOOLBAR)
self.window.set_icon(pixbuf)
def StatusIconDemo(parent=None):
icon = gtk.status_icon_new_from_stock(gtk.STOCK_QUIT)
icon.connect('popup-menu', on_right_click)
def create_gui(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_border_width(15)
self.window.set_default_size(380, 130)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_title('pyIpclient by:xspyhack@guetsec')
self.window.set_keep_above(True)
self.window.set_resizable(False)
self.window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color('#CCCCCC'))
self.window.connect('delete_event', self.delete_event_callback,
self.window)
self.window.connect('destroy', self.destroy_callback)
vbox = gtk.VBox(False, 10)
self.window.add(vbox)
hbox_msg = gtk.HBox(False, 0)
hbox_usage = gtk.HBox(False, 0)
hbox_input = gtk.HBox(False, 0)
hbox_btns = gtk.HBox(False, 0)
separator = gtk.HSeparator()
vbox.pack_start(hbox_msg, False, False, 0)
vbox.pack_start(hbox_usage, False, False, 0)
vbox.pack_start(hbox_input, False, False, 0)
vbox.pack_start(separator, False, False, 0)
vbox.pack_start(hbox_btns, False, False, 0)
self.label_msg = gtk.Label(u'新闻')
self.label_ip = gtk.Label('255.255.255.255')
self.label_flow = gtk.Label(u' 流量: 0.00KB')
self.label_money = gtk.Label(u' 剩余金额: 0.00元')
self.label_guetsec = gtk.Label('GUET Sec')
label_user = gtk.Label(u' 用户:')
label_pswd = gtk.Label(u' 密码:')
self.entry_user = gtk.Entry(max=15)
self.entry_pswd = gtk.Entry(max=20)
self.entry_pswd.set_visibility(False)
self.btn_remember = gtk.CheckButton(u'记住用户', False)
self.btn_autologin = gtk.CheckButton(u'自动登录', False)
self.btn_remember.connect('clicked', self.btn_togg_clicked)
self.btn_autologin.connect('clicked', self.btn_togg_clicked)
btn_open = gtk.Button(u' 开放 ')
btn_stop = gtk.Button(u' 停止 ')
btn_hide = gtk.Button(u' 隐藏 ')
btn_exit = gtk.Button(u' 退出 ')
btn_open.connect('clicked', self.btn_open_clicked)
btn_stop.connect('clicked', self.btn_stop_clicked)
btn_hide.connect('clicked', self.btn_hide_clicked)
btn_exit.connect('clicked', self.btn_exit_clicked)
hbox_msg.pack_start(self.label_msg, True, True, 10)
hbox_msg.pack_start(self.label_ip, True, True, 10)
hbox_usage.pack_start(self.label_flow, True, True, 10)
hbox_usage.pack_start(self.label_guetsec, False, False, 0)
hbox_usage.pack_start(self.label_money, True, True, 0)
hbox_input.pack_start(label_user, False, False, 0)
hbox_input.pack_start(self.entry_user, False, False, 10)
hbox_input.pack_start(label_pswd, False, False, 10)
hbox_input.pack_start(self.entry_pswd, False, False, 5)
hbox_btns.pack_end(btn_exit, False, False, 5)
hbox_btns.pack_end(btn_hide, False, False, 5)
hbox_btns.pack_end(btn_stop, False, False, 5)
hbox_btns.pack_end(btn_open, False, False, 5)
hbox_btns.pack_end(self.btn_remember, False, False, 5)
hbox_btns.pack_end(self.btn_autologin, False, False, 5)
icon_path = CONF['SOFTWARE DIR'] + CONF['ICON NAME']
try:
# self.create_icon_file()
self.window.set_icon_from_file(icon_path)
self.statusicon = gtk.status_icon_new_from_file(icon_path)
except glib.GError:
self.statusicon = gtk.status_icon_new_from_stock(
gtk.STOCK_GO_FORWARD)
finally:
self.statusicon.connect('activate', self.trayicon_activate)
self.statusicon.set_tooltip(COPYRIGHT['SOFTWARE'])
def StatusIconDemo(parent=None):
icon = gtk.status_icon_new_from_stock(gtk.STOCK_QUIT)
icon.connect('popup-menu', on_right_click)
i.show()
sep = gtk.SeparatorMenuItem()
menu.append(sep)
sep.show()
close_item = gtk.MenuItem("Quit")
close_item.connect_object("activate", close_app, "Close App")
menu.append(close_item)
close_item.show()
menu.popup(None, None, None, event_button, event_time)
def on_script_click(widget):
if widget.active is False:
script_handler.desactivate(widget.get_label())
else:
script_handler.activate(widget.get_label())
def on_right_click(data, event_button, event_time):
make_menu(event_button, event_time)
def close_app(data=None):
script_handler.kill_threads()
gtk.main_quit()
if __name__ == '__main__':
script_handler = ScriptHandler()
icon = gtk.status_icon_new_from_stock(gtk.STOCK_EXECUTE)
icon.connect('popup-menu', on_right_click)
icon.set_has_tooltip(True)
icon.set_tooltip_text(APPNAME + " | " + VERSION)
gtk.main()
