def __init__(self, echoer):
l.hide()
self.echoer = echoer
w = gtk.GtkWindow(gtk.WINDOW_TOPLEVEL)
vb = gtk.GtkVBox(); b = gtk.GtkButton("Echo:")
self.entry = gtk.GtkEntry(); self.outry = gtk.GtkEntry()
w.add(vb)
map(vb.add, [b, self.entry, self.outry])
b.connect('clicked', self.clicked)
w.connect('destroy', gtk.mainquit)
w.show_all()
def __init__(self, shapes, shapesgridtool=None):
gtk.GtkWindow.__init__(self)
self.set_title('Schema')
shell = gtk.GtkVBox(spacing=5)
shell.set_border_width(10)
self.add(shell)
self.grid = pgugrid.pguGrid(config=(2, 0, 0, 1, 4, 0, 0, 0))
self.grid.subscribe("cell-changed", self.changed_field)
self.shapes = shapes
self.shapesgridtool = shapesgridtool
shell.pack_start(self.grid)
# New field
box3 = gtk.GtkTable(rows=5, cols=3)
box3.set_row_spacings(5)
box3.set_col_spacings(5)
box3.set_border_width(10)
nf_frame = gtk.GtkFrame('Add Field')
nf_frame.add(box3)
self.new_field_name_entry = gtk.GtkEntry(10)
self.new_field_name_entry.set_text('')
self.new_field_name_entry.set_editable(gtk.TRUE)
self.new_field_width_entry = gtk.GtkEntry(2)
self.new_field_width_entry.set_text('20')
self.new_field_width_entry.set_editable(gtk.TRUE)
self.new_field_precision_entry = gtk.GtkEntry(2)
self.new_field_precision_entry.set_text('0')
self.new_field_precision_entry.set_editable(gtk.FALSE)
self.new_field_precision_entry.set_sensitive(gtk.FALSE)
self.new_field_types = ('string', 'integer', 'float')
self.new_field_type_menu = gvutils.GvOptionMenu(
self.new_field_types, self.new_field_precision_cb)
self.new_field_type_menu.set_history(0)
box3.attach(gtk.GtkLabel('Name'), 0, 1, 0, 1)
box3.attach(self.new_field_name_entry, 1, 2, 0, 1)
box3.attach(gtk.GtkLabel('Type'), 0, 1, 1, 2)
box3.attach(self.new_field_type_menu, 1, 2, 1, 2)
box3.attach(gtk.GtkLabel('Width'), 0, 1, 2, 3)
box3.attach(self.new_field_width_entry, 1, 2, 2, 3)
box3.attach(gtk.GtkLabel('Precision'), 0, 1, 3, 4)
box3.attach(self.new_field_precision_entry, 1, 2, 3, 4)
button = gtk.GtkButton("Add")
box3.attach(button, 0, 2, 4, 5)
button.connect("clicked", self.add_field)
shell.pack_start(nf_frame)
nf_frame.show_all()
# Ability to delete fields?
self.fill_grid()
self.grid.resize_to_default()
self.show_all()
def __init__(self, master, jabberObj):
gtk.GtkDialog.__init__(self)
self.jid_str = None
self.done = None
self.connect("delete_event", self.delete_event)
self.master = master
self.jabber = jabberObj
if self.master:
self.set_transient_for(self.master)
self.set_usize(200, 150)
self.table = gtk.GtkTable(5, 2, gtk.FALSE)
self.jid_lbl = gtk.GtkLabel('JID')
self.jid_entry = gtk.GtkEntry()
self.table.attach(self.jid_lbl, 0, 1, 0, 1)
self.table.attach(self.jid_entry, 1, 2, 0, 1)
self.add_button = gtk.GtkButton('Add')
self.add_button.connect('clicked', self.add)
self.action_area.pack_start(self.add_button, expand=gtk.FALSE)
self.vbox.pack_start(self.table)
self.vbox.show_all()
self.action_area.show_all()
self.show()
self.set_modal(gtk.TRUE)
def __init__(self, gui, jid, title='a tab'):
Tab.__init__(self, gui, title)
self._id = str(jid.getStripped())
self._scroll = gtk.GtkScrolledWindow()
self._txt = gtk.GtkText()
self._txt.set_word_wrap(gtk.TRUE)
self._scroll.add(self._txt)
self._scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._box.pack_start(self._scroll, fill=gtk.TRUE, expand=gtk.TRUE)
self._hbox = gtk.GtkHBox()
self._entry = gtk.GtkEntry()
self._hbox.pack_start(self._entry, fill=gtk.TRUE, expand=gtk.TRUE)
self._send_button = gtk.GtkButton('send')
#self._send_button.connect('clicked', self._cb, self)
#self._entry.connect('activate', self._cb, self )
self._hbox.pack_end(self._send_button,
fill=gtk.FALSE,
expand=gtk.FALSE)
self._box.pack_end(self._hbox, fill=gtk.TRUE, expand=gtk.FALSE)
self._box.show_all()
self._addToNoteBook()
self._entry.grab_focus()
def __init__(self):
gtk.GtkFileSelection.__init__(self)
self.set_title('Select GCP Text File')
self.connect("destroy", self.quit)
self.connect("delete_event", self.quit)
gtk.grab_add(self) # is modal
table = gtk.GtkTable(rows=8, cols=3)
self.entries = []
labels = [
'Delimiter: ', 'Pixel Column # (1-N: required): ',
'Line Column # (required): ',
'X (East/West) Column # (required): ',
'Y (North/South) Column # (required): ',
'Z (Height) Column # (optional): ', 'ID Column # (optional): ',
'Info Column # (optional): '
]
for idx in range(len(labels)):
nl = gtk.GtkLabel(labels[idx])
nl.set_alignment(0, 0.5)
self.entries.append(gtk.GtkEntry(maxlen=3))
table.attach(nl, 0, 1, idx, idx + 1)
table.attach(self.entries[idx], 1, 2, idx, idx + 1)
self.main_vbox.pack_end(table)
table.show_all()
self.cancel_button.connect('clicked', self.quit)
self.ok_button.connect('clicked', self.ok_cb)
self.ret = None
def create_geotransform_frame(self):
self.frames['Geotransform'] = gtk.GtkFrame('')
self.frames['Geotransform'].set_shadow_type(gtk.SHADOW_NONE)
vbox = gtk.GtkVBox()
vbox.set_spacing(spc)
self.frames['Geotransform'].add(vbox)
label = gtk.GtkLabel('Xgeo = GT(0) + XPixel*GT(1) + YLine*GT(2)')
label.set_alignment(0, 0.5)
vbox.pack_start(label)
label = gtk.GtkLabel('Ygeo = GT(3) + XPixel*GT(4) + YLine*GT(5)')
label.set_alignment(0, 0.5)
vbox.pack_start(label)
table = gtk.GtkTable(rows=6, cols=3)
self.geotransform_entries = []
for idx in range(6):
label = gtk.GtkLabel('GT(' + str(idx) + '):')
label.set_alignment(0, 0.5)
table.attach(label, 0, 1, idx, idx + 1)
newentry = gtk.GtkEntry()
self.geotransform_entries.append(newentry)
table.attach(newentry, 1, 2, idx, idx + 1)
vbox.pack_start(table)
self.geotransformprjbox = ProjectionBox(self.tips)
vbox.pack_start(self.geotransformprjbox)
self.frames['Geotransform'].show_all()
self.pack_start(self.frames['Geotransform'])
def init_customize_gui_panel(self):
# By now, main panel, basic frames, buttons have been created
# Middle frame (region display) must be filled in.
patch_table = gtk.GtkTable(1,4,FALSE)
self.show_list.append(patch_table)
self.frame_dict['base_frame2'].add(patch_table)
patch_table.set_border_width(5)
patch_table.set_col_spacings(5)
patch_table.set_col_spacing(1, 20)
label1 = gtk.GtkLabel('Line: ')
label1.set_alignment(0, 0.5)
patch_table.attach(label1, 0,1, 0, 1)
self.entry_dict['line'] = gtk.GtkEntry()
self.entry_dict['line'].set_editable(gtk.FALSE)
self.entry_dict['line'].set_usize(90, 25)
self.entry_dict['line'].set_text('1')
patch_table.attach(self.entry_dict['line'], 1,2, 0,1)
label2 = gtk.GtkLabel('Pixel: ')
label2.set_alignment(0, 0.5)
patch_table.attach(label2, 2,3,0, 1)
self.entry_dict['pixel'] = gtk.GtkEntry()
self.entry_dict['pixel'].set_editable(gtk.FALSE)
self.entry_dict['pixel'].set_usize(90, 25)
self.entry_dict['pixel'].set_text('1')
patch_table.attach(self.entry_dict['pixel'], 3,4, 0,1)
# Create tooltips
self.tooltips = gtk.GtkTooltips()
tip_text = "Re-enable point-of-interest selection mode (" + \
"required for this tool's operation)."
self.tooltips.set_tip(self.button_dict['Set Tool'],tip_text)
tip_text = 'Automatically update every time the point of ' + \
'interest changes.'
self.tooltips.set_tip(self.button_dict['Auto Update'],tip_text)
tip_text = 'Enable/Disable this tool.'
self.tooltips.set_tip(self.button_dict['Activate'],tip_text)
tip_text = 'Perform analysis.'
self.tooltips.set_tip(self.button_dict['Analyze'],tip_text)
self.frame_dict['base_frame2'].show_all()
def __init__(self):
gtk.GtkHBox.__init__(self, gtk.FALSE, 5)
self.entry = gtk.GtkEntry()
self.pack_start(self.entry)
self.entry.show()
self.button = gtk.GtkButton("...")
self.button.connect("clicked", self.show_dialog)
self.pack_start(self.button, expand=gtk.FALSE)
self.button.show()
self.dialog = gtk.GtkDialog()
self.dialog.set_title(self.get_title())
def delete_event(win, event):
win.hide()
return gtk.TRUE
self.dialog.connect("delete_event", delete_event)
box = gtk.GtkVBox()
box.set_border_width(5)
self.dialog.vbox.pack_start(box)
box.show()
swin = gtk.GtkScrolledWindow()
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
box.pack_start(swin)
swin.show()
items = map(None, self.get_list())
list = gtk.GtkList()
list.set_selection_mode(gtk.SELECTION_BROWSE)
self.selected = self.get_default()
self.entry.set_text(self.selected)
items.sort()
for s in items:
item = gtk.GtkListItem(s)
list.add(item)
if s == self.selected:
list.select_child(item)
item.show()
swin.add_with_viewport(list)
list.show()
b = gtk.GtkButton("OK")
self.dialog.action_area.pack_start(b)
b.set_flags(gtk.CAN_DEFAULT)
b.grab_default()
b.show()
b.connect("clicked", self.selection_ok, list)
b = gtk.GtkButton("Cancel")
self.dialog.action_area.pack_start(b)
b.set_flags(gtk.CAN_DEFAULT)
b.show()
b.connect("clicked", self.dialog.hide)
self.dialog.set_usize(300, 225)
def __init__(self, strings=[""]):
"""Initialize the combo box, default strings can be passed.
"""
GtkComboBox.__init__(self)
self.items = strings
self.current_item = 0
#widgets to go into the combo box
self.list = gtk.GtkCList(cols=1)
self.list.set_selection_mode(gtk.SELECTION_SINGLE)
self.entry = gtk.GtkEntry()
self.entry.set_editable(gtk.FALSE)
#fix up the style of the entry
#style = self.entry.get_style().copy()
#fake a background color the same as the button widget
#for i in range(5):
# style.base[i] = self.button.get_style().bg[i]
#self.entry.set_style( style )
self._scrolled_win = gtk.GtkScrolledWindow()
self._scrolled_win.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self._scrolled_win.add(self.list)
#################################
#
# TODO: figure out how to resize this on the fly
#
#################################
self._scrolled_win.set_usize(150, 175)
self._scrolled_win.show_all()
#frame is the popdown window frame
self.frame.add(self._scrolled_win)
#button is the main area to the left of the dropdown arrow
self.button.add(self.entry)
#initialize the widgets
self.set_popdown_strings(self.items)
self.select_item(self.current_item)
#connect up signals
self.list.connect('select-row', self.list_row_selected)
self.list.add_events(gtk.GDK.KEY_PRESS_MASK)
self.list.connect('key-press-event', self.key_press_cb)
self.arrow.connect('toggled', self.toggle_cb)
#make sure they all get shown
self.show_all()
def __init__(self, master, jabber, agent=None):
gtk.GtkWindow.__init__(self)
self.connect("delete_event", self.delete_event)
self.master = master
self.jabber = jabber
self.done = None
self.agent = agent
self.vbox = gtk.GtkVBox(gtk.FALSE, 5)
self.add(self.vbox)
self.frame = gtk.GtkFrame("New Account")
self.jabber.requestRegInfo(self.agent)
req = self.jabber.getRegInfo()
self.table = gtk.GtkTable(6, 6, gtk.FALSE)
self.instr_lbl = gtk.GtkLabel(req[u'instructions'])
self.entrys = {}
i = 0
for info in req.keys():
if info != u'instructions' and \
info != u'key':
self.entrys[info] = {}
self.entrys[info]['lbl'] = gtk.GtkLabel(info)
self.entrys[info]['lbl'].set_alignment(1, 0.5)
self.entrys[info]['entry'] = gtk.GtkEntry()
self.table.attach(self.entrys[info]['lbl'],
0,
2,
1 + i,
2 + i,
xpadding=3,
ypadding=2)
self.table.attach(self.entrys[info]['entry'],
2,
6,
1 + i,
2 + i,
xpadding=3,
ypadding=2)
i = i + 1
self.reg_button = gtk.GtkButton('Register')
self.table.attach(self.reg_button, 2, 6, 0, 1, xpadding=3, ypadding=2)
self.reg_button.connect('clicked', self.register)
self.frame.add(self.table)
self.vbox.pack_start(self.frame)
self.vbox.show_all()
self.show()
self.set_modal(gtk.TRUE)
def update_list(self):
self.widget.list.clear()
i = 0
for purge in sqmail.purges.enumerate():
purge = sqmail.purges.Purge(purge)
self.widget.list.append(("", "", "", ""))
self.widget.list.set_row_data(i, purge)
w = gtk.GtkEntry()
self.describe_purge(i)
i = i + 1
def __init__(self, im, desc):
gtk.GtkWindow.__init__(self, gtk.WINDOW_TOPLEVEL)
self.set_title(desc)
self.im = im
button = cbutton(desc, self.clicked)
self.entry = gtk.GtkEntry()
self.entry.connect('activate', self.clicked)
hb = gtk.GtkHBox()
hb.add(self.entry)
hb.add(button)
self.add(hb)
self.show_all()
def __init__(self):
#print self.send_
gtk.GtkWindow.__init__(self, gtk.WINDOW_TOPLEVEL)
self.set_title("Reality Faucet")
self.set_usize(640, 480)
self.namelabel = gtk.GtkLabel("NameLabel")
self.descbox = gtk.GtkText()
self.descbox.set_usize(370, 255)
self.descbox.set_word_wrap(gtk.TRUE)
self.descscrl = gtkutil.scrollify(self.descbox)
gtkutil.defocusify(self.descbox)
self.itembox = gtk.GtkText()
self.itembox.set_word_wrap(gtk.TRUE)
self.itemscrl = gtkutil.scrollify(self.itembox)
gtkutil.defocusify(self.itembox)
self.happenings = gtk.GtkText()
self.happenings.set_word_wrap(gtk.TRUE)
self.happscrl = gtkutil.scrollify(self.happenings)
gtkutil.defocusify(self.happenings)
self.cmdarea = gtk.GtkEntry()
self.hpaned = gtk.GtkHPaned()
self.hpaned.add1(self.descscrl)
self.hpaned.add2(self.itemscrl)
self.vpaned = gtk.GtkVPaned()
self.vpaned.add1(self.hpaned)
self.vpaned.add2(self.happscrl)
self.vbox = gtk.GtkVBox()
self.vbox.pack_start(self.namelabel, expand=0)
self.vbox.add(self.vpaned)
self.vbox.pack_start(self.cmdarea, expand=0)
self.add(self.vbox)
self.signal_connect('destroy', gtk.mainquit, None)
self.cmdarea.connect("key_press_event", self.processKey)
self.cmdarea.grab_focus()
self.history = ['']
self.descriptions = {}
self.items = {}
self.exits = []
def __init__(self):
gtk.GtkWindow.__init__(self)
self.set_title("Test TextArea")
vbox = gtk.GtkVBox()
self.text = pguTextArea()
self.entry = gtk.GtkEntry()
self.button = gtk.GtkButton("insert")
self.button.connect("clicked", self.insert_text)
vbox.pack_start(self.text)
vbox.pack_start(self.entry, expand=gtk.FALSE)
vbox.pack_start(self.button, expand=gtk.FALSE)
self.add(vbox)
self.show_all()
def mk_wnd(self, title):
wnd = gtk.GtkWindow()
wnd.set_title(title)
self.box = gtk.GtkVBox()
self.textbox = gtk.GtkHBox()
e = gtk.GtkEntry()
self.textentry = e
e.show()
self.textbox.pack_start(e)
b = gtk.GtkButton('Lookup')
def looker(button):
self.lookup('', e.get_text())
b.connect('released', looker)
b.show()
self.textbox.pack_start(b)
self.textbox.show()
self.box.pack_start(self.textbox)
def mk_sel_changed(fn):
def sel_changed(l, fn=fn):
sel = l.get_selection()
if len(sel) > 0:
s = sel[0].children()[0].get()
(typ, val) = split_tv(s)
fn(typ, val)
return sel_changed
def make_lb(text, fn, box):
lb = gtk.GtkList()
lb.show()
frame = gtk.GtkFrame(text)
frame.add(lb)
frame.show()
box.pack_start(frame)
lb.connect('selection-changed', fn)
return lb
self.lb_head = make_lb('Head terms', mk_sel_changed(self.set_head),
self.box)
self.lb_rel = make_lb('Relations', mk_sel_changed(self.lookup),
self.box)
self.box.show()
wnd.add(self.box)
wnd.show()
return wnd
def __init__(self):
gtk.GtkWindow.__init__(self)
self.set_title("Test ShapesGrid")
vbox = gtk.GtkVBox()
self.grid = pguShapesGrid()
self.grid.set_usize(300, 300)
self.entry = gtk.GtkEntry()
self.button = gtk.GtkButton("set shapes file")
self.button.connect("clicked", self.set_shapes)
vbox.pack_start(self.grid)
vbox.pack_start(self.entry, expand=gtk.FALSE)
vbox.pack_start(self.button, expand=gtk.FALSE)
self.add(vbox)
self.show_all()
def __init__(self, im, contact):
gtk.GtkWindow.__init__(self, gtk.WINDOW_TOPLEVEL)
self.im = im
self.contact = contact
self.set_title("%s - Instance Messenger" % contact)
self.text = gtk.GtkText()
vb = gtk.GtkVBox()
gtkutil.defocusify(self.text)
self.text.set_word_wrap(gtk.TRUE)
vb.pack_start(gtkutil.scrollify(self.text), 1, 1, 0)
self.entry = gtk.GtkEntry()
self.entry.signal_connect('activate', self.sendMessage)
vb.pack_start(self.entry, 0, 0, 0)
self.add(vb)
self.signal_connect('destroy', self.removeFromList, None)
self.show_all()
def about_window():
win = gtk.GtkWindow()
gui["about_window"] = win
win.set_policy(gtk.TRUE, gtk.TRUE, gtk.FALSE)
win.set_title("About")
win.connect("delete_event", about_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)
label = gtk.GtkLabel("\n\n" + "Clarence (programmer's calculator)\n"
"\nversion " + version + "\n\n"
"Written by Tomasz Maka <*****@*****.**>\n")
set_font(label)
label.show()
vbox.pack_start(label)
entry = gtk.GtkEntry()
gui["http_entry"] = entry
entry.set_editable(gtk.FALSE)
entry.set_usize(290, -2)
set_font(entry)
entry.show()
vbox.pack_start(entry)
entry.set_text("http://clay.ll.pl/clarence.html")
button = gtk.GtkButton("OK")
button.connect("clicked", about_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["about_window"].show()
def __init__(self):
gtk.GtkDialog.__init__(self)
self.jid_str = None
self.done = None
self.type = 'available'
self.connect("delete_event", self.delete_event)
#self.master = master
#self.jabber = jabberObj
self.set_usize(200, 150)
self.table = gtk.GtkTable(5, 2, gtk.FALSE)
self.jid_lbl = gtk.GtkLabel('Status')
self.jid_entry = gtk.GtkEntry()
self.table.attach(self.jid_lbl, 0, 1, 0, 1)
self.table.attach(self.jid_entry, 1, 2, 0, 1)
self.add_button = gtk.GtkButton('Set')
self.add_button.connect('clicked', self.set)
self.action_area.pack_start(self.add_button, expand=gtk.FALSE)
self.avail_radio = gtk.GtkRadioButton(None, 'available')
self.unavail_radio = gtk.GtkRadioButton(self.avail_radio,
'unavailable')
self.avail_radio.connect('clicked', self.avail)
self.unavail_radio.connect('clicked', self.unavail)
self.avail_radio.set_active(gtk.TRUE)
self.table.attach(self.avail_radio, 0, 2, 1, 2)
self.table.attach(self.unavail_radio, 0, 2, 2, 3)
self.vbox.pack_start(self.table)
self.vbox.show_all()
self.action_area.show_all()
self.show()
self.set_modal(gtk.TRUE)
def __init__(self, groupName, im):
self.groupName = groupName
self.im = im
self.history = ['']
self.histpos = 0
gtk.GtkWindow.__init__(self, gtk.WINDOW_TOPLEVEL)
self.set_title("%s - Instance Messenger" % groupName)
self.connect('destroy', self.leaveGroup)
vb = gtk.GtkVBox()
hb = gtk.GtkHBox()
self.output = gtk.GtkText()
self.output.set_word_wrap(gtk.TRUE)
gtkutil.defocusify(self.output)
hb.pack_start(gtkutil.scrollify(self.output), 1, 1, 1)
userlist = gtk.GtkCList(1, ["Users"])
userlist.set_shadow_type(gtk.SHADOW_OUT)
gtkutil.defocusify(userlist)
hb.pack_start(gtkutil.scrollify(userlist), gtk.TRUE, gtk.TRUE, 0)
# print self.im.remote.groups
# for group in self.im.remote.groups:
# if group.name == groupName:
# for member in group.members:
# userlist.append_items([member.name])
self.userlist = userlist
vb.pack_start(hb, 1, 1, 1)
self.input = gtk.GtkEntry()
vb.pack_start(self.input, 0, 0, 1)
#took this out so I can check in and not be broken
#self.input.connect('key_press_event', self.processKey)
self.input.connect('activate', self.sendMessage)
self.add(vb)
self.show_all()
def __init__(self, default=""):
gtk.GtkHBox.__init__(self, gtk.FALSE, 5)
self.entry = gtk.GtkEntry()
self.pack_start(self.entry)
self.entry.show()
self.button = gtk.GtkButton("...")
self.button.connect("clicked", self.show_dialog)
self.pack_start(self.button, expand=gtk.FALSE)
self.button.show()
self.dialog = gtk.GtkFileSelection("Fonts")
self.dialog.set_default_size(400, 300)
def delete_event(win, event):
win.hide()
return gtk.TRUE
self.dialog.connect("delete_event", delete_event)
self.dialog.ok_button.connect("clicked", self.selection_ok)
self.dialog.cancel_button.connect("clicked", self.dialog.hide)
self.dialog.set_filename(default)
self.selected = self.dialog.get_filename()
self.entry.set_text(self.selected)
def __init__(self, editable=1):
self._editable = editable
if self._editable == 1:
gtk.GtkTable.__init__(self, rows=3, cols=2)
else:
gtk.GtkTable.__init__(self, rows=2, cols=2)
self.hadj = gtk.GtkAdjustment()
self.vadj = gtk.GtkAdjustment()
self._hscroll = gtk.GtkHScrollbar(adj=self.hadj)
self._vscroll = gtk.GtkVScrollbar(adj=self.vadj)
self._area = gtk.GtkDrawingArea()
self._pixmap = None
#this mask also seems to enable scrolling???
evt_mask = gtk.GDK.BUTTON_PRESS_MASK | gtk.GDK.BUTTON_RELEASE_MASK | \
gtk.GDK.KEY_PRESS_MASK | gtk.GDK.KEY_RELEASE_MASK
self._area.set_events(evt_mask)
if self._editable == 1:
self._entry = gtk.GtkEntry()
self._entry.set_sensitive(gtk.FALSE)
self._entry.connect('changed', self.entry_changed)
#the data source
self.source = None
self.source_changed_id = None
self.subset = []
# indices/info for sorting (indices maps source index to nRow; inv_indices
# maps nRow to source index, and similar for subindices).
self.indices = None
self.inv_indices = None
self.subindices = None
self.inv_subindices = None
self.sort_reverse = 0
#string values to use as titles
self.titles = []
#fonts for drawing titles and cells put here
self.title_font = None
self.cell_font = None
#the overall size of the data set
self.n_rows = 0
self.n_cols = 0
#the height of a single row and title row
self.row_height = 0
self.title_height = 0
#the row/col to put in the top left corner
self.start_row = 0
self.start_col = 0
#the current row/col selected (when we support clicking :)
self.current_row = 0 # current row in display widget coordinates
self.current_row_src = -1 # current row in source coordinates (source index)
self.current_col = 0
self.col_widths = []
#the number of pixels around each cell
self.cell_half = 4
self.cell_full = (self.cell_half) * 2 + 1
self.max_width = 0
self.max_height = 0
#flag to recalculate the adjustments
self.bCalcAdjustments = gtk.TRUE
# list of indices of currently selected shapes (NOT the same as the
# currently editable cell)
self.selected_shapes = None
#set to true if changing some value that would end up causing multiple
#expose events or an endless loop even.
self.updating = gtk.FALSE
frm = gtk.GtkFrame()
frm.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
frm.add(self._area)
if self._editable == 1:
self.attach(self._entry,
0,
1,
0,
1,
xoptions=gtk.FILL,
yoptions=gtk.SHRINK)
self.attach(frm, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=gtk.FILL)
self.attach(self._vscroll, 1, 2, 1, 2, xoptions=gtk.SHRINK)
self.attach(self._hscroll, 0, 1, 2, 3, yoptions=gtk.SHRINK)
else:
self.attach(frm, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=gtk.FILL)
self.attach(self._vscroll, 1, 2, 0, 1, xoptions=gtk.SHRINK)
self.attach(self._hscroll, 0, 1, 1, 2, yoptions=gtk.SHRINK)
self.show_all()
# signals: Note that the right-click (button 3) event
# is a special case used internally to select cells for
# editing.
self.publish('clicked-selected-row')
self.publish('clicked-unselected-row')
self.publish('title-clicked')
self._area.connect('expose-event', self.expose)
self._area.connect('configure-event', self.configure)
self._area.connect('button-press-event', self.click)
self.hadj.connect('value-changed', self.changed)
self.vadj.connect('value-changed', self.changed)
self.connect('style-set', self.expose)
def init_dialog(self):
self.dialog = gtk.GtkWindow()
self.dialog.set_title('Available Image Formats')
self.dialog.set_usize(300, 500)
self.dialog.set_border_width(10)
self.dialog.set_policy(gtk.FALSE, gtk.TRUE, gtk.TRUE)
self.tooltips = gtk.GtkTooltips()
self.button_dict = {}
# main shell
mainshell = gtk.GtkVBox(spacing=1, homogeneous=gtk.FALSE)
self.dialog.add(mainshell)
self.show_list = []
self.show_list.append(mainshell)
#frame1=gtk.GtkFrame('Supported')
#self.show_list.append(frame1)
#mainshell.pack_start(frame1,expand=gtk.FALSE)
#num_s=len(self.supported_list)
#if num_s > 0:
# s_table = gtk.GtkTable(num_s,3)
# row=0
# for fmt_list in self.supported_list:
# clabel=gtk.GtkEntry()
# clabel.set_editable(gtk.FALSE)
# clabel.set_text(fmt_list[0])
# self.show_list.append(clabel)
# self._make_tooltip(clabel,fmt_list)
# s_table.attach(clabel,0,1,row,row+1)
# if fmt_list[4] is not None:
# self.button_dict[fmt_list[1]]=gtk.GtkButton('Help')
# self.button_dict[fmt_list[1]].connect('clicked',self.help_clicked_cb,fmt_list[4])
# s_table.attach(self.button_dict[fmt_list[1]],1,2,row,row+1)
# row=row+1
# frame1.add(s_table)
# self.show_list.append(s_table)
num_us = len(self.unsupported_list)
frame2 = gtk.GtkFrame()
pixel_scroll = gtk.GtkScrolledWindow()
self.show_list.append(pixel_scroll)
self.show_list.append(frame2)
mainshell.pack_start(frame2)
frame2.add(pixel_scroll)
num_us = len(self.unsupported_list)
if num_us > 0:
us_table = gtk.GtkTable(num_us, 3)
row = 0
for fmt_list in self.unsupported_list:
clabel = gtk.GtkEntry()
clabel.set_editable(gtk.FALSE)
clabel.set_text(fmt_list[0])
self.show_list.append(clabel)
self._make_tooltip(clabel, fmt_list)
us_table.attach(clabel, 0, 1, row, row + 1)
if fmt_list[4] is not None:
self.button_dict[fmt_list[1]] = gtk.GtkButton('Help')
self.button_dict[fmt_list[1]].connect(
'clicked', self.help_clicked_cb, fmt_list[4])
us_table.attach(self.button_dict[fmt_list[1]], 1, 2, row,
row + 1)
row = row + 1
pixel_scroll.add_with_viewport(us_table)
self.show_list.append(us_table)
self.button_dict['close'] = gtk.GtkButton('Close')
self.button_dict['close'].connect('clicked', self.close)
mainshell.pack_start(self.button_dict['close'], expand=gtk.FALSE)
self.show_list.append(self.button_dict['close'])
self.dialog.connect('delete-event', self.close)
for item in self.show_list:
item.show()
def create_main_window(*args):
win = gtk.GtkWindow()
gui["main_window"] = win
win.set_policy(gtk.TRUE, gtk.TRUE, gtk.FALSE)
win.set_title("Clarence " + version)
win.set_usize(hive.get_integer("/window/width", default_win_width),
hive.get_integer("/window/height", default_win_height))
win.connect("delete_event", gtk.mainquit)
window_pos_mode(win)
vbox1 = gtk.GtkVBox(spacing=5)
win.add(vbox1)
vbox1.show()
ag = gtk.GtkAccelGroup()
itemf = gtk.GtkItemFactory(gtk.GtkMenuBar, "<main>", ag)
gui["main_window"].add_accel_group(ag)
itemf.create_items([
('/_Misc', None, None, 0, '<Branch>'),
('/_Misc/_Clear', 'Escape', main_menu, 1, ''),
('/_Misc/sep1', None, None, 0, '<Separator>'),
('/_Misc/Pre_ferences', '<control>P', main_menu, 3, ''),
('/_Misc/sep1', None, None, 0, '<Separator>'),
('/_Misc/E_xit', '<alt>X', main_menu, 2, ''),
('/_Insert', None, None, 0, '<Branch>'),
('/_Insert/_Bin value', '<control>comma', insert_menu, 1, ''),
('/_Insert/_ASCII chars', '<control>period', insert_menu, 2, ''),
('/_Insert/_Last result', '<control>slash', insert_menu, 3, ''),
('/_Select', None, None, 0, '<Branch>'),
('/_Select/_Decimal field', '<control>1', select_menu, 1, ''),
('/_Select/_Hexadecimal field', '<control>2', select_menu, 2, ''),
('/_Select/_Octal field', '<control>3', select_menu, 3, ''),
('/_Select/_ASCII field', '<control>4', select_menu, 4, ''),
('/_Select/_Binary field', '<control>5', select_menu, 5, ''),
('/_Select/sep1', None, None, 0, '<Separator>'),
('/_Select/_Clear fields', '<control>0', select_menu, 6, ''),
('/_Help', None, None, 0, '<LastBranch>'),
('/_Help/Functions list', 'F1', functions_help_window, 1, ''),
('/_Help/sep1', None, None, 0, '<Separator>'),
('/_Help/_About', '<control>I', help_menu, 1, '')
])
menubar = itemf.get_widget('<main>')
if (gui["disable_menu"] == 0):
vbox1.pack_start(menubar, expand=gtk.FALSE)
menubar.show()
vbox2 = gtk.GtkVBox(spacing=5)
vbox1.pack_start(vbox2, expand=gtk.TRUE)
vbox2.show()
entry = gtk.GtkEntry()
gui["main_entry"] = entry
vbox2.pack_start(entry, expand=gtk.FALSE)
vbox2.set_border_width(4)
set_font(entry)
if hive.get_bool("/remember_expression", default_remember_expression):
entry.set_text(
hive.get_string("/last_expression", default_last_expression))
entry.connect("key_press_event", key_function)
entry.grab_focus()
gui["main_entry"].show()
frame = gtk.GtkFrame()
vbox2.pack_start(frame)
frame.show()
vbox3 = gtk.GtkVBox()
frame.add(vbox3)
vbox3.show()
table = gtk.GtkTable(2, 5, gtk.FALSE)
table.set_row_spacings(5)
table.set_col_spacings(5)
table.set_border_width(10)
vbox3.pack_start(table)
table.show()
for y in range(5):
label = gtk.GtkLabel(labels[y])
set_font(label)
label.show()
table.attach(label, 0, 1, y, y + 1)
entry = gtk.GtkEntry()
gui[entries[y]] = entry
entry.set_editable(gtk.FALSE)
entry.set_usize(260, -2)
set_font(entry)
entry.show()
table.attach(entry, 1, 2, y, y + 1)
gui["main_window"].show()
if hive.get_string("/remember_expression", default_remember_expression):
result(hive.get_string("/last_expression", default_last_expression))
else:
result(0)
def __init__(self,
callback,
referenceable=None,
initialUser="******",
initialPassword="******",
initialHostname="localhost",
initialPortno=str(pb.portno),
initialService="",
initialPerspective=""):
gtk.GtkWindow.__init__(self, gtk.WINDOW_TOPLEVEL)
version_label = gtk.GtkLabel("Twisted v%s" % copyright.version)
self.pbReferenceable = referenceable
self.pbCallback = callback
# version_label.show()
self.username = gtk.GtkEntry()
self.password = gtk.GtkEntry()
self.service = gtk.GtkEntry()
self.perspective = gtk.GtkEntry()
self.hostname = gtk.GtkEntry()
self.port = gtk.GtkEntry()
self.password.set_visibility(gtk.FALSE)
self.username.set_text(initialUser)
self.password.set_text(initialPassword)
self.service.set_text(initialService)
self.perspective.set_text(initialPerspective)
self.hostname.set_text(initialHostname)
self.port.set_text(str(initialPortno))
userlbl = gtk.GtkLabel("Username:"******"Password:"******"Service:")
perspeclbl = gtk.GtkLabel("Perspective:")
hostlbl = gtk.GtkLabel("Hostname:")
portlbl = gtk.GtkLabel("Port #:")
self.allLabels = [
userlbl, passlbl, servicelbl, perspeclbl, hostlbl, portlbl
]
self.logstat = gtk.GtkLabel("Protocol PB-%s" % pb.Broker.version)
self.okbutton = cbutton("Log In", self.login)
self.okbutton["can_default"] = 1
self.okbutton["receives_default"] = 1
okbtnbx = gtk.GtkHButtonBox()
okbtnbx.add(self.okbutton)
vbox = gtk.GtkVBox()
vbox.add(version_label)
table = gtk.GtkTable(2, 6)
row = 0
for label, entry in [(userlbl, self.username),
(passlbl, self.password),
(hostlbl, self.hostname),
(servicelbl, self.service),
(perspeclbl, self.perspective),
(portlbl, self.port)]:
table.attach(label, 0, 1, row, row + 1)
table.attach(entry, 1, 2, row, row + 1)
row = row + 1
vbox.add(table)
vbox.add(self.logstat)
vbox.add(okbtnbx)
self.add(vbox)
self.username.grab_focus()
self.okbutton.grab_default()
for fld in self.username, self.password, self.hostname, self.service, self.perspective:
fld.signal_connect('activate', self.login)
fld.signal_connect('focus_in_event', selectAll)
self.signal_connect('destroy', gtk.mainquit, None)
def __init__(self, title=None, cwd=None, dialog_type=FILE_OPEN, filter=None, app=None, multiselect=0):
gtk.GtkWindow.__init__(self)
if dialog_type >= FILE_OPEN and dialog_type <= DIRECTORY_SELECT:
self.dialog_type = dialog_type
else:
self.dialog_type = FILE_OPEN
self.filter = None #current filter
self.filters = {} #active filter objects
self.filter_keys = [] #ordered list of the names of the filters
self.file_selection = []
self.multiselect = multiselect
self.set_border_width(5)
self.set_policy(as=gtk.FALSE, ag=gtk.FALSE, autos=gtk.TRUE)
self.drives = None
if title == None:
if dialog_type == FILE_OPEN:
title = nls.get('filedlg-title-open-file', 'Open File ...')
elif dialog_type == FILE_SAVE:
title = nls.get('filedlg-title-save-file', 'Save File ...')
elif dialog_type == DIRECTORY_SELECT:
title = nls.get('filedlg-title-select-directory', 'Select Directory ...')
self.set_title(title)
#setup the current working directory
if cwd is None or not os.path.exists(cwd):
cwd = gview.get_preference('working-directory')
if cwd is None:
cwd = os.getcwd()
self.cwd = cwd
#widgets
vbox = gtk.GtkVBox(spacing=5)
if dialog_type == FILE_OPEN or dialog_type == DIRECTORY_SELECT:
lbl = gtk.GtkLabel(nls.get('filedlg-label-open-from', 'Open From:'))
elif dialog_type == FILE_SAVE:
lbl = gtk.GtkLabel(nls.get('filedlg-label-save-in', 'Save In:'))
self.opt_menu = gtk.GtkOptionMenu()
self.opt_menu.set_menu(gtk.GtkMenu())
hbox = gtk.GtkHBox()
hbox.pack_start(lbl, expand=gtk.FALSE)
hbox.pack_start(self.opt_menu)
vbox.pack_start(hbox, expand = gtk.FALSE)
self.list_directory = gtk.GtkCList()
scr_directories = gtk.GtkScrolledWindow()
scr_directories.add(self.list_directory)
self.list_directory.connect('button-press-event', self.directory_selected_cb)
if dialog_type == DIRECTORY_SELECT:
self.list_files = None
vbox.pack_start(scr_directories)
else:
self.list_files = gtk.GtkCList()
if self.multiselect:
self.list_files.set_selection_mode( gtk.SELECTION_EXTENDED )
scr_files = gtk.GtkScrolledWindow()
scr_files.add(self.list_files)
self.list_files.connect('button-press-event', self.file_clicked_cb)
self.list_files.connect('select-row', self.file_selected_cb )
self.list_files.connect('unselect-row', self.file_unselected_cb )
pane = gtk.GtkHPaned()
scr_directories.set_usize(100, -1)
scr_files.set_usize(100, -1)
pane.add1(scr_directories)
pane.add2(scr_files)
pane.set_position(200)
vbox.pack_start(pane)
widget = None
if dialog_type == FILE_SAVE:
self.txt_filename = gtk.GtkEntry()
widget = self.txt_filename
elif dialog_type == FILE_OPEN:
combo = gtk.GtkCombo()
combo.set_value_in_list(gtk.FALSE, gtk.FALSE)
combo.disable_activate()
if app is not None:
rfl = app.get_rfl()
rfl.insert(0, '')
combo.set_popdown_strings( rfl )
self.txt_filename = combo.entry
widget = combo
if widget is not None:
table = gtk.GtkTable(rows=2, cols=2)
lbl = gtk.GtkLabel(nls.get('filedlg-label-file-name', 'File Name:'))
self.txt_filename.connect('focus-out-event', self.map_path_cb)
self.txt_filename.connect('key-press-event', self.map_path_cb)
table.attach(lbl, 0, 1, 0, 1)
table.attach(widget, 1, 2, 0, 1)
lbl = gtk.GtkLabel(nls.get('filedlg-label-filter-extension', 'Filter extension:'))
self.cmb_filter = pguCombo()
self.set_filter(filter)
self.cmb_filter.entry.connect('changed', self.filter_cb)
table.attach(lbl, 0, 1, 1, 2)
table.attach(self.cmb_filter, 1, 2, 1, 2)
vbox.pack_start(table, expand=gtk.FALSE)
if dialog_type == FILE_SAVE:
self.ok_button = gtk.GtkButton(nls.get('filedlg-button-ok', 'OK'))
elif dialog_type == FILE_OPEN:
self.ok_button = gtk.GtkButton(nls.get('filedlg-button-open', 'Open'))
elif dialog_type == DIRECTORY_SELECT:
self.ok_button = gtk.GtkButton(nls.get('filedlg-button-ok', 'OK'))
self.cancel_button = gtk.GtkButton(nls.get('filedlg-button-cancel', 'Cancel'))
self.ok_button.connect('clicked', self.remove_grab)
self.ok_button.connect('clicked', self.update_cwd)
self.cancel_button.connect('clicked', self.remove_grab)
btn_box = gtk.GtkHButtonBox()
btn_box.pack_start(self.ok_button)
btn_box.pack_start(self.cancel_button)
vbox.pack_start(btn_box, expand=gtk.FALSE)
self.add(vbox)
self.show_all()
#make modal
gtk.grab_add(self)
self.ok_button.set_flags(gtk.CAN_DEFAULT)
self.ok_button.grab_default()
self.set_usize(400, 400)
self.menu_update = gtk.FALSE
while gtk.events_pending():
gtk.mainiteration(FALSE)
self.refresh_directory()
self.connect('delete-event', self.quit)
self.ok_button.connect('clicked', self.quit)
self.cancel_button.connect('clicked', self.quit)
self.publish('quit')
self.add_events(gtk.GDK.KEY_PRESS_MASK)
self.connect('key-press-event', self.key_press_cb)
self.result = 'cancel'
def showgui_cb(self, *args):
if self.dialog is None:
self.dialog = gtk.GtkWindow()
self.dialog.connect('delete-event', self.close)
table = gtk.GtkTable(9, 4)
table.set_border_width(10)
table.set_row_spacings(10)
table.set_col_spacings(10)
vbox = gtk.GtkVBox()
self.dialog.add(vbox)
vbox.pack_start(table)
iconbar = gtk.GtkToolbar(gtk.ORIENTATION_HORIZONTAL,
gtk.TOOLBAR_ICONS)
arrows = []
atypes = [
gtk.ARROW_LEFT, gtk.ARROW_UP, gtk.ARROW_DOWN, gtk.ARROW_RIGHT
]
cbs = [
self.rewind_cb, self.speed_up_cb, self.speed_down_cb,
self.play_cb
]
for atype, cb in map(None, atypes, cbs):
arr = gtk.GtkButton()
arr.set_border_width(0)
arr.set_relief(gtk.RELIEF_NONE)
arr.add(gtk.GtkArrow(atype))
arr.connect('clicked', cb)
arrows.append(arr)
vbox = gtk.GtkVBox(spacing=0, homogeneous=gtk.FALSE)
vbox.pack_start(arrows[1], expand=gtk.FALSE)
vbox.pack_start(arrows[2], expand=gtk.FALSE)
# Now put them in the toolbar
iconbar.append_widget(arrows[0], 'Rewind', 'Rewind')
iconbar.append_widget(vbox, 'Adjust speed', 'Adjust speed')
iconbar.append_widget(arrows[3], 'Play', 'Play')
table.attach(iconbar, 0, 1, 0, 1)
but = gtk.GtkButton('Stop')
table.attach(but, 1, 2, 0, 1)
but.connect('clicked', self.stop_pan_cb)
but = gtk.GtkButton('Pause')
table.attach(but, 2, 3, 0, 1)
but.connect('clicked', self.pause_pan_cb)
label = gtk.GtkLabel('Block Size Mode:')
label.set_alignment(0, 0.5)
table.attach(label, 0, 1, 1, 2)
self.block_size_menu = gvutils.GvOptionMenu(
('Relative to Pan Extents', 'View Coordinates',
'Constant Resolution'), self.block_mode_changed)
table.attach(self.block_size_menu, 1, 3, 1, 2)
self.block_label_list = [
'Block x size (0-1):', 'Block x size:', 'View units/Pixel:'
]
self.block_label = gtk.GtkLabel(self.block_label_list[0])
self.block_label.set_alignment(0, 0.5)
table.attach(self.block_label, 0, 1, 2, 3)
self.block_entry = gtk.GtkEntry()
self.block_entry.set_editable(gtk.TRUE)
self.block_entry.set_text('0.125')
self.block_entry.connect('leave-notify-event',
self.block_size_changed)
table.attach(self.block_entry, 1, 3, 2, 3)
label = gtk.GtkLabel('Overlap (0-1):')
label.set_alignment(0, 0.5)
table.attach(label, 0, 1, 3, 4)
self.overlap_entry = gtk.GtkEntry()
self.overlap_entry.set_editable(gtk.TRUE)
self.overlap_entry.set_text('0.1')
self.overlap_entry.connect('leave-notify-event',
self.overlap_changed)
table.attach(self.overlap_entry, 1, 3, 3, 4)
label = gtk.GtkLabel('Path type:')
label.set_alignment(0, 0.5)
table.attach(label, 0, 1, 4, 5)
self.path_menu = gvutils.GvOptionMenu(('0', '1', '2', '3', '4'),
self.path_changed)
table.attach(self.path_menu, 1, 3, 4, 5)
label = gtk.GtkLabel('Show trail:')
label.set_alignment(0, 0.5)
table.attach(label, 0, 1, 5, 6)
self.trail_menu = gvutils.GvOptionMenu(('No', 'Yes'),
self.trail_changed)
table.attach(self.trail_menu, 1, 2, 5, 6)
button = gtk.GtkButton('Clear Trail')
table.attach(button, 2, 3, 5, 6)
button.connect('clicked', self.clear_trail)
label = gtk.GtkLabel('Trail Color:')
label.set_alignment(0, 0.5)
table.attach(label, 0, 1, 6, 7)
self.trail_color = pgucolorsel.ColorControl(
'Trail Color', self.trail_color_cb)
table.attach(self.trail_color, 1, 3, 6, 7)
self.trail_color.set_color((1.0, 0.75, 0.0, 0.5))
self.second_view = gview.GvViewArea()
self.second_view.set_usize(300, 300)
table.attach(self.second_view, 0, 3, 7, 8)
self.dialog.show_all()
self.dialog.connect('delete-event', self.close)
self.viewtitle = args[1]
self.dialog.show()
self.dialog.get_window()._raise()
def __init__(self, master):
gtk.GtkWindow.__init__(self)
self.password = ''
self.username = ''
self.server = 'jabber.org'
self.done = None
self.connect("delete_event", self.delete_event)
self.master = master
self.vbox = gtk.GtkVBox(gtk.FALSE, 5)
self.add(self.vbox)
self.frame_s = gtk.GtkFrame("Server to use")
self.table_s = gtk.GtkTable(1, 6, gtk.FALSE)
self.server_lbl = gtk.GtkLabel('Server')
self.server_lbl.set_alignment(1, 0.5)
self.server_entry = gtk.GtkEntry()
self.table_s.attach(self.server_lbl,
0,
2,
0,
1,
xpadding=3,
ypadding=2)
self.table_s.attach(self.server_entry,
2,
6,
0,
1,
xpadding=3,
ypadding=2)
self.frame_s.add(self.table_s)
self.vbox.pack_start(self.frame_s)
self.frame = gtk.GtkFrame("Have Account?")
self.table = gtk.GtkTable(6, 6, gtk.FALSE)
self.username_lbl = gtk.GtkLabel('Username')
self.username_lbl.set_alignment(1, 0.5)
self.password_lbl = gtk.GtkLabel('Password')
self.password_lbl.set_alignment(1, 0.5)
self.username_entry = gtk.GtkEntry()
self.password_entry = gtk.GtkEntry()
self.password_entry.set_visibility(gtk.FALSE)
self.table.attach(self.username_lbl,
0,
2,
1,
2,
xpadding=3,
ypadding=2)
self.table.attach(self.password_lbl,
0,
2,
2,
3,
xpadding=3,
ypadding=2)
self.table.attach(self.username_entry,
2,
6,
1,
2,
xpadding=3,
ypadding=2)
self.table.attach(self.password_entry,
2,
6,
2,
3,
xpadding=3,
ypadding=2)
self.save_check = gtk.GtkCheckButton('Save Details')
self.table.attach(self.save_check, 3, 6, 4, 5, xpadding=3, ypadding=2)
self.login_button = gtk.GtkButton('Login')
self.login_button.connect('clicked', self.login)
self.table.attach(self.login_button, 3, 6, 5, 6, xpadding=5)
self.frame.add(self.table)
self.vbox.pack_start(self.frame)
self.frame_acc = gtk.GtkFrame("New User?")
self.table_acc = gtk.GtkTable(1, 1, gtk.FALSE)
self.button_acc = gtk.GtkButton("Get an Account")
self.button_acc.connect('clicked', self.new_account)
self.table_acc.attach(self.button_acc,
0,
1,
0,
1,
xpadding=5,
ypadding=5)
self.frame_acc.add(self.table_acc)
self.vbox.pack_end(self.frame_acc)
self.readRC()
self.username_entry.set_text(self.username)
self.password_entry.set_text(self.password)
self.server_entry.set_text(self.server)
self.vbox.show_all()
self.show()
self.set_modal(gtk.TRUE)
def __init__(self, parent_box, title='Input Window'):
self.frame = gtk.GtkFrame(title)
self.show_list = []
self.show_list.append(self.frame)
patch_table = gtk.GtkTable(2, 4, gtk.FALSE)
self.show_list.append(patch_table)
self.frame.add(patch_table)
patch_table.set_border_width(5)
patch_table.set_col_spacings(5)
patch_table.set_col_spacing(1, 20)
label1 = gtk.GtkLabel('Start Line: ')
label1.set_alignment(0, 0.5)
patch_table.attach(label1, 0, 1, 0, 1)
self.entry_dict = {}
self.entry_dict['start_line'] = gtk.GtkEntry()
self.entry_dict['start_line'].set_editable(gtk.TRUE)
self.entry_dict['start_line'].set_usize(90, 25)
self.entry_dict['start_line'].set_text('0')
patch_table.attach(self.entry_dict['start_line'], 1, 2, 0, 1)
label2 = gtk.GtkLabel('Start Pixel: ')
label2.set_alignment(0, 0.5)
patch_table.attach(label2, 2, 3, 0, 1)
self.entry_dict['start_pix'] = gtk.GtkEntry()
self.entry_dict['start_pix'].set_editable(gtk.TRUE)
self.entry_dict['start_pix'].set_usize(90, 25)
self.entry_dict['start_pix'].set_text('0')
patch_table.attach(self.entry_dict['start_pix'], 3, 4, 0, 1)
label3 = gtk.GtkLabel('Num. of Lines: ')
label3.set_alignment(0, 0.5)
patch_table.attach(label3, 0, 1, 1, 2)
self.entry_dict['num_lines'] = gtk.GtkEntry()
self.entry_dict['num_lines'].set_editable(gtk.TRUE)
self.entry_dict['num_lines'].set_usize(90, 25)
self.entry_dict['num_lines'].set_text('1')
patch_table.attach(self.entry_dict['num_lines'], 1, 2, 1, 2)
label4 = gtk.GtkLabel('Num. of Pixels: ')
label4.set_alignment(0, 0.5)
patch_table.attach(label4, 2, 3, 1, 2)
self.entry_dict['num_pix'] = gtk.GtkEntry()
self.entry_dict['num_pix'].set_editable(gtk.TRUE)
self.entry_dict['num_pix'].set_usize(90, 25)
self.entry_dict['num_pix'].set_text('1')
patch_table.attach(self.entry_dict['num_pix'], 3, 4, 1, 2)
self.show_list.append(label1)
self.show_list.append(label2)
self.show_list.append(label3)
self.show_list.append(label4)
self.show_list.append(self.entry_dict['start_line'])
self.show_list.append(self.entry_dict['start_pix'])
self.show_list.append(self.entry_dict['num_lines'])
self.show_list.append(self.entry_dict['num_pix'])
parent_box.pack_start(self.frame, gtk.FALSE, gtk.FALSE, 0)
def init_dialog(self):
self.dialog = gtk.GtkWindow()
self.dialog.set_title('GDAL Export Tool')
self.dialog.set_border_width(10)
self.tips = gtk.GtkTooltips()
#self.dialog.set_default_size(500,400)
self.dialog.set_policy(gtk.FALSE, gtk.TRUE, gtk.TRUE)
# main shell
mainshell = gtk.GtkHBox(spacing=1, homogeneous=gtk.FALSE)
self.dialog.add(mainshell)
self.show_list = []
self.adv_show_list = [] # advanced show list
self.show_list.append(mainshell)
#navigation shell
navshell = gtk.GtkVBox(spacing=1, homogeneous=gtk.FALSE)
mainshell.pack_start(navshell)
self.show_list.append(navshell)
self.frame_dict = {}
self.button_dict = {}
self.frame_dict['Files'] = gvutils.GvDataFilesFrame(
'Data Files', sel_list=('Input', 'Output'))
self.frame_dict['Files'].set_border_width(5)
self.frame_dict['Files'].set_spacings(5, 5)
self.frame_dict['Files'].show_all()
navshell.pack_start(self.frame_dict['Files'])
self.show_list.append(self.frame_dict['Files'])
bopt_frame = gtk.GtkFrame('Basic Options')
self.frame_dict['Basic Options'] = bopt_frame
self.show_list.append(bopt_frame)
navshell.pack_start(bopt_frame, gtk.FALSE, gtk.FALSE, 0)
bopt_table = gtk.GtkTable(2, 4, gtk.FALSE)
bopt_table.set_border_width(5)
bopt_table.set_row_spacings(5)
bopt_table.set_col_spacings(5)
bopt_frame.add(bopt_table)
self.show_list.append(bopt_table)
# Might be nice to have more formats below, but
# this involves error checking to test for
# supported data types, etc.
fmtlabel = gtk.GtkLabel('Output Format: ')
fmtlabel.set_alignment(0, 0.5)
self.show_list.append(fmtlabel)
bopt_table.attach(fmtlabel, 0, 1, 0, 1)
self.format_list = []
hist_idx = 0
for iDriver in gdal.GetDriverList():
create = None
try:
create = iDriver.GetMetadata()["DCAP_CREATE"]
except KeyError:
try:
create = iDriver.GetMetadata()["DCAP_CREATECOPY"]
except KeyError:
pass
if create == "YES":
if iDriver.ShortName == 'DTED':
# DTED is a special case that needs certain
# conditions to be valid. Skip it.
continue
self.format_list.append(iDriver.ShortName)
self.format_list.sort()
# Default to GTiff if possible
try:
hist_idx = self.format_list.index('GTiff')
except ValueError:
pass
self.format_menu = gvutils.GvOptionMenu(self.format_list)
self.format_menu.set_history(hist_idx)
self.show_list.append(self.format_menu)
bopt_table.attach(self.format_menu, 1, 2, 0, 1)
self.button_dict['Format_help'] = gtk.GtkButton('Help')
self.show_list.append(self.button_dict['Format_help'])
bopt_table.attach(self.button_dict['Format_help'], 2, 3, 0, 1)
reslabel = gtk.GtkLabel('Output Resolution: ')
reslabel.set_alignment(0, 0.5)
self.show_list.append(reslabel)
bopt_table.attach(reslabel, 0, 1, 1, 2)
self.res_list = ['Full', '1:2', '1:4', '1:8']
self.res_menu = gvutils.GvOptionMenu(self.res_list)
bopt_table.attach(self.res_menu, 1, 2, 1, 2)
self.show_list.append(self.res_menu)
self.button_dict['Mode'] = gtk.GtkCheckButton('Advanced Options')
navshell.pack_start(self.button_dict['Mode'])
self.show_list.append(self.button_dict['Mode'])
self.frame_dict['IP_window'] = DataWindowFrame(navshell)
self.adv_show_list.append(self.frame_dict['IP_window'])
iopt_frame = gtk.GtkFrame('Interactive Options')
self.frame_dict['Interactive Options'] = iopt_frame
self.adv_show_list.append(iopt_frame)
navshell.pack_start(iopt_frame, gtk.FALSE, gtk.FALSE, 0)
iopt_table = gtk.GtkTable(3, 3, gtk.FALSE)
iopt_table.set_border_width(5)
iopt_table.set_row_spacings(5)
iopt_table.set_col_spacings(5)
iopt_frame.add(iopt_table)
self.adv_show_list.append(iopt_table)
self.button_dict['IP_window'] = gtk.GtkCheckButton('Window Input File')
iopt_table.attach(self.button_dict['IP_window'], 0, 2, 0, 1)
self.adv_show_list.append(self.button_dict['IP_window'])
self.button_dict['Scale'] = gtk.GtkCheckButton(
'Scale to View Settings')
self.tips.set_tip(
self.button_dict['Scale'], 'Scale the output bands ' +
'according to the min/max settings of the ' +
'currently active raster layer. This only ' +
'applies to real data.')
iopt_table.attach(self.button_dict['Scale'], 0, 2, 1, 2)
self.adv_show_list.append(self.button_dict['Scale'])
self.button_dict['Refresh'] = gtk.GtkButton(
'Active Layer->Input Filename')
self.tips.set_tip(
self.button_dict['Refresh'], 'Set the input ' +
'filename to that of the currently active layer')
iopt_table.attach(self.button_dict['Refresh'], 0, 1, 2, 3)
self.adv_show_list.append(self.button_dict['Refresh'])
self.button_dict['Enable_ROI'] = gtk.GtkButton('Draw ROI mode')
self.tips.set_tip(
self.button_dict['Enable_ROI'], 'Re-activate the ' +
'ROI mode used for interactive input file window definition')
iopt_table.attach(self.button_dict['Enable_ROI'], 1, 2, 2, 3)
self.adv_show_list.append(self.button_dict['Enable_ROI'])
self.frame_dict['Other_Advanced'] = gtk.GtkFrame('')
self.frame_dict['Other_Advanced'].set_shadow_type(gtk.SHADOW_NONE)
self.adv_show_list.append(self.frame_dict['Other_Advanced'])
oadvbox = gtk.GtkVBox(spacing=5, homogeneous=gtk.FALSE)
oadvbox.set_border_width(5)
self.adv_show_list.append(oadvbox)
self.frame_dict['Other_Advanced'].add(oadvbox)
otable = gtk.GtkTable(2, 3, gtk.FALSE)
otable.set_row_spacings(5)
otable.set_col_spacings(5)
self.adv_show_list.append(otable)
oadvbox.pack_start(otable)
self._overview_list = ['None', 'Nearest', 'Average']
self.overview_menu = gvutils.GvOptionMenu(self._overview_list)
ovrlabel = gtk.GtkLabel('Overviews:')
self.tips.set_tip(self.overview_menu,
'Tiled overview creation options')
ovrlabel.set_alignment(0, 0.5)
self.adv_show_list.append(ovrlabel)
otable.attach(ovrlabel, 0, 1, 0, 1)
otable.attach(self.overview_menu, 1, 2, 0, 1)
self.adv_show_list.append(self.overview_menu)
self._geocode_list = ['Default', 'GCP', 'Geotransform']
self.geocoding_menu = gvutils.GvOptionMenu(self._geocode_list)
geolabel = gtk.GtkLabel('Geocoding:')
self.tips.set_tip(
self.geocoding_menu, 'Specify the type of georeferencing ' +
'information to output. Default is to output ' +
'all available geocoding from the input file. ' +
'If GCP or Geotransform is selected, geocoding ' +
'information will only be output if it is of the ' +
'selected type. This may later be updated to ' +
'generate information of the specified form if ' +
'it is not present but can be accurately computed ' +
'from the existing information.')
geolabel.set_alignment(0, 0.5)
self.adv_show_list.append(geolabel)
otable.attach(geolabel, 0, 1, 1, 2)
otable.attach(self.geocoding_menu, 1, 2, 1, 2)
self.adv_show_list.append(self.geocoding_menu)
opthbox = gtk.GtkHBox(spacing=5, homogeneous=gtk.FALSE)
self.adv_show_list.append(opthbox)
oadvbox.pack_start(opthbox)
optlabel = gtk.GtkLabel('Create Options:')
optlabel.set_alignment(0, 0.5)
self.adv_show_list.append(optlabel)
self.optentry = gtk.GtkEntry()
self.optentry.set_editable(editable=gtk.TRUE)
self.optentry.set_usize(400, 25)
self.optentry.set_text('')
self.adv_show_list.append(self.optentry)
opthbox.pack_start(optlabel)
opthbox.pack_start(self.optentry)
navshell.pack_start(self.frame_dict['Other_Advanced'], gtk.FALSE,
gtk.FALSE, 0)
echbox = gtk.GtkHBox(spacing=5, homogeneous=gtk.FALSE)
echbox.set_border_width(3)
navshell.pack_end(echbox, gtk.FALSE, gtk.FALSE, 0)
self.show_list.append(echbox)
self.button_dict['Close'] = gtk.GtkButton('Close')
echbox.pack_end(self.button_dict['Close'], expand=gtk.TRUE)
self.show_list.append(self.button_dict['Close'])
self.button_dict['Export'] = gtk.GtkButton('Export')
echbox.pack_end(self.button_dict['Export'], expand=gtk.TRUE)
self.show_list.append(self.button_dict['Export'])
self.button_dict['Format_help'].connect('clicked', self.format_help_cb)
self.button_dict['Enable_ROI'].connect('clicked', self.set_roitool)
self.button_dict['Refresh'].connect('clicked', self.refresh_fileinfo)
self.button_dict['Export'].connect('clicked', self.export_cb)
self.button_dict['Close'].connect('clicked', self.close)
self.button_dict['IP_window'].connect('toggled',
self.ip_window_toggled_cb)
self.button_dict['Mode'].connect('toggled', self.mode_toggled_cb)
self.button_dict['IP_window'].set_active(gtk.FALSE)
self.button_dict['Mode'].set_active(gtk.FALSE)
self.frame_dict['IP_window'].set_entry_sensitivities(gtk.FALSE)
# Trap window close event
self.dialog.connect('delete-event', self.close)
for item in self.show_list:
item.show()
if self.button_dict['Mode'].get_active():
for item in self.adv_show_list:
item.show()
else:
for item in self.adv_show_list:
item.hide()
