def main():
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("GTK-Menu Info"):
enable_color()
log.enable_debug()
try:
from xpra.x11.gtk2.gdk_display_source import display #@UnresolvedImport
assert display
xid = 0
if len(sys.argv) > 1:
wid = sys.argv[1]
if wid.startswith("0x"):
xid = int(wid[2:], 16)
else:
xid = int(wid)
except Exception as e:
log.error("Error: invalid window id: %s", e)
log.error("usage:")
log.error(" %s WINDOWID", sys.argv[0])
else:
import gtk
from gtk import gdk
def get_frame_extents(window):
from xpra.x11.gtk_x11.prop import prop_get, log as x11log
x11log.enable_debug()
def pget(key, etype):
return prop_get(window,
key,
etype,
ignore_errors=False,
raise_xerrors=True)
return pget("_NET_FRAME_EXTENTS", ["u32"])
if xid > 0:
#show for an existing window:
w = gdk.window_foreign_new(xid)
log.info("_NET_FRAME_EXTENTS=%s", get_frame_extents(w))
else:
#create a window an send the request:
root = gdk.get_default_root_window()
from xpra.gtk_common.gtk_util import WINDOW_TOPLEVEL, get_xwindow
#code ripped from gtk_client_base:
from xpra.gtk_common.error import xsync
from xpra.x11.gtk_x11.send_wm import send_wm_request_frame_extents
window = gtk.Window(WINDOW_TOPLEVEL)
window.set_title("Xpra-FRAME_EXTENTS")
window.connect("destroy", gtk.main_quit)
window.realize()
win = window.get_window()
vbox = gtk.VBox(False, 0)
btn = gtk.Button("request frame extents")
def request_frame_extents(*args):
with xsync:
log("request_frame_extents() window=%#x",
get_xwindow(win))
send_wm_request_frame_extents(root, win)
btn.connect("clicked", request_frame_extents)
vbox.pack_start(btn, expand=False, fill=False, padding=10)
label = gtk.Label()
vbox.add(label)
window.add(vbox)
label.set_text(str(get_frame_extents(win)))
from gi.repository import GLib
def refresh_label():
v = get_frame_extents(win)
label.set_text(str(v))
log.info("_NET_FRAME_EXTENTS=%s", v)
return True
window.realize()
request_frame_extents()
GLib.timeout_add(5000, window.show_all)
GLib.timeout_add(1000, refresh_label)
gtk.main()
def unlock_tray(self, is_showing_dlg=[False]):
try:
from hashlib import sha1 as sha_hash
except ImportError:
from sha import new as sha_hash
log.debug("Show tray lock dialog")
if is_showing_dlg[0]:
return
is_showing_dlg[0] = True
entered_pass = gtk.Entry(25)
entered_pass.set_activates_default(True)
entered_pass.set_width_chars(25)
entered_pass.set_visibility(False)
tray_lock = gtk.Dialog(title="",
parent=self.window.window,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OK, gtk.RESPONSE_OK))
tray_lock.set_default_response(gtk.RESPONSE_OK)
tray_lock.set_has_separator(False)
tray_lock.set_border_width(5)
hbox = gtk.HBox(spacing=5)
image = gtk.image_new_from_file(deluge.common.get_pixmap("lock48.png"))
image.set_alignment(0.5, 0.0)
hbox.pack_start(image, False)
vbox = gtk.VBox(spacing=5)
hbox.pack_start(vbox, False)
label = gtk.Label("<b><big>%s</big></b>" %
_("Deluge is password protected!"))
label.set_use_markup(True)
label.set_alignment(0.0, 0.5)
label.set_line_wrap(True)
vbox.pack_start(label, False)
tlabel = gtk.Label("<i>%s</i>" % _("Enter your password to continue"))
tlabel.set_use_markup(True)
tlabel.set_alignment(0.0, 0.5)
tlabel.set_line_wrap(True)
vbox.pack_start(tlabel, False)
vbox.pack_start(entered_pass)
tray_lock.vbox.pack_start(hbox)
def on_response(dialog, response_id):
if response_id == gtk.RESPONSE_OK:
if self.config["tray_password"] == sha_hash(
entered_pass.get_text()).hexdigest():
self.window.present()
tray_lock.destroy()
is_showing_dlg[0] = False
tray_lock.connect("response", on_response)
tray_lock.show_all()
## main script for testing the image + cube problem on mac, causes
## some errors because it doesn't send a demowindow to the canvas, but
## is still good enough to check whether both actors show up.
if __name__ == "__main__":
window = gtk.Window()
window.set_title("The Canvas 3D Test")
window.connect("destroy", gtk.mainquit)
window.connect("delete_event", gtk.mainquit)
window.set_border_width(10)
vtkda = Canvas3D(None)
vtkda.show()
vbox = gtk.VBox(spacing=3)
vbox.show()
vbox.pack_start(vtkda)
button = gtk.Button('My Button')
button.show()
vbox.pack_start(button)
window.add(vbox)
window.set_size_request(400, 400)
window.show()
# The VTK stuff.
cone = vtk.vtkConeSource()
cone.SetResolution(80)
def __init__(self,imageName):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Tesseract Box Editor")
self.window.connect('destroy', lambda w: gtk.main_quit())
self.window.set_size_request(800, 600)
self.imageName = imageName
print self.imageName
vbox = gtk.VBox(False, 2)
self.window.add(vbox)
vbox.show()
menuBar = self.makeMenu()
vbox.pack_start(menuBar, False)
self.scrolledWindow = gtk.ScrolledWindow()
self.scrolledWindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
vbox.pack_start(self.scrolledWindow, True, True, 2)
self.scrolledWindow.show()
self.drawingArea = gtk.DrawingArea()
self.drawingArea.connect("expose-event", self.redrawArea)
self.scrolledWindow.add_with_viewport(self.drawingArea)
self.drawingArea.show()
self.textScroll = gtk.ScrolledWindow()
self.textScroll.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
vbox.pack_start(self.textScroll, True, True, 2)
self.textScroll.show()
self.textVBox = gtk.VBox()
self.textScroll.add_with_viewport(self.textVBox)
self.textVBox.show()
self.buttonBox = gtk.HBox(False, 0)
vbox.pack_start(self.buttonBox, False, False, 2)
self.buttonBox.show()
b = gtk.CheckButton("_Bold", True)
self.buttonBox.pack_start(b, False, False, 10)
b.connect("toggled", self.onCheckButtonToggled, ATTR_BOLD)
b.add_accelerator("activate", self.accelGroup, ord('B'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
b.show()
self.boldButton = b
b = gtk.CheckButton("_Italic", True)
self.buttonBox.pack_start(b, False, False, 10)
b.connect("toggled", self.onCheckButtonToggled, ATTR_ITALIC)
b.add_accelerator("activate", self.accelGroup, ord('I'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
b.show()
self.italicButton = b
b = gtk.CheckButton("_Underline", True)
self.buttonBox.pack_start(b, False, False, 10)
b.connect("toggled", self.onCheckButtonToggled, ATTR_UNDERLINE)
b.add_accelerator("activate", self.accelGroup, ord('U'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
b.show()
self.underlineButton = b
self.spinBottom = gtk.SpinButton()
self.spinBottom.connect("changed", self.onSpinButtonChanged, DIR_BOTTOM)
self.buttonBox.pack_end(self.spinBottom, False, False, 0)
self.spinBottom.show()
l = gtk.Label(" Bottom:");
self.buttonBox.pack_end(l, False, False, 0)
l.show()
self.spinTop = gtk.SpinButton()
self.spinTop.connect("changed", self.onSpinButtonChanged, DIR_TOP)
self.buttonBox.pack_end(self.spinTop, False, False, 0)
self.spinTop.show()
l = gtk.Label(" Top:");
self.buttonBox.pack_end(l, False, False, 0)
l.show()
self.spinRight = gtk.SpinButton()
self.spinRight.connect("changed", self.onSpinButtonChanged, DIR_RIGHT)
self.buttonBox.pack_end(self.spinRight, False, False, 0)
self.spinRight.show()
l = gtk.Label(" Right:");
self.buttonBox.pack_end(l, False, False, 0)
l.show()
self.spinLeft = gtk.SpinButton()
self.spinLeft.connect("changed", self.onSpinButtonChanged, DIR_LEFT)
self.buttonBox.pack_end(self.spinLeft, False, False, 0)
self.spinLeft.show()
l = gtk.Label("Left:");
self.buttonBox.pack_end(l, False, False, 0)
l.show()
self.setImageControlSensitivity(False)
self.setSymbolControlSensitivity(False)
self.window.show()
self.loadImageAndBoxes(None,None)
def __init__(self):
QTWindow.__init__(self, 'source', 'Source')
self.connect("delete-event", self._delete_event_cb)
self._find_string = ''
self._find_ofs = 0
menu = [{
'name':
_L('File'),
'submenu': [{
'name': _L('Open'),
'action': self._open_cb,
'accel': '<Control>o'
}, {
'name': _L('Close'),
'action': self._close_cb,
'accel': '<Control>x'
}, {
'name': _L('Save'),
'action': self._save_cb,
'accel': '<Control>s'
}, {
'name': _L('Save as'),
'action': self._save_as_cb
}, {
'name': _L('Run'),
'action': self._run_clicked_cb,
'accel': '<Control>r'
}]
}, {
'name':
_L('Edit'),
'submenu': [
{
'name': _L('Find'),
'action': self._find_cb,
'accel': '<Control>f'
},
{
'name': _L('Find next'),
'action': self._find_next_cb,
'accel': '<Control>n'
},
{
'name': _L('Find previous'),
'action': self._find_prev_cb,
'accel': '<Control>p'
},
]
}]
self._accel_group = gtk.AccelGroup()
self.add_accel_group(self._accel_group)
self._menu = gui.build_menu(menu, accelgroup=self._accel_group)
# Run menu
self._name = gtk.Entry()
self._run_button = gtk.Button(_L('Run'))
self._run_button.connect('clicked', self._run_clicked_cb)
self._options = gui.pack_hbox(
[gtk.Label(_L('Name')), self._name, self._run_button])
# Directory and edit panes
self._file_info = {}
self._notebook = gtk.Notebook()
self._dir_pane = DirPane()
self._dir_pane.dir_browser.connect('file-activated',
self._file_activated_cb)
self._panes = gtk.HPaned()
self._panes.add1(self._dir_pane)
self._panes.add2(self._notebook)
# Put everything together
self._vbox = gtk.VBox()
self._vbox.pack_start(self._menu, False, False)
self._vbox.pack_start(self._options, False, False)
self._vbox.pack_start(self._panes, True, True)
self.add(self._vbox)
self._vbox.show_all()
def __create_widget(self):
'''create gtk widget'''
title_item_font_size = TITLE_FONT_SIZE
option_item_font_size = CONTENT_FONT_SIZE
# image init
self.image_widgets["custom"] = ImageBox(app_theme.get_pixbuf("%s/mouse_l.png" % MODULE_NAME))
self.image_widgets["speed"] = ImageBox(app_theme.get_pixbuf("%s/pointer.png" % MODULE_NAME))
self.image_widgets["double"] = ImageBox(app_theme.get_pixbuf("%s/double-click.png" % MODULE_NAME))
self.image_widgets["double_test_1"] = app_theme.get_pixbuf("%s/smiley00.png" % MODULE_NAME)
self.image_widgets["double_test_2"] = app_theme.get_pixbuf("%s/smiley01.png" % MODULE_NAME)
# label init
self.label_widgets["custom"] = Label(_("Custom"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False)
self.label_widgets["pointer_speed"] = Label(_("Pointer Speed"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False)
self.label_widgets["acceleration"] = Label(_("Acceleration"), text_size=option_item_font_size,
text_x_align=ALIGN_END, enable_select=False,
enable_double_click=False, fixed_width=STANDARD_LINE)
self.label_widgets["accel_fast"] = Label(_("Fast"), enable_select=False, enable_double_click=False)
self.label_widgets["accel_slow"] = Label(_("Slow"), enable_select=False, enable_double_click=False)
self.label_widgets["sensitivity"] = Label(_("Sensitivity"), text_size=option_item_font_size,
text_x_align=ALIGN_END, enable_select=False,
enable_double_click=False, fixed_width=STANDARD_LINE)
self.label_widgets["sensitiv_low"] = Label(_("Low"), enable_select=False, enable_double_click=False)
self.label_widgets["sensitiv_high"] = Label(_("High"), enable_select=False, enable_double_click=False)
self.label_widgets["double_click"] = Label(_("Double-click"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False)
self.label_widgets["click_rate"] = Label(_("Frequency"), text_size=option_item_font_size,
text_x_align=ALIGN_END, enable_select=False,
enable_double_click=False, fixed_width=STANDARD_LINE)
self.label_widgets["click_fast"] = Label(_("Fast"), enable_select=False, enable_double_click=False)
self.label_widgets["click_slow"] = Label(_("Slow"), enable_select=False, enable_double_click=False)
self.label_widgets["double_test"] = Label(_("Double-click on the smiley face to test your settings."),
label_width=HSCALEBAR_WIDTH, wrap_width=HSCALEBAR_WIDTH, enable_select=False, enable_double_click=False)
self.label_widgets["relevant"] = Label(_("Relevant Settings"), text_size=title_item_font_size,
enable_select=False, enable_double_click=False, fixed_width=180)
# button init
self.button_widgets["right_hand_radio"] = RadioButton( _("Right-handed"), padding_x=10)
self.button_widgets["left_hand_radio"] = RadioButton(_("Left-handed"), padding_x=10)
self.button_widgets["double_test"] = gtk.EventBox()
# relevant settings button
self.button_widgets["keyboard_setting"] = Label("<u>%s</u>" % _("Keyboard Settings"),
DynamicColor(GOTO_FG_COLOR), text_size=option_item_font_size,
enable_select=False, enable_double_click=False, fixed_width=180)
self.button_widgets["touchpad_setting"] = Label("<u>%s</u>" % _("TouchPad Settings"),
DynamicColor(GOTO_FG_COLOR), text_size=option_item_font_size,
enable_select=False, enable_double_click=False, fixed_width=180)
self.button_widgets["set_to_default"] = Button(_("Reset"))
# container init
self.container_widgets["main_vbox"] = gtk.VBox(False)
self.container_widgets["statusbar"] = StatusBar()
self.container_widgets["main_hbox"] = gtk.HBox(False)
self.container_widgets["left_vbox"] = gtk.VBox(False)
self.container_widgets["right_vbox"] = gtk.VBox(False)
self.container_widgets["custom_main_vbox"] = gtk.VBox(False) # custom
self.container_widgets["custom_label_hbox"] = gtk.HBox(False)
self.container_widgets["custom_button_hbox"] = gtk.HBox(False)
self.container_widgets["pointer_speed_main_vbox"] = gtk.VBox(False) # pointer speed
self.container_widgets["pointer_speed_label_hbox"] = gtk.HBox(False)
self.container_widgets["pointer_speed_table"] = gtk.Table(2, 4, False)
self.container_widgets["pointer_speed_accel_hbox"] = gtk.HBox(False)
self.container_widgets["pointer_speed_sensitiv_hbox"] = gtk.HBox(False)
self.container_widgets["double_click_main_vbox"] = gtk.VBox(False) # double click
self.container_widgets["double_click_label_hbox"] = gtk.HBox(False)
self.container_widgets["double_click_table"] = gtk.Table(2, 4, False)
self.container_widgets["double_click_rate_hbox"] = gtk.HBox(False)
# alignment init
self.alignment_widgets["main_hbox"] = gtk.Alignment()
self.alignment_widgets["left"] = gtk.Alignment()
self.alignment_widgets["right"] = gtk.Alignment()
self.alignment_widgets["custom_label"] = gtk.Alignment() # custom
self.alignment_widgets["custom_button"] = gtk.Alignment()
self.alignment_widgets["pointer_speed_label"] = gtk.Alignment() # pointer speed
self.alignment_widgets["pointer_speed_table"] = gtk.Alignment()
self.alignment_widgets["double_click_label"] = gtk.Alignment() # double click
self.alignment_widgets["double_click_table"] = gtk.Alignment()
self.alignment_widgets["keyboard_setting"] = gtk.Alignment()
self.alignment_widgets["touchpad_setting"] = gtk.Alignment()
# adjust init
self.adjust_widgets["pointer_speed_accel"] = gtk.Adjustment(1.0, 1.0, 10.0, 1, 2)
self.adjust_widgets["pointer_speed_sensitiv"] = gtk.Adjustment(1, 1, 10, 1, 2)
self.adjust_widgets["double_click_rate"] = gtk.Adjustment(100, 100, 1000, 100, 200)
# scale init
self.scale_widgets["pointer_speed_accel"] = HScalebar(value_min=1, value_max=10)
#self.scale_widgets["pointer_speed_accel"] = HScalebar(
#None, None, None, None, None, None,
#app_theme.get_pixbuf("scalebar/point.png"))
#self.scale_widgets["pointer_speed_accel"].set_adjustment( self.adjust_widgets["pointer_speed_accel"])
self.scale_widgets["pointer_speed_sensitiv"] = HScalebar(value_min=1, value_max=10)
#self.scale_widgets["pointer_speed_sensitiv"] = HScalebar(
#None, None, None, None, None, None,
#app_theme.get_pixbuf("scalebar/point.png"))
#self.scale_widgets["pointer_speed_sensitiv"].set_adjustment( self.adjust_widgets["pointer_speed_sensitiv"])
self.scale_widgets["double_click_rate"] = HScalebar(value_min=100, value_max=1000)
def __init__(self, wallet, config):
self.config = config
self.wallet = wallet
self.funds_error = False # True if not enough funds
self.window = MyWindow(gtk.WINDOW_TOPLEVEL)
title = 'Electrum ' + self.wallet.electrum_version + ' - ' + self.config.path
if not self.wallet.seed: title += ' [seedless]'
self.window.set_title(title)
self.window.connect("destroy", gtk.main_quit)
self.window.set_border_width(0)
self.window.connect('mykeypress', gtk.main_quit)
self.window.set_default_size(720, 350)
self.wallet_updated = False
vbox = gtk.VBox()
self.notebook = gtk.Notebook()
self.create_history_tab()
if self.wallet.seed:
self.create_send_tab()
self.create_recv_tab()
self.create_book_tab()
self.create_about_tab()
self.notebook.show()
vbox.pack_start(self.notebook, True, True, 2)
self.status_bar = gtk.Statusbar()
vbox.pack_start(self.status_bar, False, False, 0)
self.status_image = gtk.Image()
self.status_image.set_from_stock(gtk.STOCK_NO, gtk.ICON_SIZE_MENU)
self.status_image.set_alignment(True, 0.5)
self.status_image.show()
self.network_button = gtk.Button()
self.network_button.connect(
"clicked", lambda x: run_network_dialog(self.wallet, self.window))
self.network_button.add(self.status_image)
self.network_button.set_relief(gtk.RELIEF_NONE)
self.network_button.show()
self.status_bar.pack_end(self.network_button, False, False)
if self.wallet.seed:
def seedb(w, wallet):
if wallet.use_encryption:
password = password_dialog(self.window)
if not password: return
else: password = None
show_seed_dialog(wallet, password, self.window)
button = gtk.Button('S')
button.connect("clicked", seedb, wallet)
button.set_relief(gtk.RELIEF_NONE)
button.show()
self.status_bar.pack_end(button, False, False)
settings_icon = gtk.Image()
settings_icon.set_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_MENU)
settings_icon.set_alignment(0.5, 0.5)
settings_icon.set_size_request(16, 16)
settings_icon.show()
prefs_button = gtk.Button()
prefs_button.connect(
"clicked", lambda x: run_settings_dialog(self.wallet, self.window))
prefs_button.add(settings_icon)
prefs_button.set_tooltip_text("Settings")
prefs_button.set_relief(gtk.RELIEF_NONE)
prefs_button.show()
self.status_bar.pack_end(prefs_button, False, False)
pw_icon = gtk.Image()
pw_icon.set_from_stock(gtk.STOCK_DIALOG_AUTHENTICATION,
gtk.ICON_SIZE_MENU)
pw_icon.set_alignment(0.5, 0.5)
pw_icon.set_size_request(16, 16)
pw_icon.show()
if self.wallet.seed:
password_button = gtk.Button()
password_button.connect(
"clicked", lambda x: change_password_dialog(
self.wallet, self.window, pw_icon))
password_button.add(pw_icon)
password_button.set_relief(gtk.RELIEF_NONE)
password_button.show()
self.status_bar.pack_end(password_button, False, False)
self.window.add(vbox)
self.window.show_all()
#self.fee_box.hide()
self.context_id = self.status_bar.get_context_id("statusbar")
self.update_status_bar()
self.wallet.interface.register_callback('updated',
self.update_callback)
def update_status_bar_thread():
while True:
gobject.idle_add(self.update_status_bar)
time.sleep(0.5)
def check_recipient_thread():
old_r = ''
while True:
time.sleep(0.5)
if self.payto_entry.is_focus():
continue
r = self.payto_entry.get_text()
if r != old_r:
old_r = r
r = r.strip()
if re.match('^(|([\w\-\.]+)@)((\w[\w\-]+\.)+[\w\-]+)$', r):
try:
to_address = self.wallet.get_alias(
r, interactive=False)
except:
continue
if to_address:
s = r + ' <' + to_address + '>'
gobject.idle_add(
lambda: self.payto_entry.set_text(s))
thread.start_new_thread(update_status_bar_thread, ())
if self.wallet.seed:
thread.start_new_thread(check_recipient_thread, ())
self.notebook.set_current_page(0)
def __init__(self, opts):
gtk.Window.__init__(self)
self.connect("delete-event", self._cleanup)
self.set_title("{0} {1}".format(name, version))
self.cfg = opts
self.serverwrangler = ServerWrangler(self.cfg, self._do_log)
self.serverwrangler.connect("upnp-error", self._do_upnp_error)
self.current_server = None
self.bound_actions = gtk.ActionGroup("bound_actions")
vbox = gtk.VBox()
self.add(vbox)
# Actions
add_server_action = gtk.Action("add_server", "Create Server",
"Create a new DHT Server.",
gtk.STOCK_NEW)
add_server_action.connect("activate", self.add_server)
add_multiple_servers_action = gtk.Action(
"add_multiple_servers", "Create Multiple Servers",
"Create Multiple DHT Servers.", gtk.STOCK_NEW)
add_multiple_servers_action.connect("activate",
self.add_multiple_servers)
quit_action = gtk.Action("quit", "Quit", "Quit", gtk.STOCK_QUIT)
quit_action.connect("activate", self.quit)
ping_action = gtk.Action("ping", "Ping Node...", "Ping a DHT Node",
gtk.STOCK_REFRESH)
ping_action.connect("activate", self.ping_node)
self.bound_actions.add_action(ping_action)
find_action = gtk.Action("find", "Find Node...", "Find a DHT Node",
gtk.STOCK_FIND)
find_action.connect("activate", self.find_node)
self.bound_actions.add_action(find_action)
get_peers_action = gtk.Action("get_peers", "Get Peers...",
"Get DHT Peers", gtk.STOCK_FIND)
get_peers_action.connect("activate", self.get_peers)
self.bound_actions.add_action(get_peers_action)
load_action = gtk.Action("load", "Load From Torrent...",
"Load DHT Nodes from a torrent file",
gtk.STOCK_OPEN)
load_action.connect("activate", self.load_torrent)
self.bound_actions.add_action(load_action)
# Menus
menubar = gtk.MenuBar()
vbox.pack_start(menubar, False, False)
file_menuitem = gtk.MenuItem("File")
menubar.add(file_menuitem)
file_menu = gtk.Menu()
file_menuitem.set_submenu(file_menu)
file_menu.add(add_server_action.create_menu_item())
file_menu.add(add_multiple_servers_action.create_menu_item())
file_menu.add(gtk.SeparatorMenuItem())
file_menu.add(quit_action.create_menu_item())
tools_menuitem = gtk.MenuItem("Tools")
menubar.add(tools_menuitem)
tools_menu = gtk.Menu()
tools_menuitem.set_submenu(tools_menu)
tools_menu.add(ping_action.create_menu_item())
tools_menu.add(find_action.create_menu_item())
tools_menu.add(get_peers_action.create_menu_item())
tools_menu.add(load_action.create_menu_item())
# Main Toolbar
toolbar = gtk.Toolbar()
vbox.pack_start(toolbar, False, False)
toolbar.add(add_server_action.create_tool_item())
toolbar.add(add_multiple_servers_action.create_tool_item())
# Work area
serverpane = gtk.HPaned()
vbox.pack_start(serverpane, True, True)
self.serverview = dbview.ServerView(self.serverwrangler)
self.serverview.connect("cursor-changed",
self._do_serverview_cursor_changed)
serverpane.pack1(self.serverview, True, True)
server_frame = gtk.Frame()
server_frame.set_shadow_type(gtk.SHADOW_IN)
serverpane.pack2(server_frame, True, True)
server_area = gtk.VBox()
server_frame.add(server_area)
# Server Area
server_toolbar = gtk.Toolbar()
server_area.pack_start(server_toolbar, False, False)
server_toolbar.add(ping_action.create_tool_item())
server_toolbar.add(find_action.create_tool_item())
server_toolbar.add(get_peers_action.create_tool_item())
server_toolbar.add(load_action.create_tool_item())
self.notebook = gtk.Notebook()
server_area.pack_start(self.notebook)
self.bucketview = dbview.BucketView()
self.nodeview = dbview.NodeView(self.bucketview)
self.nodeview.connect("right-click", self._do_nodeview_right_click)
self.peerview = dbview.PeerView()
self.torrentview = dbview.TorrentView()
self.torrentview.connect("right-click",
self._do_torrentview_right_click)
self.bucketnodeview = dbview.BucketNodeView(self.bucketview,
self.nodeview)
self.bucketnodeview.connect("right-click",
self._do_nodeview_right_click)
self.torrentpeerview = dbview.TorrentPeerView(self.torrentview,
self.peerview)
self.peertorrentview = dbview.PeerTorrentView(self.peerview,
self.torrentview)
self.peertorrentview.connect("right-click",
self._do_torrentview_right_click)
self.notebook.append_page(self.nodeview, gtk.Label("Nodes"))
bucketspane = gtk.VPaned()
self.notebook.append_page(bucketspane, gtk.Label("Buckets"))
bucketspane.pack1(self.bucketview, True, True)
bucketspane.pack2(self.bucketnodeview, True, True)
torrentspane = gtk.VPaned()
self.notebook.append_page(torrentspane, gtk.Label("Torrents"))
torrentspane.pack1(self.torrentview, True, True)
torrentspane.pack2(self.torrentpeerview, True, True)
peerspane = gtk.VPaned()
self.notebook.append_page(peerspane, gtk.Label("Peers"))
peerspane.pack1(self.peerview, True, True)
peerspane.pack2(self.peertorrentview, True, True)
logwin = gtk.ScrolledWindow()
logwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.notebook.append_page(logwin, gtk.Label("Log"))
self.logbuffer = gtk.TextBuffer()
self.logview = gtk.TextView(self.logbuffer)
self.logview.set_wrap_mode(gtk.WRAP_NONE)
self.logview.set_editable(True)
self.logview.set_cursor_visible(False)
logwin.add(self.logview)
# Status Bar
self.statusbar = gtk.Statusbar()
vbox.pack_end(self.statusbar, False, False)
# self.serverstatus = StatusLabel("Server:", False)
# self.statusbar.pack_start(self.serverstatus, False, False)
# self.statusbar.pack_start(gtk.VSeparator(), False, False)
self.netstatus = StatusLabel("Network:")
self.netstatus.attach_to_prop(self.serverwrangler, "incoming")
self.statusbar.pack_start(self.netstatus, False, False)
self.bound_actions.set_sensitive(False)
self.show_all()
self.hide()
self.serverwrangler.launch_dispatch()
self._do_log("Application Initiated.")
def __init__(self):
#gtk entry
self.entry1 = gtk.Entry()
self.entry2 = gtk.Entry()
self.entry3 = gtk.Entry()
self.entry4 = gtk.Entry()
self.entry5 = gtk.Entry()
#gtk label
self.out1 = gtk.Label()
self.out2 = gtk.Label()
self.out3 = gtk.Label()
self.out4 = gtk.Label()
self.out5 = gtk.Label()
self.out6 = gtk.Label()
self.out7 = gtk.Label()
self.out8 = gtk.Label()
self.out9 = gtk.Label()
self.out10 = gtk.Label()
self.out11 = gtk.Label()
self.out12 = gtk.Label()
labelA = gtk.Label('')
labelA.set_markup( _('<b>PENDAPATAN</b>'))
labelB = gtk.Label('')
labelB.set_markup( _('<b>ZAKAT PENGHASILAN</b>'))
labelC = gtk.Label('')
labelC.set_markup( _('<b>ZAKAT SIMPANAN</b>'))
label1 = gtk.Label( _("Pendapatan atau gaji (per bulan)"))
label2 = gtk.Label( _("Pendapatan lain (per bulan)"))
label3 = gtk.Label( _("Pendapatan total (per tahun)"))
label4 = gtk.Label( _("Kebutuhan (per bulan)"))
label5 = gtk.Label( _("Kebutuhan total (per tahun)"))
label6 = gtk.Label( _("Sisa pendapatan"))
label7 = gtk.Label( _("Harga beras saat ini (per kg)"))
label8 = gtk.Label( _("Besarnya nishab"))
label9 = gtk.Label( _("Wajib zakat penghasilan?"))
label10 = gtk.Label( _("Besarnya zakat penghasilan yang harus dibayarkan"))
label11 = gtk.Label( _("Zakat per tahun"))
label12 = gtk.Label( _("Zakat per bulan"))
label13 = gtk.Label( _("Harga emas saat ini (per gram)"))
label14 = gtk.Label( _("Besarnya nishab"))
label15 = gtk.Label( _("Wajib zakat simpanan?"))
label16 = gtk.Label( _("Besarnya zakat simpanan yang harus dibayarkan"))
label17 = gtk.Label( _("Zakat per tahun"))
label18 = gtk.Label( _("Zakat per bulan"))
#gtk button
button1 = gtk.Button( _("_Ihwal"), stock='gtk-about')
button2 = gtk.Button( _("_Hitung Zakat"))
button3 = gtk.Button( _("_Bersihkan"), stock='gtk-clear')
button4 = gtk.Button( _("_Tutup"), stock='gtk-close')
#vbox
vbox1 = gtk.VBox(False, 5)
vbox2 = gtk.VBox(False, 5)
#buttonbox
buttonbox = gtk.HButtonBox()
buttonbox.set_spacing(15)
buttonbox.set_layout(gtk.BUTTONBOX_CENTER)
buttonbox.add(button1)
buttonbox.add(button2)
buttonbox.add(button3)
buttonbox.add(button4)
#image
pixbuf = gtk.gdk.pixbuf_new_from_file("/usr/share/zacalc/image/logo.png")
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
image.show()
#table
table1 = gtk.Table(1,6,True)
table2 = gtk.Table(1,6,True)
#frame
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
#align
align1 = gtk.Alignment(0.5, 0.3, 0, 0)
align2 = gtk.Alignment(0.5, 0.1, 0, 0)
align3 = gtk.Alignment(0.5, 0.5, 0, 0)
#layout inserting
vbox1.add(frame)
vbox1.add(buttonbox)
frame.add(align1)
align1.add(table1)
align3.add(vbox2)
align2.add(table2)
table1.attach(image,3,6,0,10)
table1.attach(labelA,0,3,0,1)
table1.attach(label1,0,2,1,2)
table1.attach(label2,0,2,2,3)
table1.attach(label3,0,2,3,4)
table1.attach(label4,0,2,4,5)
table1.attach(label5,0,2,5,6)
table1.attach(label6,0,2,6,7)
table1.attach(self.entry1,2,3,1,2)
table1.attach(self.entry2,2,3,2,3)
table1.attach(self.out1,2,3,3,4)
table1.attach(self.entry3,2,3,4,5)
table1.attach(self.out2,2,3,5,6)
table1.attach(self.out3,2,3,6,7)
table1.attach(labelB,0,3,8,9)
table1.attach(label7,0,2,9,10)
table1.attach(label8,0,2,10,11)
table1.attach(label9,0,2,11,12)
table1.attach(label10,0,3,12,13)
table1.attach(self.entry4,2,3,9,10)
table1.attach(self.out4,2,3,10,11)
table1.attach(self.out5,2,3,11,12)
table1.attach(label11,0,2,13,14)
table1.attach(label12,0,2,14,15)
table1.attach(self.out6,2,3,13,14)
table1.attach(self.out7,2,3,14,15)
table1.attach(labelC,3,5,8,9)
table1.attach(label13,3,5,9,10)
table1.attach(label14,3,5,10,11)
table1.attach(label15,3,5,11,12)
table1.attach(label16,3,6,12,13)
table1.attach(self.entry5,5,6,9,10)
table1.attach(self.out8,5,6,10,11)
table1.attach(self.out9,5,6,11,12)
table1.attach(label17,3,5,13,14)
table1.attach(label18,3,5,14,15)
table1.attach(self.out10,5,6,13,14)
table1.attach(self.out11,5,6,14,15)
#property
frame.set_label('')
self.clear_value(self)
self.out1.set_alignment(xalign=0.95, yalign=0.5)
self.out2.set_alignment(xalign=0.95, yalign=0.5)
self.out3.set_alignment(xalign=0.95, yalign=0.5)
self.out4.set_alignment(xalign=0.95, yalign=0.5)
self.out5.set_alignment(xalign=0.05, yalign=0.5)
self.out6.set_alignment(xalign=0.95, yalign=0.5)
self.out7.set_alignment(xalign=0.95, yalign=0.5)
self.out8.set_alignment(xalign=0.95, yalign=0.5)
self.out9.set_alignment(xalign=0.05, yalign=0.5)
self.out10.set_alignment(xalign=0.95, yalign=0.5)
self.out11.set_alignment(xalign=0.95, yalign=0.5)
labelA.set_alignment(xalign=0, yalign=0.5)
labelB.set_alignment(xalign=0, yalign=0.5)
labelC.set_alignment(xalign=0, yalign=0.5)
label1.set_alignment(xalign=0, yalign=0.5)
label2.set_alignment(xalign=0, yalign=0.5)
label3.set_alignment(xalign=0, yalign=0.5)
label4.set_alignment(xalign=0, yalign=0.5)
label5.set_alignment(xalign=0, yalign=0.5)
label6.set_alignment(xalign=0, yalign=0.5)
label7.set_alignment(xalign=0, yalign=0.5)
label8.set_alignment(xalign=0, yalign=0.5)
label9.set_alignment(xalign=0, yalign=0.5)
label10.set_alignment(xalign=0, yalign=0.5)
label11.set_alignment(xalign=0, yalign=0.5)
label12.set_alignment(xalign=0, yalign=0.5)
label13.set_alignment(xalign=0, yalign=0.5)
label14.set_alignment(xalign=0, yalign=0.5)
label15.set_alignment(xalign=0, yalign=0.5)
label16.set_alignment(xalign=0, yalign=0.5)
label17.set_alignment(xalign=-0, yalign=0.5)
label18.set_alignment(xalign=-0, yalign=0.5)
image.set_alignment(xalign=0, yalign=0.5)
table1.set_col_spacings(30)
align1.set_padding(5, 5, 15, 15)
table2.set_col_spacings(0)
align2.set_padding(0, 0, 0, 0)
#signal
self.entry1.connect("changed", self.valid_number)
self.entry2.connect("changed", self.valid_number)
self.entry3.connect("changed", self.valid_number)
self.entry4.connect("changed", self.valid_number)
self.entry5.connect("changed", self.valid_number)
button1.connect("clicked", self.show_about)
button2.connect("clicked", self.calculate)
button3.connect("clicked", self.clear_value)
button4.connect("clicked", gtk.main_quit)
icon_theme = gtk.icon_theme_get_default()
try:
self.icon = icon_theme.load_icon("zacalc", 48, 0)
except Exception, e:
print "can't load icon", e
def __init__(self):
file_name_entry = gtk.Entry(max=256)
# create a new window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
#window.set_size_request(800, 600)
window.set_title("Story Board")
window.connect("delete_event", lambda w,e: gtk.main_quit())
vbox = gtk.VBox(False, 0)
window.add(vbox)
vbox.show()
# Menu
file_menu = gtk.Menu();
open_menu_item = gtk.MenuItem("Open")
file_menu.append(open_menu_item)
open_menu_item.connect("activate", self.file_dialog, file_name_entry)
open_menu_item.show()
quit_menu_item = gtk.MenuItem("Quit")
file_menu.append(quit_menu_item)
quit_menu_item.connect("activate", lambda w,e: gtk.main_quit(), "Quit")
quit_menu_item.show()
file_root_menu = gtk.MenuItem("File")
file_root_menu.show()
file_root_menu.set_submenu(file_menu)
menubar = gtk.MenuBar()
vbox.pack_start(menubar, False, False, 0)
menubar.show()
menubar.append(file_root_menu)
# Port name
hbox = gtk.HBox(False, 0)
vbox.pack_start(hbox)
hbox.show()
port_label = gtk.Label("Port name:")
hbox.pack_start(port_label, False, False, 5)
port_label.show()
port_name_entry = gtk.Entry()
port_name_entry.set_max_length(50)
port_name_entry.connect("activate", self.enter_callback, port_name_entry)
#port_name = port_name_entry.get_text()
hbox.pack_start(port_name_entry, False, False, 0)
port_name_entry.show()
hbox_filename = gtk.HBox(False, 0)
vbox.pack_start(hbox_filename)
hbox_filename.show()
file_name_label = gtk.Label("File name:")
hbox_filename.pack_start(file_name_label, False, False, 0)
file_name_label.show()
hbox_filename.pack_start(file_name_entry, True, True, 0)
file_name_entry.show()
hbox2 = gtk.HBox(False, 0)
vbox.add(hbox2)
hbox2.show()
# Function
function_label = gtk.Label("Function:")
hbox2.pack_start(function_label, False, False, 5)
function_label.show()
function_button = gtk.RadioButton(None, "Add")
hbox2.pack_start(function_button, False, False, 0)
function_button.show()
function_button = gtk.RadioButton(function_button, "Delete")
hbox2.pack_start(function_button, False, False, 0)
function_button.show()
hbox3 = gtk.HBox(False, 0)
vbox.add(hbox3)
hbox3.show()
# Buttons
ok_button = gtk.Button(stock=gtk.STOCK_OK)
ok_button.connect("clicked", self.ok_button_callback, file_name_entry, port_name_entry)
hbox3.pack_start(ok_button, False, False, 0)
ok_button.show()
close_button = gtk.Button(stock=gtk.STOCK_CLOSE)
close_button.connect("clicked", lambda w: gtk.main_quit())
hbox3.pack_start(close_button, False, False, 0)
close_button.set_flags(gtk.CAN_DEFAULT)
close_button.grab_default()
close_button.show()
window.show()
def __init__(self, col=1, homogeneous=False):
self.col = 1
self.table = gtk.VBox()
self.table.set_homogeneous(homogeneous)
def __init__(self):
global stuff_box
# create a new window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
# Sets the border width of the window.
self.window.set_border_width(15)
main_box = gtk.VBox()
self.options_box = gtk.HBox()
control_box = gtk.VBox()
stuff_box = gtk.HBox()
self.window.set_title("Remote Controller")
#option field:
self.options_box.lights = gtk.CheckButton("Lights")
self.options_box.logging = gtk.CheckButton("Logging")
self.options_box.debug = gtk.CheckButton("Debug")
self.options_box.remote_ip = gtk.HBox()
self.options_box.remote_ip.entry = gtk.Entry(15)
self.options_box.remote_ip.entry.set_text("192.168.2.11")
self.options_box.remote_ip.connect_button = gtk.Button(" Connect ")
self.options_box.remote_ip.pack_start(self.options_box.remote_ip.entry,
False, False, 13)
self.options_box.remote_ip.pack_start(
self.options_box.remote_ip.connect_button, False, False, 3)
#connect option buttons
self.options_box.lights.connect("toggled", self.options_handler,
"lights")
self.options_box.logging.connect("toggled", self.options_handler,
"logging")
self.options_box.debug.connect("toggled", self.options_handler,
"debug")
self.options_box.remote_ip.connect_button.connect(
"clicked", self.options_handler, "connect_button")
#Control Frame:
control_frame = gtk.Frame()
control_frame.set_label("Controlling")
control_frame.add(control_box)
control_box.sides = gtk.HBox()
control_box.up_box = gtk.HBox()
control_box.down_box = gtk.HBox()
control_box.up = create_arrow_button(gtk.ARROW_UP, gtk.SHADOW_IN,
"Forwards")
control_box.left = create_arrow_button(gtk.ARROW_LEFT, gtk.SHADOW_IN,
"Left")
control_box.right = create_arrow_button(gtk.ARROW_RIGHT, gtk.SHADOW_IN,
"Right")
control_box.down = create_arrow_button(gtk.ARROW_DOWN, gtk.SHADOW_IN,
"Backwards")
control_box.sides.pack_start(control_box.left, True, False, 20)
control_box.sides.pack_start(control_box.right, True, False, 20)
control_box.up_box.pack_start(control_box.up, True, False, 13)
control_box.down_box.pack_start(control_box.down, True, False, 13)
#connect controlling buttons
control_box.up.connect("released", self.released_handler, "forward")
control_box.down.connect("released", self.released_handler, "backward")
control_box.left.connect("released", self.released_handler, "left")
control_box.right.connect("released", self.released_handler, "right")
control_box.up.connect("pressed", self.pressed_handler, "forward")
control_box.down.connect("pressed", self.pressed_handler, "backward")
control_box.left.connect("pressed", self.pressed_handler, "left")
control_box.right.connect("pressed", self.pressed_handler, "right")
self.window.connect("key-press-event", self.click_event)
self.window.connect("key-release-event", self.click_event)
#Singals and Infos about the car
stuff_box.battery = gtk.ProgressBar()
stuff_box.battery.set_text("Battery")
stuff_box.sig_strength = gtk.ProgressBar()
stuff_box.sig_strength.set_text("Signal strength")
stuff_box.speed = gtk.Label("N/A Km/h")
stuff_box.temp = gtk.Label("N/A Degrees C.")
#add the widgets to the boxes
self.options_box.pack_start(self.options_box.lights, False, False, 3)
self.options_box.pack_start(self.options_box.logging, False, False, 3)
self.options_box.pack_start(self.options_box.debug, False, False, 3)
self.options_box.pack_start(self.options_box.remote_ip, False, False,
3)
control_box.pack_start(control_box.up_box, True, False, 3)
control_box.pack_start(control_box.sides, True, False, 3)
control_box.pack_start(control_box.down_box, True, False, 3)
stuff_box.pack_start(stuff_box.battery, False, False, 3)
stuff_box.pack_start(stuff_box.sig_strength, False, False, 3)
stuff_box.pack_start(stuff_box.speed, False, False, 3)
stuff_box.pack_start(stuff_box.temp, False, False, 3)
#add the boxes to the main_box
main_box.pack_start(self.options_box, True, False, 13)
main_box.pack_start(control_frame, True, True, 13)
main_box.pack_start(stuff_box, True, False, 13)
#add the main_box to the window
self.window.add(main_box)
# The final step is to display all widgets.
self.window.show_all()
#do some initializations
self.car = communication()
init_stats()
# add items to the menu bar by creating item objects
m1 = gtk.MenuItem("File")
n1 = gtk.Menu()
m1.set_submenu(n1)
add = gtk.MenuItem("Add")
add.connect('activate', display)
n1.append(add)
dele = gtk.MenuItem("Del")
dele.connect('activate', output)
n1.append(dele)
exit = gtk.MenuItem("Exit")
exit.connect('activate', gtk.main_quit)
n1.append(exit)
m2 = gtk.MenuItem("Edit")
m3 = gtk.MenuItem("Print")
# append the menu items to the menu bar
m.append(m1)
m.append(m2)
m.append(m3)
# layout management
vbox = gtk.VBox(False, 2)
vbox.pack_start(m, False, False, 0)
x.add(vbox)
x.connect("destroy", gtk.main_quit)
x.show_all()
gtk.main()
def init(self):
# The user_id to work on
self.current_user_id = 0
self.user_list = []
# ---------------
# Log Management
# ---------------
# create tree model
self.log_model = gtk.ListStore(
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_INT,
gobject.TYPE_INT,
gobject.TYPE_INT,
gobject.TYPE_STRING)
# Main box is vertical
top_box = gtk.VBox(False, 8)
top_box.show()
self.frame.add(top_box)
# First line label and combo
label_box = gtk.HBox(False, 8)
label_box.show()
top_box.pack_start(label_box, False, False, 0)
# Let the user select the class to work on
#
# Grab the class list and put it in a combo
class_box = gtk.HBox(False, 8)
class_box.show()
label_box.pack_start(class_box, False, False, 0)
user_label = gtk.Label(_('Select a user:'******'SELECT DISTINCT user_id FROM logs')
user_list = self.cur.fetchall()
self.combo_user = gtk.combo_box_new_text()
self.combo_user.show()
# Insert the ALL option (HACK, use the user_id -2 to indicate ALL)
self.combo_user.append_text(_("All users"))
self.user_list.append(-2)
for auser in user_list:
if(auser[0] == -1):
self.combo_user.append_text(_("Default"))
self.user_list.append(-1)
continue
self.cur.execute('SELECT login, firstname, lastname FROM users WHERE user_id=?',
(auser[0],) )
oneuser = self.cur.fetchall()
self.combo_user.append_text( (oneuser[0][0] + ' ' +
oneuser[0][1] + ' ' +
oneuser[0][2]))
# Save in a list the combo index => the user_id
self.user_list.append(auser[0])
self.combo_user.set_active(self.current_user_id)
label_box.pack_end(self.combo_user, True, True, 0)
# update the combobox
self.combo_user.connect('changed', self.user_changed_cb)
# Second line logs and button
log_hbox = gtk.HBox(False, 8)
log_hbox.show()
top_box.add(log_hbox)
loglist_box = gtk.VBox(False, 8)
loglist_box.show()
log_hbox.add(loglist_box)
vbox_button = gtk.VBox(False, 8)
vbox_button.show()
log_hbox.add(vbox_button)
# Create the table
sw = gtk.ScrolledWindow()
sw.show()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
# create tree view
treeview_log = gtk.TreeView(self.log_model)
treeview_log.show()
treeview_log.set_rules_hint(True)
treeview_log.set_search_column(COLUMN_DATE)
sw.add(treeview_log)
loglist_box.pack_start(sw, True, True, 0)
# add columns to the tree view
self.__add_columns_log(treeview_log)
# Reset buttons
self.button_remove = gtk.Button(_('Reset'))
self.button_remove.connect("clicked", self.on_remove_log_clicked, treeview_log)
vbox_button.pack_start(self.button_remove, False, False, 0)
self.button_remove.show()
self.button_remove.set_sensitive(True)
# Refresh buttons
self.button_refresh = gtk.Button(stock='gtk-refresh')
self.button_refresh.connect("clicked", self.on_refresh_log_clicked)
vbox_button.pack_start(self.button_refresh, False, False, 0)
self.button_refresh.show()
self.button_refresh.set_sensitive(True)
# Load lists
self.user_changed_cb(self.combo_user)
self.reload_log()
def _get_wipe_selector(editable_property):
"""
Returns GUI component for selecting wipe type.
"""
# Preset luma
combo_box = gtk.combo_box_new_text()
# Get options
keys = mlttransitions.wipe_lumas.keys()
# translate here
keys.sort()
for k in keys:
combo_box.append_text(k)
# Set initial value
k_index = -1
tokens = editable_property.value.split("/")
test_value = tokens[len(tokens) - 1]
for k, v in mlttransitions.wipe_lumas.iteritems():
if v == test_value:
k_index = keys.index(k)
combo_box.set_active(k_index)
preset_luma_row = _get_two_column_editor_row(
editable_property.get_display_name(), combo_box)
# User luma
use_preset_luma_combo = gtk.combo_box_new_text()
use_preset_luma_combo.append_text(_("Preset Luma"))
use_preset_luma_combo.append_text(_("User Luma"))
dialog = gtk.FileChooserDialog(
_("Select Luma File"), None, gtk.FILE_CHOOSER_ACTION_OPEN,
(_("Cancel").encode('utf-8'), gtk.RESPONSE_REJECT,
_("OK").encode('utf-8'), gtk.RESPONSE_ACCEPT), None)
dialog.set_action(gtk.FILE_CHOOSER_ACTION_OPEN)
dialog.set_select_multiple(False)
file_filter = gtk.FileFilter()
file_filter.add_pattern("*.png")
file_filter.add_pattern("*.pgm")
file_filter.set_name(_("Wipe Luma files"))
dialog.add_filter(file_filter)
user_luma_select = gtk.FileChooserButton(dialog)
user_luma_select.set_size_request(210, 28)
user_luma_label = gtk.Label(_("Luma File:"))
if k_index == -1:
use_preset_luma_combo.set_active(1)
combo_box.set_sensitive(False)
combo_box.set_active(0)
user_luma_select.set_filename(editable_property.value)
else:
use_preset_luma_combo.set_active(0)
user_luma_select.set_sensitive(False)
user_luma_label.set_sensitive(False)
user_luma_row = gtk.HBox(False, 2)
user_luma_row.pack_start(use_preset_luma_combo, False, False, 0)
user_luma_row.pack_start(gtk.Label(), True, True, 0)
user_luma_row.pack_start(user_luma_label, False, False, 2)
user_luma_row.pack_start(user_luma_select, False, False, 0)
editor_pane = gtk.VBox(False)
editor_pane.pack_start(preset_luma_row, False, False, 4)
editor_pane.pack_start(user_luma_row, False, False, 4)
widgets = (combo_box, use_preset_luma_combo, user_luma_select,
user_luma_label, keys)
combo_box.connect("changed", editable_property.combo_selection_changed,
keys)
use_preset_luma_combo.connect("changed", _wipe_preset_combo_changed,
editable_property, widgets)
dialog.connect('response', _wipe_lumafile_dialog_response,
editable_property, widgets)
return editor_pane
def __init__(self):
# Create and setup a new window
# - titlebar, moveable, resizeable...
#self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
# - ontop, sticky, un-moveable, un-resizeable...
self.window = gtk.Window(gtk.WINDOW_POPUP)
# Window properties
self.window.set_title(appname)
self.window.set_border_width(5)
self.window.set_size_request(310, 222)
self.window.set_position(gtk.WIN_POS_CENTER)
# Connect the destroy event to a handler
self.window.connect("destroy", lambda x: gtk.main_quit())
# Create a vertical container box with small padding
self.vbox = gtk.VBox(False, 2)
# Create an image
self.image = gtk.Image()
self.image.set_from_file(appimage)
# Integrate it into the vbox
self.vbox.pack_start(self.image)
# Create a label notice
self.label = gtk.Label(appname)
# Integrate it into the vbox
self.vbox.pack_start(self.label)
# Create a scrolled window
self.scrolledwin = gtk.ScrolledWindow()
self.scrolledwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.scrolledwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
# Integrate it into the vbox
# - child, expand, fill, padding
self.vbox.pack_start(self.scrolledwin, True, True, 0)
# Create a TreeView object
liststore = self.create_listmodel()
self.treeview = gtk.TreeView(liststore)
self.treeview.connect("row-activated", self.on_clkactivated)
# Change the bg color of every 2nd row
self.treeview.set_rules_hint(True)
# Add the TreeView to the scrolled window
self.scrolledwin.add(self.treeview)
# Create TreeView columns
self.create_columns(self.treeview)
# Add the vbox to the main window
self.window.add(self.vbox)
# Create a button box
self.bbox = gtk.HButtonBox()
self.vbox.pack_start(self.bbox, False, False, 0)
self.bbox.set_layout(gtk.BUTTONBOX_SPREAD)
# OK button widget
button = gtk.Button(stock=gtk.STOCK_OK)
button.connect("clicked", self.on_btnactivated)
self.bbox.add(button)
# Close button widget
button = gtk.Button(stock=gtk.STOCK_CANCEL)
button.connect("clicked", lambda w: gtk.main_quit())
self.bbox.add(button)
# This is the default button
button.set_flags(gtk.CAN_DEFAULT)
button.grab_default()
# Set window icon
gtk.window_set_default_icon(self.presentation_select_icon())
# Draw the presentation manager
self.window.show_all()
self.__cr.restore()
def update_layout(widget, testgraph):
testgraph.update_layout()
if __name__ == "__main__":
window = gtk.Window()
window.connect("delete-event", gtk.main_quit)
width = 500
height = 500
window.resize(width, height)
testgraph = TestGraph()
update_button = gtk.Button("Organise graph")
update_button.connect("clicked", update_layout, testgraph)
vbox = gtk.VBox(False, 10)
vbox.pack_start(testgraph, True, True, 0)
vbox.pack_start(update_button, False, False, 0)
window.add(vbox)
testgraph.show()
vbox.show()
update_button.show()
window.present()
gtk.main()
def __init__(self):
self._window = gtk.Window()
self._window.set_icon(getPixbuf("smart"))
self._window.set_title(_("New Mirror"))
self._window.set_modal(True)
self._window.set_position(gtk.WIN_POS_CENTER)
#self._window.set_geometry_hints(min_width=600, min_height=400)
def delete(widget, event):
gtk.main_quit()
return True
self._window.connect("delete-event", delete)
vbox = gtk.VBox()
vbox.set_border_width(10)
vbox.set_spacing(10)
vbox.show()
self._window.add(vbox)
table = gtk.Table()
table.set_row_spacings(10)
table.set_col_spacings(10)
table.show()
vbox.pack_start(table)
label = gtk.Label(_("Origin URL:"))
label.set_alignment(1.0, 0.5)
label.show()
table.attach(label, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
self._origin = gtk.Entry()
self._origin.set_width_chars(40)
self._origin.show()
table.attach(self._origin, 1, 2, 0, 1, gtk.EXPAND | gtk.FILL, gtk.FILL)
label = gtk.Label(_("Mirror URL:"))
label.set_alignment(1.0, 0.5)
label.show()
table.attach(label, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
self._mirror = gtk.Entry()
self._mirror.set_width_chars(40)
self._mirror.show()
table.attach(self._mirror, 1, 2, 1, 2, gtk.EXPAND | gtk.FILL, gtk.FILL)
sep = gtk.HSeparator()
sep.show()
vbox.pack_start(sep, expand=False)
bbox = gtk.HButtonBox()
bbox.set_spacing(10)
bbox.set_layout(gtk.BUTTONBOX_END)
bbox.show()
vbox.pack_start(bbox, expand=False)
self._okbutton = gtk.Button(stock="gtk-ok")
self._okbutton.show()
def clicked(x):
self._result = True
gtk.main_quit()
self._okbutton.connect("clicked", clicked)
bbox.pack_start(self._okbutton)
self._cancelbutton = gtk.Button(stock="gtk-cancel")
self._cancelbutton.show()
self._cancelbutton.connect("clicked", lambda x: gtk.main_quit())
bbox.pack_start(self._cancelbutton)
def make_address_list(self, is_recv):
liststore = self.recv_list if is_recv else self.addressbook_list
treeview = gtk.TreeView(model=liststore)
treeview.connect('key-press-event', self.treeview_key_press)
treeview.connect('button-press-event', self.treeview_button_press)
treeview.show()
if not is_recv:
self.contacts_treeview = treeview
tvcolumn = gtk.TreeViewColumn('Address')
treeview.append_column(tvcolumn)
cell = gtk.CellRendererText()
cell.set_property('family', MONOSPACE_FONT)
tvcolumn.pack_start(cell, True)
tvcolumn.add_attribute(cell, 'text', 0)
tvcolumn = gtk.TreeViewColumn('Label')
tvcolumn.set_expand(True)
treeview.append_column(tvcolumn)
cell = gtk.CellRendererText()
cell.set_property('editable', True)
def edited_cb2(cell, path, new_text, liststore):
address = liststore.get_value(liststore.get_iter(path), 0)
self.wallet.labels[address] = new_text
self.wallet.save()
self.update_receiving_tab()
self.update_sending_tab()
self.update_history_tab()
cell.connect('edited', edited_cb2, liststore)
tvcolumn.pack_start(cell, True)
tvcolumn.add_attribute(cell, 'text', 1)
tvcolumn = gtk.TreeViewColumn('Tx')
treeview.append_column(tvcolumn)
cell = gtk.CellRendererText()
tvcolumn.pack_start(cell, True)
tvcolumn.add_attribute(cell, 'text', 2)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(treeview)
hbox = gtk.HBox()
if not is_recv:
button = gtk.Button("New")
button.connect("clicked", self.newaddress_dialog)
button.show()
hbox.pack_start(button, False)
def showqrcode(w, treeview, liststore):
path, col = treeview.get_cursor()
if not path: return
address = liststore.get_value(liststore.get_iter(path), 0)
qr = pyqrnative.QRCode(4, pyqrnative.QRErrorCorrectLevel.H)
qr.addData(address)
qr.make()
boxsize = 7
size = qr.getModuleCount() * boxsize
def area_expose_cb(area, event):
style = area.get_style()
k = qr.getModuleCount()
for r in range(k):
for c in range(k):
gc = style.black_gc if qr.isDark(r,
c) else style.white_gc
area.window.draw_rectangle(gc, True, c * boxsize,
r * boxsize, boxsize,
boxsize)
area = gtk.DrawingArea()
area.set_size_request(size, size)
area.connect("expose-event", area_expose_cb)
area.show()
dialog = gtk.Dialog(address,
parent=self.window,
flags=gtk.DIALOG_MODAL
| gtk.DIALOG_NO_SEPARATOR,
buttons=("ok", 1))
dialog.vbox.add(area)
dialog.run()
dialog.destroy()
button = gtk.Button("QR")
button.connect("clicked", showqrcode, treeview, liststore)
button.show()
hbox.pack_start(button, False)
button = gtk.Button("Copy to clipboard")
def copy2clipboard(w, treeview, liststore):
import platform
path, col = treeview.get_cursor()
if path:
address = liststore.get_value(liststore.get_iter(path), 0)
if platform.system() == 'Windows':
from Tkinter import Tk
r = Tk()
r.withdraw()
r.clipboard_clear()
r.clipboard_append(address)
r.destroy()
else:
c = gtk.clipboard_get()
c.set_text(address)
button.connect("clicked", copy2clipboard, treeview, liststore)
button.show()
hbox.pack_start(button, False)
if not is_recv:
button = gtk.Button("Pay to")
def payto(w, treeview, liststore):
path, col = treeview.get_cursor()
if path:
address = liststore.get_value(liststore.get_iter(path), 0)
self.payto_entry.set_text(address)
self.notebook.set_current_page(1)
self.amount_entry.grab_focus()
button.connect("clicked", payto, treeview, liststore)
button.show()
hbox.pack_start(button, False)
vbox = gtk.VBox()
vbox.pack_start(scroll, True)
vbox.pack_start(hbox, False)
return vbox
def __init__(self, parent=None):
self._window = gtk.Window()
self._window.set_icon(getPixbuf("smart"))
self._window.set_title(_("Mirrors"))
self._window.set_modal(True)
self._window.set_transient_for(parent)
self._window.set_position(gtk.WIN_POS_CENTER)
self._window.set_geometry_hints(min_width=600, min_height=400)
def delete(widget, event):
gtk.main_quit()
return True
self._window.connect("delete-event", delete)
vbox = gtk.VBox()
vbox.set_border_width(10)
vbox.set_spacing(10)
vbox.show()
self._window.add(vbox)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.show()
vbox.add(sw)
self._treemodel = gtk.TreeStore(gobject.TYPE_STRING)
self._treeview = gtk.TreeView(self._treemodel)
self._treeview.set_rules_hint(True)
self._treeview.set_headers_visible(False)
self._treeview.show()
sw.add(self._treeview)
renderer = gtk.CellRendererText()
renderer.set_property("xpad", 3)
renderer.set_property("editable", True)
renderer.connect("edited", self.rowEdited)
self._treeview.insert_column_with_attributes(-1,
_("Mirror"),
renderer,
text=0)
bbox = gtk.HButtonBox()
bbox.set_spacing(10)
bbox.set_layout(gtk.BUTTONBOX_END)
bbox.show()
vbox.pack_start(bbox, expand=False)
button = gtk.Button(stock="gtk-new")
button.show()
button.connect("clicked", lambda x: self.newMirror())
bbox.pack_start(button)
button = gtk.Button(stock="gtk-delete")
button.show()
button.connect("clicked", lambda x: self.delMirror())
bbox.pack_start(button)
button = gtk.Button(stock="gtk-close")
button.show()
button.connect("clicked", lambda x: gtk.main_quit())
bbox.pack_start(button)
def create_send_tab(self):
page = vbox = gtk.VBox()
page.show()
payto = gtk.HBox()
payto_label = gtk.Label('Pay to:')
payto_label.set_size_request(100, -1)
payto.pack_start(payto_label, False)
payto_entry = gtk.Entry()
payto_entry.set_size_request(450, 26)
payto.pack_start(payto_entry, False)
vbox.pack_start(payto, False, False, 5)
message = gtk.HBox()
message_label = gtk.Label('Description:')
message_label.set_size_request(100, -1)
message.pack_start(message_label, False)
message_entry = gtk.Entry()
message_entry.set_size_request(450, 26)
message.pack_start(message_entry, False)
vbox.pack_start(message, False, False, 5)
amount_box = gtk.HBox()
amount_label = gtk.Label('Amount:')
amount_label.set_size_request(100, -1)
amount_box.pack_start(amount_label, False)
amount_entry = gtk.Entry()
amount_entry.set_size_request(120, -1)
amount_box.pack_start(amount_entry, False)
vbox.pack_start(amount_box, False, False, 5)
self.fee_box = fee_box = gtk.HBox()
fee_label = gtk.Label('Fee:')
fee_label.set_size_request(100, -1)
fee_box.pack_start(fee_label, False)
fee_entry = gtk.Entry()
fee_entry.set_size_request(60, 26)
fee_box.pack_start(fee_entry, False)
vbox.pack_start(fee_box, False, False, 5)
end_box = gtk.HBox()
empty_label = gtk.Label('')
empty_label.set_size_request(100, -1)
end_box.pack_start(empty_label, False)
send_button = gtk.Button("Send")
send_button.show()
end_box.pack_start(send_button, False, False, 0)
clear_button = gtk.Button("Clear")
clear_button.show()
end_box.pack_start(clear_button, False, False, 15)
send_button.connect(
"clicked", self.do_send,
(payto_entry, message_entry, amount_entry, fee_entry))
clear_button.connect(
"clicked", self.do_clear,
(payto_entry, message_entry, amount_entry, fee_entry))
vbox.pack_start(end_box, False, False, 5)
# display this line only if there is a signature
payto_sig = gtk.HBox()
payto_sig_id = gtk.Label('')
payto_sig.pack_start(payto_sig_id, False)
vbox.pack_start(payto_sig, True, True, 5)
self.user_fee = False
def entry_changed(entry, is_fee):
self.funds_error = False
amount = numbify(amount_entry)
fee = numbify(fee_entry)
if not is_fee: fee = None
if amount is None:
return
inputs, total, fee = self.wallet.choose_tx_inputs(amount, fee)
if not is_fee:
fee_entry.set_text(str(Decimal(fee) / 100000000))
self.fee_box.show()
if inputs:
amount_entry.modify_text(gtk.STATE_NORMAL,
gtk.gdk.color_parse("#000000"))
fee_entry.modify_text(gtk.STATE_NORMAL,
gtk.gdk.color_parse("#000000"))
send_button.set_sensitive(True)
else:
send_button.set_sensitive(False)
amount_entry.modify_text(gtk.STATE_NORMAL,
gtk.gdk.color_parse("#cc0000"))
fee_entry.modify_text(gtk.STATE_NORMAL,
gtk.gdk.color_parse("#cc0000"))
self.funds_error = True
amount_entry.connect('changed', entry_changed, False)
fee_entry.connect('changed', entry_changed, True)
self.payto_entry = payto_entry
self.payto_fee_entry = fee_entry
self.payto_sig_id = payto_sig_id
self.payto_sig = payto_sig
self.amount_entry = amount_entry
self.message_entry = message_entry
self.add_tab(page, 'Send')
def __init__(self):
gtk.Window.__init__(self)
bdb.Bdb.__init__(self)
self.realize()
self.set_title("PyGTKDb")
self.connect("destroy", self.do_quit)
self.connect("delete_event", self.do_quit)
self.box = gtk.VBox()
self.add(self.box)
self.box.show()
self.add_stock_ids()
actions = [
('Next', 'pyide-next', None, None, "Next statement", self.do_next),
('Step', 'pyide-step', None, None, "Step into function",
self.do_step),
('Return', 'pyide-return', None, None,
"Continue execution to end of function", self.do_return),
('Continue', 'pyide-continue', None, None,
"Continue execution to next break point", self.do_continue),
('Break', 'pyide-break', None, None,
"Toggle break point at selected line", self.do_break),
('Edit', 'pyide-edit', None, None,
"Edit the value of the selected variable", self.do_edit),
('Run', 'pyide-run', None, None,
"Execute some code in the current stack context", self.do_run),
('Quit', 'pyide-quit', None, None, "Quit the debugger",
self.do_quit),
]
self.ag = gtk.ActionGroup('PyIDE Actions')
self.ag.add_actions(actions)
self.ui = gtk.UIManager()
self.ui.insert_action_group(self.ag, 0)
self.ui.add_ui_from_string(self.ui_string)
self.add_accel_group(self.ui.get_accel_group())
self.box.pack_start(self.ui.get_widget('/Toolbar'), expand=False)
sep = gtk.HSeparator()
self.box.pack_start(sep, expand=False)
sep.show()
vpane = gtk.VPaned()
self.box.pack_start(vpane)
vpane.show()
hpane = gtk.HPaned()
vpane.add1(hpane)
hpane.show()
swin = gtk.ScrolledWindow()
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
hpane.add1(swin)
swin.show()
ls = gtk.ListStore(str)
self.stackdisp = gtk.TreeView(ls)
tvc = gtk.TreeViewColumn('Stack Frame', gtk.CellRendererText(),
text=0)
self.stackdisp.append_column(tvc)
self.stackdisp.set_size_request(280, 125)
selection = self.stackdisp.get_selection()
selection.set_mode(gtk.SELECTION_BROWSE)
selection.connect("changed", self.update_curstack)
self.stackdisp.set_border_width(2)
swin.add(self.stackdisp)
self.stackdisp.show()
swin = gtk.ScrolledWindow()
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
hpane.add2(swin)
swin.show()
ls = gtk.ListStore(str, str, str)
self.vardisp = gtk.TreeView(ls)
titles = ['local var', 'type', 'value']
for n in range(len(titles)):
tvc = gtk.TreeViewColumn(titles[n], gtk.CellRendererText(),
text=n)
self.vardisp.append_column(tvc)
selection = self.vardisp.get_selection()
selection.set_mode(gtk.SELECTION_BROWSE)
selection.connect("changed", self.update_selectedvar)
self.vardisp.set_border_width(2)
self.vardisp.set_border_width(2)
swin.add(self.vardisp)
self.vardisp.show()
self.vardisp.selected = 0
self.vardisp.varnames = []
swin = gtk.ScrolledWindow()
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vpane.add2(swin)
swin.show()
self.minibreak = gtk.Image()
self.minibreak.set_from_file("minibreak.xpm")
self.minibreak.show()
ls = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
self.filedisp = gtk.TreeView(ls)
titles = ['break', 'lineno', 'line']
cell = gtk.CellRendererPixbuf()
tvc = gtk.TreeViewColumn(None, cell, pixbuf=0)
tvc.set_min_width(14)
tvc.set_widget(self.minibreak)
self.filedisp.append_column(tvc)
cell = gtk.CellRendererText()
cell.set_property('xalign', 1.0)
tvc = gtk.TreeViewColumn(titles[1], cell, text=1)
self.filedisp.append_column(tvc)
cell = gtk.CellRendererText()
tvc = gtk.TreeViewColumn(titles[2], cell, text=2)
self.filedisp.append_column(tvc)
self.minibreak = self.minibreak.get_pixbuf()
selection = self.filedisp.get_selection()
selection.set_mode(gtk.SELECTION_BROWSE)
selection.connect("changed", self.update_selection)
self.filedisp.connect('row-activated', lambda t,p,c: self.do_break())
self.filedisp.set_border_width(2)
self.filedisp.set_size_request(600, 200)
swin.add(self.filedisp)
self.filedisp.show()
separator = gtk.HSeparator()
self.box.pack_start(separator, expand=False)
separator.show()
align = gtk.Alignment(0.0, 0.5, 0.0, 0.0)
self.box.pack_start(align, expand=False)
align.show()
self.status = gtk.Label()
self.status.set_padding(4, 1)
align.add(self.status)
self.status.show()
self.filename = None
self.selected = 0
self.blockupdate = 0
return
def __init__(self):
'''Create tablist, window and notebook.'''
self._fifos = {}
self._timers = {}
self._buffer = ""
# Once a second is updated with the latest tabs' uris so that when the
# window is killed the session is saved.
self._tabsuris = []
# And index of current page in self._tabsuris
self._curpage = 0
# Holds metadata on the uzbl childen open.
self.tabs = {}
# Generates a unique id for uzbl socket filenames.
self.next_pid = counter().next
# Create main window
self.window = gtk.Window()
try:
window_size = map(int, config['window_size'].split(','))
self.window.set_default_size(*window_size)
except:
error("Invalid value for default_size in config file.")
self.window.set_title("Uzbl Browser")
self.window.set_border_width(0)
# Set main window icon
icon_path = config['icon_path']
if os.path.exists(icon_path):
self.window.set_icon(gtk.gdk.pixbuf_new_from_file(icon_path))
else:
icon_path = '/usr/share/uzbl/examples/data/uzbl/uzbl.png'
if os.path.exists(icon_path):
self.window.set_icon(gtk.gdk.pixbuf_new_from_file(icon_path))
# Attach main window event handlers
self.window.connect("delete-event", self.quit)
# Create tab list
if config['show_tablist']:
vbox = gtk.VBox()
self.window.add(vbox)
ebox = gtk.EventBox()
self.tablist = gtk.Label()
self.tablist.set_use_markup(True)
self.tablist.set_justify(gtk.JUSTIFY_LEFT)
self.tablist.set_line_wrap(False)
self.tablist.set_selectable(False)
self.tablist.set_padding(2, 2)
self.tablist.set_alignment(0, 0)
self.tablist.set_ellipsize(pango.ELLIPSIZE_END)
self.tablist.set_text(" ")
self.tablist.show()
ebox.add(self.tablist)
ebox.show()
bgcolor = gtk.gdk.color_parse(config['status_background'])
ebox.modify_bg(gtk.STATE_NORMAL, bgcolor)
# Create notebook
self.notebook = gtk.Notebook()
self.notebook.set_show_tabs(config['show_gtk_tabs'])
# Set tab position
allposes = {
'left': gtk.POS_LEFT,
'right': gtk.POS_RIGHT,
'top': gtk.POS_TOP,
'bottom': gtk.POS_BOTTOM
}
if config['gtk_tab_pos'] in allposes.keys():
self.notebook.set_tab_pos(allposes[config['gtk_tab_pos']])
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True)
self.notebook.set_border_width(0)
self.notebook.connect("page-removed", self.tab_closed)
self.notebook.connect("switch-page", self.tab_changed)
self.notebook.connect("page-added", self.tab_opened)
self.notebook.show()
if config['show_tablist']:
if config['tablist_top']:
vbox.pack_start(ebox, False, False, 0)
vbox.pack_end(self.notebook, True, True, 0)
else:
vbox.pack_start(self.notebook, True, True, 0)
vbox.pack_end(ebox, False, False, 0)
vbox.show()
else:
self.window.add(self.notebook)
self.window.show()
self.wid = self.notebook.window.xid
# Create the uzbl_tabbed fifo
fifo_filename = 'uzbltabbed_%d' % os.getpid()
self.fifo_socket = os.path.join(config['fifo_dir'], fifo_filename)
self._create_fifo_socket(self.fifo_socket)
self._setup_fifo_watcher(self.fifo_socket)
def __init__(self, mainwindow):
'''
Initialize the window
@param mainwindow: reference to the parent window
'''
gtk.HBox.__init__(self)
self.mainwindow = mainwindow
self.config = mainwindow.config
self.section = type(self).__name__
h1 = gtk.VBox()
##############################################################################
self.fin = gtk.FileChooserButton("file")
# self.fin.set_current_folder("")
#TODO
self.fin.set_current_folder("$HESSUSER/RoundUp/Maps")
self.fin.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
self.fin.show()
# Simulated spectrum
f = gtk.Frame("Root files")
h1.pack_start(f, expand=False, fill=False, padding=5)
t = gtk.Table(5, 2)
f.add(t)
t.attach(self.fin, 0, 2, 0, 1, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 5)
# t.attach(gtk.Label("Spectral Index"), 0, 1, 1, 2, gtk.EXPAND | gtk.FILL, 5, 5)
#Load file list button
self.load_button = gtk_supp.PixmapButton(gtk.STOCK_OPEN,
"Load file list")
self.load_button.connect("clicked", self.load_run_list)
# h1.pack_start(self.load_button, expand=False, fill=False, padding=1)
t.attach(self.load_button, 2, 3, 0, 1, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 5)
##############################################################################
# ==== default values ====
self.ra_mode = True
self.ra = 0.
self.dec = 0.
self.MinSig = 4.5
self.UseConfigTarget = 1
f = gtk.Frame("Target ")
h1.pack_start(f, expand=False, fill=False, padding=5)
t3 = gtk.Table(3, 3)
f.add(t3)
self.UseConfigTarget_button = SignalWidgets.CheckButton(
"Config from File results")
self.UseConfigTarget_button.set_active(True)
t3.attach(self.UseConfigTarget_button, 0, 3, 1, 2,
gtk.EXPAND | gtk.FILL, gtk.EXPAND | gtk.FILL, 5, 1)
self.UseConfigTarget_button.connect("toggled",
self.changed_UseConfigTarget)
t3.attach(gtk.Label("Target Name"), 0, 1, 2, 3, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
self.target_list = gtk_supp.EntryCompletion(0)
self.target_list.set_size_request(150, -1)
t3.attach(self.target_list, 1, 2, 2, 3, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
self.filter_pos_button = gtk_supp.PixmapButton(gtk.STOCK_EXECUTE,
"Lookup")
self.filter_pos_button.set_size_request(150, -1)
self.filter_pos_button.connect("clicked", self.lookup_pos)
t3.attach(self.filter_pos_button, 2, 4, 2, 3, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
self.ra_label = gtk.Label("RA :")
t3.attach(self.ra_label, 1, 2, 3, 4, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
self.ra_entry = gtk.SpinButton(gtk.Adjustment(self.ra, -360, 360, .1),
.5, 4)
self.ra_entry.set_numeric(True)
self.ra_entry.set_size_request(30, -1)
t3.attach(self.ra_entry, 2, 3, 3, 4, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
self.dec_label = gtk.Label("DEC :")
t3.attach(self.dec_label, 1, 2, 4, 5, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
self.dec_entry = gtk.SpinButton(gtk.Adjustment(self.dec, -90, 90, .1),
.5, 4)
self.dec_entry.set_numeric(True)
self.dec_entry.set_size_request(30, -1)
t3.attach(self.dec_entry, 2, 3, 4, 5, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
self.target_list.set_sensitive(False)
self.filter_pos_button.set_sensitive(False)
self.ra_label.set_sensitive(False)
self.ra_entry.set_sensitive(False)
self.dec_label.set_sensitive(False)
self.dec_entry.set_sensitive(False)
#Start button
self.exec_button = gtk_supp.PixmapButton(gtk.STOCK_EXECUTE,
"ONOFF Test @ Pos")
self.exec_button.connect("clicked", self.start_ONOFFTest)
# h1.pack_start(self.exec_button, expand=False, fill=False, padding=1)
t3.attach(self.exec_button, 0, 2, 5, 6, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
#Start button
self.exec_buttonFP = gtk_supp.PixmapButton(gtk.STOCK_EXECUTE,
"Info @ Pos")
self.exec_buttonFP.connect("clicked", self.start_findPos)
# h1.pack_start(self.exec_buttonFP, expand=False, fill=False, padding=1)
t3.attach(self.exec_buttonFP, 2, 4, 5, 6, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
f2 = gtk.Frame("Tools ")
h1.pack_start(f2, expand=False, fill=False, padding=5)
ttools = gtk.Table(3, 2)
f2.add(ttools)
# #Start button
# self.exec_buttonFP = gtk_supp.PixmapButton(gtk.STOCK_EXECUTE, "Start FindPosition")
# self.exec_buttonFP.connect("clicked", self.start_findPos)
# # h1.pack_start(self.exec_buttonFP, expand=False, fill=False, padding=1)
# ttools.attach(self.exec_buttonFP, 1, 2, 4,5, gtk.EXPAND | gtk.FILL, gtk.EXPAND | gtk.FILL, 5, 1)
#Start button
self.exec_buttonFindspot = gtk_supp.PixmapButton(
gtk.STOCK_EXECUTE, "Find Hot Spot (Significance) ")
self.exec_buttonFindspot.connect("clicked", self.start_FindHotSpot)
# h1.pack_start(self.exec_buttonFindspot, expand=False, fill=False, padding=1)
ttools.attach(self.exec_buttonFindspot, 1, 2, 2, 3,
gtk.EXPAND | gtk.FILL, gtk.EXPAND | gtk.FILL, 5, 1)
self.minsig_label = gtk.Label("Min Significance :")
ttools.attach(self.minsig_label, 2, 3, 2, 3, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
self.MinSig_entry = gtk.SpinButton(
gtk.Adjustment(self.MinSig, 0, 90, .1), .1, 4)
self.MinSig_entry.set_numeric(True)
self.MinSig_entry.set_size_request(30, -1)
ttools.attach(self.MinSig_entry, 3, 4, 2, 3, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 5, 1)
#Start button
self.exec_buttonFindspot = gtk_supp.PixmapButton(
gtk.STOCK_EXECUTE, "Find Hot Spot (ONOFF) ")
self.exec_buttonFindspot.connect("clicked",
self.start_FindHotSpotONOFF)
# h1.pack_start(self.exec_buttonFindspot, expand=False, fill=False, padding=1)
ttools.attach(self.exec_buttonFindspot, 1, 2, 3, 4,
gtk.EXPAND | gtk.FILL, gtk.EXPAND | gtk.FILL, 5, 1)
#Start button
self.exec_buttonDrawMap = gtk_supp.PixmapButton(
gtk.STOCK_EXECUTE, "Open Results Maps")
self.exec_buttonDrawMap.connect("clicked", self.start_OpenResults)
h1.pack_start(self.exec_buttonDrawMap,
expand=False,
fill=False,
padding=1)
# tsum= gtk.Table(3, 3)
# f.add(tsum)
self.exec_MakeSummary = gtk_supp.PixmapButton(gtk.STOCK_EXECUTE,
"Make Summary")
self.exec_MakeSummary.connect("clicked", self.start_MakeSummary)
h1.pack_start(self.exec_MakeSummary,
expand=False,
fill=False,
padding=1)
# ##############################################################################
# #Selection window
self.pack_start(h1, expand=False, fill=True, padding=5)
h1 = gtk.VBox()
self.pack_start(h1, expand=True, fill=True, padding=5)
# self.list = gtk_supp.SortList(1, (""))
self.list = gtk_supp.SortList(2, ("filename", "size"))
self.list.set_selection_mode(gtk.SELECTION_EXTENDED)
self.list.set_size_request(400, -1)
self.list.set_column_width(0, 400)
self.list.set_column_width(1, 100)
swin = gtk.ScrolledWindow()
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
swin.set_size_request(-1, -1)
swin.add(self.list)
h1.pack_start(swin, expand=True, fill=True, padding=5)
def get_orphan_container(self, page):
"""Return a container with the page object inside."""
box = gtk.VBox()
box.pack_start(page, expand=True, fill=True)
box.show()
return box
def about_shortcuts(self, _button):
# define the shortcuts and their descriptions
# these are all gettextable
mainshortcuts = \
[[ "F1", _("About Sonata") ],
[ "F5", _("Preferences") ],
[ "F11", _("Fullscreen Artwork Mode") ],
[ "Alt-[1-5]", _("Switch to [1st-5th] tab") ],
[ "Alt-C", _("Connect to MPD") ],
[ "Alt-D", _("Disconnect from MPD") ],
[ "Alt-R", _("Randomize current playlist") ],
[ "Alt-Down", _("Expand player") ],
[ "Alt-Left", _("Switch to previous tab") ],
[ "Alt-Right", _("Switch to next tab") ],
[ "Alt-Up", _("Collapse player") ],
[ "Ctrl-H", _("Search library") ],
[ "Ctrl-Q", _("Quit") ],
[ "Ctrl-Shift-U", _("Update entire library") ],
[ "Menu", _("Display popup menu") ],
[ "Escape", _("Minimize to system tray (if enabled)") ]]
playbackshortcuts = \
[[ "Ctrl-Left", _("Previous track") ],
[ "Ctrl-Right", _("Next track") ],
[ "Ctrl-P", _("Play/Pause") ],
[ "Ctrl-S", _("Stop") ],
[ "Ctrl-Minus", _("Lower the volume") ],
[ "Ctrl-Plus", _("Raise the volume") ]]
currentshortcuts = \
[[ "Enter/Space", _("Play selected song") ],
[ "Delete", _("Remove selected song(s)") ],
[ "Ctrl-I", _("Center currently playing song") ],
[ "Ctrl-T", _("Edit selected song's tags") ],
[ "Ctrl-Shift-S", _("Save to new playlist") ],
[ "Ctrl-Delete", _("Clear list") ],
[ "Alt-R", _("Randomize list") ]]
libraryshortcuts = \
[[ "Enter/Space", _("Add selected song(s) or enter directory") ],
[ "Backspace", _("Go to parent directory") ],
[ "Ctrl-D", _("Add selected item(s)") ],
[ "Ctrl-R", _("Replace with selected item(s)") ],
[ "Ctrl-T", _("Edit selected song's tags") ],
[ "Ctrl-Shift-D", _("Add selected item(s) and play") ],
[ "Ctrl-Shift-R", _("Replace with selected item(s) and play") ],
[ "Ctrl-U", _("Update selected item(s)/path(s)") ]]
playlistshortcuts = \
[[ "Enter/Space", _("Add selected playlist(s)") ],
[ "Delete", _("Remove selected playlist(s)") ],
[ "Ctrl-D", _("Add selected playlist(s)") ],
[ "Ctrl-R", _("Replace with selected playlist(s)") ],
[ "Ctrl-Shift-D", _("Add selected playlist(s) and play") ],
[ "Ctrl-Shift-R", _("Replace with selected playlist(s) and play") ]]
streamshortcuts = \
[[ "Enter/Space", _("Add selected stream(s)") ],
[ "Delete", _("Remove selected stream(s)") ],
[ "Ctrl-D", _("Add selected stream(s)") ],
[ "Ctrl-R", _("Replace with selected stream(s)") ],
[ "Ctrl-Shift-D", _("Add selected stream(s) and play") ],
[ "Ctrl-Shift-R", _("Replace with selected stream(s) and play") ]]
infoshortcuts = \
[[ "Ctrl-T", _("Edit playing song's tags") ]]
# define the main array- this adds headings to each section of
# shortcuts that will be displayed
shortcuts = [[ _("Main Shortcuts"), mainshortcuts ],
[ _("Playback Shortcuts"), playbackshortcuts ],
[ _("Current Shortcuts"), currentshortcuts ],
[ _("Library Shortcuts"), libraryshortcuts ],
[ _("Playlist Shortcuts"), playlistshortcuts ],
[ _("Stream Shortcuts"), streamshortcuts ],
[ _("Info Shortcuts"), infoshortcuts ]]
dialog = ui.dialog(title=_("Shortcuts"), parent=self.about_dialog, flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE), role='shortcuts', default=gtk.RESPONSE_CLOSE, h=320)
# each pair is a [ heading, shortcutlist ]
vbox = gtk.VBox()
for pair in shortcuts:
titlelabel = ui.label(markup="<b>%s</b>" % pair[0])
vbox.pack_start(titlelabel, False, False, 2)
# print the items of [ shortcut, desc ]
for item in pair[1]:
tmphbox = gtk.HBox()
tmplabel = ui.label(markup="<b>%s:</b>" % item[0], y=0)
tmpdesc = ui.label(text=item[1], wrap=True, y=0)
tmphbox.pack_start(tmplabel, False, False, 2)
tmphbox.pack_start(tmpdesc, True, True, 2)
vbox.pack_start(tmphbox, False, False, 2)
vbox.pack_start(ui.label(text=" "), False, False, 2)
scrollbox = ui.scrollwindow(policy_x=gtk.POLICY_NEVER, addvp=vbox)
dialog.vbox.pack_start(scrollbox, True, True, 2)
dialog.show_all()
dialog.run()
dialog.destroy()
def __init__(self, w3af):
super(VulnAddDialog,
self).__init__("Add new vulnerability", None,
gtk.MESSAGE_QUESTION,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_ADD, gtk.RESPONSE_OK))
self.set_icon_from_file(W3AF_ICON)
self.w3af = w3af
# Main hbox
hbox = gtk.HBox()
hbox.show()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_DIALOG_QUESTION, gtk.ICON_SIZE_DIALOG)
image.set_padding(20, 20)
image.show()
hbox.pack_start(image)
# Vbox with all the information for the right section of the dialog
vbox = gtk.VBox()
# Add a label
align = gtk.Alignment()
align.set_padding(10, 0, 0, 10)
label = gtk.Label('Choose the vulnerability template to use:')
align.add(label)
vbox.pack_start(align)
template_long_names = get_template_long_names()
template_names = get_template_names()
self.vuln_template = None
# A list store with the following columns:
# * Long template name (show)
# * Template name (code internals)
liststore = gtk.ListStore(str, str)
self.combobox = gtk.ComboBox(liststore)
cell = gtk.CellRendererText()
self.combobox.pack_start(cell, True)
self.combobox.add_attribute(cell, 'text', 0)
self.combobox.connect("changed", self._changed_combo)
for i, long_name in enumerate(template_long_names):
liststore.append((long_name, template_names[i]))
vbox.pack_start(self.combobox, False, False)
vbox.pack_start(gtk.Label())
# the Cancel button
but = self.action_area.get_children()[1]
but.connect("clicked", lambda x: self.destroy())
self.connect("delete-event", lambda x, y: self.destroy())
# the Ok button
self.ok_but = self.action_area.get_children()[0]
self.ok_but.connect("clicked", self._ok)
self.ok_but.set_sensitive(False)
hbox.pack_start(vbox)
self.vbox.pack_start(hbox)
self.show_all()
def __init__(self, *args, **kwargs):
gtk.Window.__init__(self, *args, **kwargs)
self.set_title('Spell check')
self.set_default_size(350, 200)
self._checker = None
self._numContext = 40
self.errors = None
# create accel group
accel_group = gtk.AccelGroup()
self.add_accel_group(accel_group)
# list of widgets to disable if there's no spell error left
self._conditional_widgets = []
conditional = self._conditional_widgets.append
# layout
mainbox = gtk.VBox(spacing=5)
hbox = gtk.HBox(spacing=5)
self.add(mainbox)
mainbox.pack_start(hbox, padding=5)
box1 = gtk.VBox(spacing=5)
hbox.pack_start(box1, padding=5)
conditional(box1)
# unreconized word
text_view_lable = gtk.Label('Unreconized word')
text_view_lable.set_justify(gtk.JUSTIFY_LEFT)
box1.pack_start(text_view_lable, False, False)
text_view = gtk.TextView()
text_view.set_wrap_mode(gtk.WRAP_WORD)
text_view.set_editable(False)
text_view.set_cursor_visible(False)
self.error_text = text_view.get_buffer()
text_buffer = text_view.get_buffer()
text_buffer.create_tag("fg_black", foreground="black")
text_buffer.create_tag("fg_red", foreground="red")
box1.pack_start(text_view)
# Change to
change_to_box = gtk.HBox()
box1.pack_start(change_to_box, False, False)
change_to_label = gtk.Label('Change to:')
self.replace_text = gtk.Entry()
text_view_lable.set_justify(gtk.JUSTIFY_LEFT)
change_to_box.pack_start(change_to_label, False, False)
change_to_box.pack_start(self.replace_text)
# scrolled window
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
box1.pack_start(sw)
self.suggestion_list_view = create_list_view('Suggestions')
self.suggestion_list_view.connect("button_press_event",
self._onButtonPress)
self.suggestion_list_view.connect("cursor-changed",
self._onSuggestionChanged)
sw.add(self.suggestion_list_view)
#---Buttons---#000000#FFFFFF----------------------------------------------------
button_box = gtk.VButtonBox()
hbox.pack_start(button_box, False, False)
# Ignore
button = gtk.Button("Ignore")
button.connect("clicked", self._onIgnore)
button.add_accelerator("activate", accel_group, gtk.keysyms.Return, 0,
gtk.ACCEL_VISIBLE)
button_box.pack_start(button)
conditional(button)
# Ignore all
button = gtk.Button("Ignore All")
button.connect("clicked", self._onIgnoreAll)
button_box.pack_start(button)
conditional(button)
# Replace
button = gtk.Button("Replace")
button.connect("clicked", self._onReplace)
button_box.pack_start(button)
conditional(button)
# Replace all
button = gtk.Button("Replace All")
button.connect("clicked", self._onReplaceAll)
button_box.pack_start(button)
conditional(button)
# Recheck button
button = gtk.Button("_Add")
button.connect("clicked", self._onAdd)
button_box.pack_start(button)
conditional(button)
# Close button
button = gtk.Button(stock=gtk.STOCK_CLOSE)
button.connect("clicked", self._onClose)
button.add_accelerator("activate", accel_group, gtk.keysyms.Escape, 0,
gtk.ACCEL_VISIBLE)
button_box.pack_end(button)
# dictionary label
self._dict_lable = gtk.Label('')
mainbox.pack_start(self._dict_lable, False, False, padding=5)
mainbox.show_all()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", self.destroy)
self.window.set_default_size(400, 300)
self.window.set_border_width(20)
# Title
vbox = gtk.VBox(False, 0)
vbox.set_spacing(15)
label = gtk.Label("Connect to xpra server")
label.modify_font(pango.FontDescription("sans 13"))
vbox.pack_start(label)
# Mode:
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
hbox.pack_start(gtk.Label("Mode: "))
self.mode_combo = gtk.combo_box_new_text()
self.mode_combo.get_model().clear()
self.mode_combo.append_text("tcp")
if not sys.platform.startswith("win"):
#when we fix the build on win32 to include putty
#this can be enabled again:
self.mode_combo.append_text("ssh")
if xpra_opts.mode == "tcp" or sys.platform.startswith("win"):
self.mode_combo.set_active(0)
else:
self.mode_combo.set_active(1)
hbox.pack_start(self.mode_combo)
vbox.pack_start(hbox)
# Encoding:
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
hbox.pack_start(gtk.Label("Encoding: "))
self.encoding_combo = gtk.combo_box_new_text()
self.encoding_combo.get_model().clear()
for option in XPRA_ENCODING_OPTIONS:
self.encoding_combo.append_text(option)
self.encoding_combo.set_active(
XPRA_ENCODING_OPTIONS.index(xpra_opts.encoding))
hbox.pack_start(self.encoding_combo)
vbox.pack_start(hbox)
# JPEG:
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
hbox.pack_start(gtk.Label("JPEG Compression: "))
self.jpeg_combo = gtk.combo_box_new_text()
self.jpeg_combo.get_model().clear()
for option in XPRA_COMPRESSION_OPTIONS:
self.jpeg_combo.append_text(option)
self.jpeg_combo.set_active(2)
hbox.pack_start(self.jpeg_combo)
vbox.pack_start(hbox)
# Host:Port
hbox = gtk.HBox(False, 0)
hbox.set_spacing(5)
self.host_entry = gtk.Entry(max=128)
self.host_entry.set_width_chars(40)
self.host_entry.set_text(xpra_opts.host)
self.port_entry = gtk.Entry(max=5)
self.port_entry.set_width_chars(5)
self.port_entry.set_text(str(xpra_opts.port))
hbox.pack_start(self.host_entry)
hbox.pack_start(gtk.Label(":"))
hbox.pack_start(self.port_entry)
vbox.pack_start(hbox)
# Password
hbox = gtk.HBox(False, 0)
hbox.set_spacing(20)
self.password_entry = gtk.Entry(max=128)
self.password_entry.set_width_chars(30)
self.password_entry.set_text("")
self.password_entry.set_visibility(False)
hbox.pack_start(gtk.Label("Password: "******"Connect")
self.button.connect("clicked", self.connect_clicked, None)
vbox.pack_start(self.button)
self.window.add(vbox)
self.window.show_all()
def createScreen(self):
self.loginPage = FirstbootLoginPage()
self.vbox = gtk.VBox(spacing=5)
self.vbox.pack_start(self.loginPage.loginPageVbox(), True, True)
