def create(self, path, accelerator=None, callback=None, *args):
"""
create a single menuitem and add it to one of the menus already
created (or create a new one)
"""
last_slash = string.rfind(path, '/')
if last_slash < 0:
parentmenu = self.__w
else:
parentmenu = self.get_menu(path[:last_slash])
label = path[last_slash+1:]
if label == '<separator>':
item = gtk.GtkMenuItem()
elif label[:7] == '<image:':
end = string.find(label, '>')
img_name = label[7:end]
hbox = gtk.GtkHBox(spacing=2)
try:
hbox.pack_start(self.create_pixmap(img_name), expand=FALSE)
except:
print 'Unable to load menu pixmap: ' + img_name
lbl = gtk.GtkLabel(label[end+1:])
lbl.set_justify(gtk.JUSTIFY_LEFT)
hbox.pack_start(lbl, expand=FALSE)
item = gtk.GtkMenuItem()
item.add(hbox)
item.show_all()
elif label[:8] == '<toggle>':
item = pguToggleMenuItem(label[8:])
elif label[:7] == '<check>':
item = gtk.GtkCheckMenuItem(label[7:])
else:
if parentmenu == self.__w:
item = gtk.GtkMenuItem(label)
else:
hbox = gtk.GtkHBox()
spc = gtk.GtkLabel('')
spc.set_usize(22,18)
hbox.pack_start(spc, expand=FALSE)
lbl = gtk.GtkLabel(label)
lbl.set_justify(gtk.JUSTIFY_LEFT)
hbox.pack_start(lbl, expand=FALSE)
item = gtk.GtkMenuItem()
item.add(hbox)
if label != '<nothing>':
item.show()
if accelerator:
key, mods = self.parse_accelerator(accelerator)
item.add_accelerator("activate", self.accelerator,
key, mods, 'visible')
if callback:
apply(item.connect, ("activate", callback) + args)
# right justify the help menu automatically
if string.lower(label) == 'help' and parentmenu == self.__w:
item.right_justify()
parentmenu.append(item)
self.__items[path] = item
return item
def UpdatePatchDo(items):
menu = gtk.GtkMenu()
for item in items[0]:
menu_item = gtk.GtkMenuItem(item)
menu_item.connect("activate", Patch_Changed)
menu_item.show()
menu.append(menu_item)
menu.set_active(items[1])
getWidget("whichpatch").set_menu(menu)
getWidget("patch_name").set_text(items[0][items[1]])
menu = gtk.GtkMenu()
for item in items[2]:
menu_item = gtk.GtkMenuItem(item)
menu_item.connect("activate", Port_Changed)
menu_item.show()
menu.append(menu_item)
menu.set_active(0)
getWidget("whichport").set_menu(menu)
getWidget("port").set_text(items[3])
getWidget("channel").set_text(str(items[4]))
getWidget("msb").set_text(str(items[5]))
getWidget("lsb").set_text(str(items[6]))
getWidget("preset").get_adjustment().set_value(items[7])
getWidget("pan_onoff").set_active(items[8])
panwidg = getWidget("pan")
panwidg.set_sensitive(items[8])
panwidg.get_adjustment().set_value(items[9])
getWidget("vol_onoff").set_active(items[10])
volwidg = getWidget("vol")
volwidg.set_sensitive(items[10])
volwidg.get_adjustment().set_value(items[11])
getWidget("vel").get_adjustment().set_value(items[12])
ccnams = range(8)
ccvals = range(8)
for lokke in range(8):
ccnams[lokke] = getWidget("ccnam" + str(lokke))
ccvals[lokke] = getWidget("ccval" + str(lokke))
getWidget("cconoff" + str(lokke)).set_active(items[13][lokke])
ccnams[lokke].set_sensitive(items[13][lokke])
ccvals[lokke].set_sensitive(items[13][lokke])
ccnams[lokke].set_text(
str(items[15][lokke]) + ". " + items[14][lokke])
ccvals[lokke].get_adjustment().set_value(items[16][lokke])
def makeoptmenu(name, opts, default=0, func=None):
hbox = gtk.GtkHBox()
label = gtk.GtkLabel(name)
label.show()
hbox.pack_start(label)
menu = gtk.GtkMenu()
def store(widget, data):
self.values[name] = data
if func:
func(widget, data)
for text, data in opts:
menu_item = gtk.GtkMenuItem(text)
menu_item.connect("activate", store, data)
menu_item.show()
menu.append(menu_item)
option_menu = gtk.GtkOptionMenu()
option_menu.set_menu(menu)
option_menu.set_history(default)
self.values[name] = opts[default][1]
option_menu.show()
hbox.pack_start(option_menu)
hbox.show()
return hbox
def __init__(self,
ok_cb=None,
cancel_cb=None,
cb_data=None,
classify_type=CLASSIFY_EQUAL_INTERVAL):
gtk.GtkWindow.__init__(self)
self.set_title('Classification')
self.user_ok_cb = ok_cb
self.user_cancel_cb = cancel_cb
self.user_cb_data = cb_data
self.classify_type = classify_type
self.set_border_width(6)
#main vertical box
vbox = gtk.GtkVBox(spacing=6)
type_box = gtk.GtkHBox(spacing=6)
type_box.pack_start(gtk.GtkLabel('Type:'), expand=gtk.FALSE)
opt_menu = gtk.GtkOptionMenu()
type_menu = gtk.GtkMenu()
#using classification_types dictionary from gvclassification
for i in range(len(classification_types)):
for type in classification_types.iteritems():
if type[1] == i:
item = gtk.GtkMenuItem(type[0])
item.connect('activate', self.type_menu_cb,
classification_types[type[0]])
type_menu.append(item)
opt_menu.set_menu(type_menu)
opt_menu.set_history(classify_type)
opt_menu.resize_children()
type_box.pack_start(opt_menu)
vbox.pack_start(type_box, expand=gtk.FALSE)
#Number of classes
classes_box = gtk.GtkHBox(spacing=6)
classes_box.pack_start(gtk.GtkLabel('Number of classes:'))
adj = gtk.GtkAdjustment(5, 2, 80, 1, 5, 5, 0)
self.spinner = gtk.GtkSpinButton(adj)
self.spinner.set_snap_to_ticks(gtk.TRUE)
self.spinner.set_digits(0)
classes_box.pack_start(self.spinner)
vbox.pack_start(classes_box, expand=gtk.FALSE)
#add the ok and cancel buttons
button_box = gtk.GtkHButtonBox()
ok_button = gtk.GtkButton("OK")
ok_button.connect('clicked', self.ok_cb, cb_data)
cancel_button = gtk.GtkButton("Cancel")
cancel_button.connect('clicked', self.cancel_cb, cb_data)
button_box.pack_start(ok_button)
button_box.pack_start(cancel_button)
vbox.pack_start(button_box, expand=gtk.FALSE)
vbox.show_all()
self.add(vbox)
ok_button.set_flags(gtk.CAN_DEFAULT)
ok_button.grab_default()
def _createMenu(items, callback, data):
menu = gtk.GtkMenu()
if not items:
items = [("(none)", None)]
for label, id in items:
menu_item = gtk.GtkMenuItem(label)
menu_item.set_data("Gimp-ID", id)
menu.add(menu_item)
if callback:
menu_item.connect("activate", _callbackWrapper,
callback, data)
menu_item.show()
return menu
def _updateAccountMenu(self):
# This seems to be necessary -- I don't understand gtk's handling of
# GtkOptionMenus
print 'updating account menu', self.accountMenuItems
self.accountMenu = gtk.GtkMenu()
for account in self.accountMenuItems:
i = gtk.GtkMenuItem(account.accountName)
i.connect('activate', self.on_AccountsListPopup_activate, account)
self.accountMenu.append(i)
if self.accountMenuItems:
print "setting default account to", self.accountMenuItems[0]
self.currentAccount = self.accountMenuItems[0]
self.accountMenu.show_all()
self.optionMenu.set_menu(self.accountMenu)
def __init__(self, manager):
self.manager = manager
self.manager.lockNewAccount(1)
self.xml = openGlade(GLADE_FILE, root="NewAccountWindow")
autoConnectMethods(self)
self.widget = self.xml.get_widget("NewAccountWindow")
self.frame = self.xml.get_widget("GatewayFrame")
# Making up for a deficiency in glade.
widgetMenu = self.xml.get_widget("GatewayOptionMenu")
m = gtk.GtkMenu()
activ = 0
self.currentGateway = None
for name, klas in registeredTypes:
i = gtk.GtkMenuItem(name)
m.append(i)
k = klas(self.manager)
i.connect("activate", self.gatewaySelected, k)
if not activ:
activ = 1
self.gatewaySelected(None, k)
widgetMenu.set_menu(m)
self.widget.show_all()
def show(self):
if self.window is not None:
self.window.destroy()
xml = p4vasp.util.loadGlade("graphwindow.glade", "exportdata_window")
self.connect_signals(xml)
self.xml = xml
self.file_entry = xml.get_widget("file_entry")
opt = xml.get_widget("type_optionmenu")
menu = gtk.GtkMenu()
opt.set_menu(menu)
self.type_menu = menu
self.type_options = opt
for i in range(len(self.options)):
item = gtk.GtkMenuItem(self.options[i])
item.signal_connect("activate", self._set_type, i)
menu.append(item)
item.show()
opt.show()
opt.set_history(0)
self.window = xml.get_widget("exportdata_window")
self.window.show()
def refresh_directory(self, *args):
"""refresh the directory menu and cause a rebuild of the
file/directory lists"""
self.menu_update = gtk.TRUE
self.opt_menu.remove_menu()
paths = []
drive, head = os.path.splitdrive(self.cwd)
while head <> os.sep and head <> "":
paths.append(drive + head)
head, tail = os.path.split(head)
paths.append(drive + os.sep)
menu = gtk.GtkMenu()
for path in paths:
item = gtk.GtkMenuItem(path)
item.show()
item.connect('activate', self.directory_cb, path)
menu.append(item)
self.opt_menu.set_menu(menu)
self.opt_menu.set_history(len(paths))
self.refresh_files()
self.menu_update = gtk.FALSE
def __init__(self, reader, message, addrlist):
self.reader = reader
self.message = message
composewin = reader.readglade("composewin", self)
self.widget = sqmail.gui.utils.WidgetStore(composewin)
self.font = gtk.load_font(sqmail.preferences.get_composefont())
# Ensure the text box is 80 columns wide.
width = gtk.gdk_char_width(self.font, "m") * 82
# Set up the header fields.
if addrlist:
self.widget.tofield.set_text(
sqmail.gui.utils.render_addrlist(addrlist))
self.widget.fromfield.set_text(sqmail.preferences.get_fromaddress())
if message:
i = self.message.getsubject()
if (i[:3] == "Re:") or (i[:3] == "re:"):
self.widget.subjectfield.set_text(i)
else:
self.widget.subjectfield.set_text("Re: " + i)
# Set up the sign button.
self.signaturespopup = gtk.GtkMenu()
signatures = os.listdir(os.path.expanduser("~"))
signatures.sort()
for i in signatures:
if (i[0:10] == ".signature"):
w = gtk.GtkMenuItem(i)
w.show()
w.connect("activate",
sqmail.gui.utils.Callback(self)["on_sign_with"])
w.set_data("file", i)
self.signaturespopup.append(w)
# Set up the quote button.
if message:
self.quotepopup = gtk.GtkMenu()
attachments = message.mimeflatten()
for i in attachments:
if (i[1] in sqmail.gui.textviewer.displayable):
w = gtk.GtkMenuItem(i[1] + ": " + i[0])
w.show()
w.connect("activate",
sqmail.gui.utils.Callback(self)["on_quote_with"])
w.set_data("msg", i[2])
self.quotepopup.append(w)
else:
self.widget.quotebutton.set_sensitive(0)
self.widget.textbox.freeze()
self.widget.textbox.set_usize(width, 0)
# These two lines set the font. *shrug*
self.widget.textbox.insert(self.font, None, None, "\n")
self.widget.textbox.delete_text(0, 1)
# We want word wrapping.
self.widget.textbox.set_word_wrap(1)
self.widget.textbox.thaw()
def prefs_window():
win = gtk.GtkWindow()
gui["prefs_window"] = win
win.set_policy(gtk.TRUE, gtk.TRUE, gtk.FALSE)
win.set_title("Preferences")
win.connect("delete_event", prefs_window_close)
win.set_border_width(2)
window_pos_mode(win)
frame = gtk.GtkFrame()
frame.show()
frame.set_border_width(2)
win.add(frame)
vbox = gtk.GtkVBox(spacing=5)
vbox.show()
frame.add(vbox)
gui["cb_ascii"] = gtk.GtkCheckButton("ASCII only")
vbox.pack_start(gui["cb_ascii"])
gui["cb_ascii"].connect("toggled", prefs_toggled, 0)
gui["cb_ascii"].show()
gui["cb_rexp"] = gtk.GtkCheckButton("Remember last expression")
vbox.pack_start(gui["cb_rexp"])
gui["cb_rexp"].connect("toggled", prefs_toggled, 1)
gui["cb_rexp"].show()
hbox = gtk.GtkHBox()
vbox.pack_start(hbox)
hbox.show()
label = gtk.GtkLabel(" Window placement: ")
label.show()
hbox.pack_start(label)
menu = gtk.GtkMenu()
menuitem = gtk.GtkMenuItem("None")
menuitem.connect("activate", prefs_selected_1, 0)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("Center")
menuitem.connect("activate", prefs_selected_1, 1)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("Mouse")
menuitem.connect("activate", prefs_selected_1, 2)
menu.append(menuitem)
menuitem.show()
gui["wp_menu"] = gtk.GtkOptionMenu()
gui["wp_menu"].set_menu(menu)
gui["wp_menu"].set_history(
hive.get_integer("/window/placement", default_window_placement))
hbox.pack_start(gui["wp_menu"])
gui["wp_menu"].show()
hbox = gtk.GtkHBox()
vbox.pack_start(hbox)
hbox.show()
label = gtk.GtkLabel(" Binary separators: ")
label.show()
hbox.pack_start(label)
menu = gtk.GtkMenu()
menuitem = gtk.GtkMenuItem("0")
menuitem.connect("activate", prefs_selected_2, 0)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("1")
menuitem.connect("activate", prefs_selected_2, 1)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("3")
menuitem.connect("activate", prefs_selected_2, 2)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("7")
menuitem.connect("activate", prefs_selected_2, 3)
menu.append(menuitem)
menuitem.show()
gui["bs_menu"] = gtk.GtkOptionMenu()
gui["bs_menu"].set_menu(menu)
gui["bs_menu"].set_history(
hive.get_integer("/binary_separators", default_binary_separators))
hbox.pack_start(gui["bs_menu"])
gui["bs_menu"].show()
if hive.get_bool("/ascii_only", default_ascii_only):
gui["cb_ascii"].set_active(gtk.TRUE)
else:
gui["cb_ascii"].set_active(gtk.FALSE)
if hive.get_bool("/remember_expression", default_remember_expression):
gui["cb_rexp"].set_active(gtk.TRUE)
else:
gui["cb_rexp"].set_active(gtk.FALSE)
button = gtk.GtkButton("Close")
button.connect("clicked", prefs_window_close)
vbox.pack_start(button, expand=gtk.FALSE)
button.set_flags(gtk.CAN_DEFAULT)
button.grab_default()
button.show()
gui["main_window"].set_sensitive(gtk.FALSE)
gui["prefs_window"].show()
def init_dialog(self):
self.dialog = gtk.GtkWindow()
self.dialog.set_title('Tabular Shapes Attribute Grid Demo')
self.dialog.set_default_size(300, 400)
self.dialog.set_policy(gtk.FALSE, gtk.TRUE, gtk.TRUE)
shell = gtk.GtkVBox(spacing=5)
shell.set_border_width(10)
self.dialog.add(shell)
self.pgugrid = pgugrid.pguGrid(config=(3, 2, 0, 2, 4, 2, 0, 0, 0))
shell.pack_start(self.pgugrid, expand=gtk.TRUE)
hbox = gtk.GtkHBox(spacing=5)
shell.pack_start(hbox)
self.column_button = gtk.GtkCheckButton("Schema properties only")
self.column_button.connect("toggled", self.refresh_columns)
self.column_button.set_active(gtk.TRUE)
hbox.pack_start(self.column_button)
rbutton = gtk.GtkButton("Refresh columns")
rbutton.connect("clicked", self.refresh_columns)
hbox.pack_start(rbutton, expand=gtk.FALSE)
button = gtk.GtkButton("close")
button.connect("clicked", self.close)
shell.pack_start(button, expand=gtk.FALSE)
button.show()
shell.show_all()
# Trap window close event
self.dialog.connect('delete-event', self.close)
self.app.sel_manager.subscribe('active-layer-changed',
self.layer_update)
self.pgugrid.subscribe("clicked", self.clicked_cb)
self.pgugrid.connect("button-release-event", self.clicked_nocolumns_cb)
#self.pgugrid.subscribe("cell-selection-changed",self.cell_cb)
#self.pgugrid.subscribe("cell-changed",self.cellch_cb)
#self.pgugrid.subscribe("row-selection-changed",self.row_cb)
#self.pgugrid.subscribe("column-selection-changed",self.column_cb)
# Popup menus:
itemlist = [ #('Configuration',None,None),
('Set subset/Selected', self.set_subset_selected_cb, None),
('Set subset/Unseleted', self.set_subset_unselected_cb, None),
('Set subset/All', self.set_subset_all_cb, None),
('New layer/Selected', self.new_layer_selected_cb, None),
('New layer/Unselected', self.new_layer_unselected_cb, None),
('Edit Schema', self.edit_schema, None),
#('Query',None,None),
#('Save',None,None),
#('Help',None,None)
]
self.cell_popup_menu = []
self.cell_popup_menu.append(gtk.GtkMenu())
for label, func, args in itemlist:
menu_item = gtk.GtkMenuItem(label)
if func is not None:
menu_item.connect("activate", func, args)
self.cell_popup_menu[0].append(menu_item)
self.cell_popup_menu[0].show_all()
itemlist2 = [ #('Configuration',None,None),
('Set subset/Selected', self.set_subset_selected_cb, None),
('Set subset/Unseleted', self.set_subset_unselected_cb, None),
('Set subset/All', self.set_subset_all_cb, None),
('New layer/Selected', self.new_layer_selected_cb, None),
('New layer/Unselected', self.new_layer_unselected_cb, None),
('Edit Schema', self.edit_schema, None),
('Add property', self.add_property_column, None),
#('Query',None,None),
#('Save',None,None),
#('Help',None,None)
]
self.cell_popup_menu.append(gtk.GtkMenu())
for label, func, args in itemlist2:
menu_item = gtk.GtkMenuItem(label)
if func is not None:
menu_item.connect("activate", func, args)
self.cell_popup_menu[1].append(menu_item)
self.cell_popup_menu[1].show_all()
# Only do actions when grid is visible
self.active = 0
def __init__(self, classification):
"""Initialize a GvClassificationDlg on a particular GvLayer"""
gtk.GtkWindow.__init__(self)
self.set_title('Layer Classification')
self.set_usize(-1, 400)
self.connect('delete-event', self.close)
self.set_border_width(5)
self.color_buttons = []
self.sym_menus = []
self.scale_spinners = []
self.view_mgr = None
self.ranges = []
self.labels = []
self.reclassdlg = None
self.updating = FALSE
items = load_ramp_config_file()
self.ramp = None
if classification is None:
self.classification = GvClassification()
elif issubclass(classification.__class__, GvClassification):
self.classification = classification
else:
raise TypeError, 'GvClassificationDlg now requires a \
GvClassification instance'
if self.classification.count <= 0:
self.ramp = items[0]
self.classification.prepare_default()
#d = self.classification.serialize()
#main vertical box
vbox = gtk.GtkVBox(spacing=3)
save_box = gtk.GtkHButtonBox()
btn_save = gtk.GtkButton('Save ...')
btn_save.connect('clicked', self.save_cb)
btn_load = gtk.GtkButton('Load ...')
btn_load.connect('clicked', self.load_cb)
save_box.pack_start(btn_load)
save_box.pack_start(btn_save)
try:
import pgucombo
self.property_list = pgucombo.pguCombo()
except:
self.property_list = gtk.GtkCombo()
self.property_list.entry.connect('changed', self.property_select_cb)
self.update_property_list()
save_box.pack_start(self.property_list)
vbox.pack_start(save_box, expand=gtk.FALSE)
#classification frame
class_frame = gtk.GtkFrame()
frame_box = gtk.GtkVBox(spacing=3)
title_box = gtk.GtkHBox()
title_lbl = gtk.GtkLabel('Legend Title: ')
self.title_txt = gtk.GtkEntry()
self.title_txt.set_text(self.classification.get_title())
self.title_txt.connect('changed', self.title_changed_cb)
title_box.pack_start(title_lbl, expand=gtk.FALSE)
title_box.pack_start(self.title_txt)
frame_box.pack_start(title_box, expand=gtk.FALSE)
frame_box.set_border_width(5)
#classification list
class_box = gtk.GtkScrolledWindow()
self.class_list = gtk.GtkList()
self.class_list.connect('select-child', self.list_selected)
class_box.add_with_viewport(self.class_list)
frame_box.pack_start(class_box)
self.reset_classification_list()
class_frame.add(frame_box)
vbox.pack_start(class_frame)
ar_box = gtk.GtkHButtonBox()
add_btn = gtk.GtkButton('Add class')
add_btn.connect('clicked', self.add_class_cb)
classify_btn = gtk.GtkButton('reclassify ...')
classify_btn.connect('clicked', self.reclassify_cb)
reset_btn = gtk.GtkButton('Revert')
reset_btn.connect('clicked', self.reset_cb)
ar_box.pack_start(add_btn)
ar_box.pack_start(classify_btn)
ar_box.pack_start(reset_btn)
vbox.pack_start(ar_box, expand=gtk.FALSE)
#Color Ramp choices
ramp_table = gtk.GtkTable(rows=2, cols=2)
ramp_table.show()
ramp_lbl = gtk.GtkLabel('Color Ramps: ')
ramp_lbl.show()
ramp_table.attach(ramp_lbl, 0, 1, 0, 1)
ramp_opt = gtk.GtkOptionMenu()
ramp_opt.show()
self.ramp_menu = gtk.GtkMenu()
self.ramp_menu.show()
ramp_item = gtk.GtkMenuItem()
ramp_item.add(gtk.GtkHSeparator())
ramp_item.set_sensitive(gtk.FALSE)
ramp_item.show_all
self.ramp_menu.append(ramp_item)
for n in items:
ramp_item = gtk.GtkMenuItem()
ramp_item.add(n)
ramp_item.show_all()
if issubclass(n.__class__, ColorRamp):
ramp_item.connect('activate', self.ramp_cb, n)
else:
ramp_item.set_sensitive(gtk.FALSE)
self.ramp_menu.append(ramp_item)
ramp_opt.set_menu(self.ramp_menu)
ramp_opt.show()
ramp_opt.set_history(0)
ramp_table.attach(ramp_opt, 1, 2, 0, 1)
ramp_table.show_all()
vbox.pack_start(ramp_table, expand=gtk.FALSE)
#buttons
button_box = gtk.GtkHButtonBox()
#button_box.set_layout_default(gtk.BUTTONBOX_START)
self.ok_button = gtk.GtkButton('OK')
self.ok_button.connect('clicked', self.ok_cb)
self.apply_button = gtk.GtkButton('Apply')
self.apply_button.connect('clicked', self.apply_cb)
self.cancel_button = gtk.GtkButton('Cancel')
self.cancel_button.connect('clicked', self.cancel_cb)
button_box.pack_start(self.ok_button, expand=gtk.FALSE)
button_box.pack_start(self.apply_button, expand=gtk.FALSE)
button_box.pack_start(self.cancel_button, expand=gtk.FALSE)
vbox.pack_start(button_box, expand=gtk.FALSE)
vbox.show_all()
self.add(vbox)
#make ok_button a default button ? why isn't it working ?
self.ok_button.set_flags(gtk.CAN_DEFAULT)
self.ok_button.grab_default()
self.publish('classification-changed')
self.update_property_list()
