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__(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):
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 __init__(self, fontspec=None, use_font=FALSE):
"""
Initialize the font selector and optionally load a previous
font spec
"""
gtk.GtkHBox.__init__(self)
self.use_font = use_font
self.font = XLFDFontSpec()
tips = gtk.GtkTooltips()
if fontspec is not None:
self.font.parse_font_spec(fontspec)
else:
self.font.set_font_part('Family', 'Arial')
self.font.set_font_part('Point Size', '100')
table = gtk.GtkTable()
self.pack_start(table)
table.set_row_spacings(6)
table.set_col_spacings(6)
table.set_border_width(6)
self.font_label = pguFontDisplay()
self.font_label.set_text(self.font.get_display_string())
table.attach(self.font_label,
0,
1,
0,
1,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
tips.set_tip(self.font_label, 'double click to toggle sample mode')
font_button = gtk.GtkButton('...')
font_button.connect('clicked', self.show_font_dialog)
table.attach(font_button,
1,
2,
0,
1,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
tips.set_tip(font_button, 'click to select a different font')
self.show_all()
self.font_label.set_events(gtk.GDK.BUTTON_PRESS_MASK)
self.font_label.connect('button-press-event', self.label_clicked)
self.update_gui()
self.publish('font-changed')
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 __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_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.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)
glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue )
gear( 1.3, 2.0, 0.5, 10, 0.7 )
glEndList()
glEnable( GL_NORMALIZE )
if not gtkgl.query():
print "OpenGL not supported. Bye."
raise SystemExit
win = gtk.GtkWindow()
win.connect("destroy", gtk.mainquit)
win.set_title("Gears")
table = gtk.GtkTable(4, 2)
win.add(table)
table.show()
glarea = gtkgl.GtkGLArea((gtkgl.RGBA, gtkgl.DEPTH_SIZE, 1, gtkgl.DOUBLEBUFFER))
glarea.size(300, 300)
glarea.connect("realize", init)
glarea.connect("size_allocate", reshape)
glarea.connect("expose_event", draw)
gtk.idle_add(idle)
table.attach(glarea, 0,2, 0,1)
glarea.show()
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 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, 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()
def _interact(func_name):
(blurb, help, author, copyright, date,
menupath, imagetypes, plugin_type,
params, results, function) = _registered_plugins_[func_name]
# short circuit for no parameters ...
if len(params) == 0: return []
import gtk
import gimpui
gtk.rc_parse(gimp.gtkrc())
defaults = _get_defaults(func_name)
# define a mapping of param types to edit objects ...
class StringEntry(gtk.GtkEntry):
def __init__(self, default=''):
import gtk
gtk.GtkEntry.__init__(self)
self.set_text(str(default))
def get_value(self):
return self.get_text()
class IntEntry(StringEntry):
def get_value(self):
import string
return string.atoi(self.get_text())
class FloatEntry(StringEntry):
def get_value(self):
import string
return string.atof(self.get_text())
class ArrayEntry(StringEntry):
def get_value(self):
return eval(self.get_text())
class SliderEntry(gtk.GtkHScale):
# bounds is (upper, lower, step)
def __init__(self, default=0, bounds=(0, 100, 5)):
import gtk
self.adj = gtk.GtkAdjustment(default, bounds[0],
bounds[1], bounds[2],
bounds[2], bounds[2])
gtk.GtkHScale.__init__(self, self.adj)
def get_value(self):
return self.adj.value
class SpinnerEntry(gtk.GtkSpinButton):
# bounds is (upper, lower, step)
def __init__(self, default=0, bounds=(0, 100, 5)):
import gtk
self.adj = gtk.GtkAdjustment(default, bounds[0],
bounds[1], bounds[2],
bounds[2], bounds[2])
gtk.GtkSpinButton.__init__(self, self.adj, 1, 0)
def get_value(self):
return int(self.adj.value)
class ToggleEntry(gtk.GtkToggleButton):
def __init__(self, default=0):
import gtk
gtk.GtkToggleButton.__init__(self)
self.label = gtk.GtkLabel("No")
self.add(self.label)
self.label.show()
self.connect("toggled", self.changed)
self.set_active(default)
def changed(self, tog):
if tog.active:
self.label.set_text("Yes")
else:
self.label.set_text("No")
def get_value(self):
return self.get_active()
_edit_mapping = {
PF_INT8 : IntEntry,
PF_INT16 : IntEntry,
PF_INT32 : IntEntry,
PF_FLOAT : FloatEntry,
PF_STRING : StringEntry,
PF_INT8ARRAY : ArrayEntry,
PF_INT16ARRAY : ArrayEntry,
PF_INT32ARRAY : ArrayEntry,
PF_FLOATARRAY : ArrayEntry,
PF_STRINGARRAY : ArrayEntry,
PF_COLOUR : gimpui.ColourSelector,
PF_REGION : IntEntry, # should handle differently ...
PF_IMAGE : gimpui.ImageSelector,
PF_LAYER : gimpui.LayerSelector,
PF_CHANNEL : gimpui.ChannelSelector,
PF_DRAWABLE : gimpui.DrawableSelector,
PF_TOGGLE : ToggleEntry,
PF_SLIDER : SliderEntry,
PF_SPINNER : SpinnerEntry,
PF_FONT : gimpui.FontSelector,
PF_FILE : gimpui.FileSelector,
PF_BRUSH : gimpui.BrushSelector,
PF_PATTERN : gimpui.PatternSelector,
PF_GRADIENT : gimpui.GradientSelector,
}
tooltips = gtk.GtkTooltips()
dialog = gtk.GtkDialog()
dialog.set_title(func_name)
table = gtk.GtkTable(len(params), 3, gtk.FALSE)
table.set_border_width(5)
table.set_row_spacings(2)
table.set_col_spacings(10)
dialog.vbox.pack_start(table)
table.show()
vbox = gtk.GtkVBox(gtk.FALSE, 15)
table.attach(vbox, 0,1, 0,len(params), xoptions=gtk.FILL)
vbox.show()
pix = _get_logo(vbox.get_colormap())
vbox.pack_start(pix, expand=gtk.FALSE)
pix.show()
label = gtk.GtkLabel(blurb)
label.set_line_wrap(TRUE)
label.set_justify(gtk.JUSTIFY_LEFT)
label.set_usize(100, -1)
vbox.pack_start(label, expand=gtk.FALSE)
label.show()
edit_wids = []
for i in range(len(params)):
type = params[i][0]
name = params[i][1]
desc = params[i][2]
def_val = defaults[i]
label = gtk.GtkLabel(name)
label.set_alignment(1.0, 0.5)
table.attach(label, 1,2, i,i+1, xoptions=gtk.FILL)
label.show()
if type in (PF_SPINNER, PF_SLIDER):
wid = _edit_mapping[type](def_val, params[i][4])
else:
wid = _edit_mapping[type](def_val)
table.attach(wid, 2,3, i,i+1)
tooltips.set_tip(wid, desc, None)
wid.show()
edit_wids.append(wid)
def delete_event(win, event=None):
import gtk
win.hide()
gtk.mainquit()
return TRUE
# this is a hack ...
finished = [ 0 ]
def ok_clicked(button, win=dialog, finished=finished):
import gtk
win.hide()
finished[0] = 1
gtk.mainquit()
b = gtk.GtkButton("OK")
b.set_flags(gtk.CAN_DEFAULT)
dialog.action_area.pack_start(b)
b.grab_default()
b.connect("clicked", ok_clicked)
b.show()
b = gtk.GtkButton("Cancel")
b.set_flags(gtk.CAN_DEFAULT)
dialog.action_area.pack_start(b)
b.connect("clicked", delete_event)
b.show()
dialog.show()
tooltips.enable()
# run the main loop
gtk.mainloop()
ret = None
if finished[0]:
# OK was clicked
ret = map(lambda wid: wid.get_value(), edit_wids)
_set_defaults(func_name, ret)
dialog.destroy()
return ret
def init_customize_gui_panel(self):
# Inherit all the usual stuff...
General_ROIToolDlg.init_customize_gui_panel(self)
# Add new frame with pixel info, keeping track of
# the frame and text object...
self.frame_dict['region_info_frame'] = gtk.GtkFrame()
self.show_list.append(self.frame_dict['region_info_frame'])
pixel_vbox = gtk.GtkVBox()
self.show_list.append(pixel_vbox)
self.frame_dict['region_info_frame'].add(pixel_vbox)
pixel_scroll = gtk.GtkScrolledWindow()
self.show_list.append(pixel_scroll)
pixel_vbox.pack_start(pixel_scroll,expand = gtk.TRUE)
self.entry_dict['region_info_text'] = gtk.GtkText()
self.show_list.append(self.entry_dict['region_info_text'])
self.entry_dict['region_info_text'].set_line_wrap(gtk.FALSE)
self.entry_dict['region_info_text'].set_word_wrap(gtk.FALSE)
self.entry_dict['region_info_text'].set_editable(gtk.FALSE)
pixel_scroll.add(self.entry_dict['region_info_text'])
self.entry_dict['region_info_text'].insert_defaults('')
# Add a frame with the log file options
self.frame_dict['log_frame']=gtk.GtkFrame()
self.show_list.append(self.frame_dict['log_frame'])
log_table = gtk.GtkTable(2,4,gtk.FALSE)
self.show_list.append(log_table)
self.frame_dict['log_frame'].add(log_table)
log_table.set_border_width(5)
log_table.set_col_spacings(5)
log_table.set_col_spacing(1, 20)
self.button_dict['Log To File'] = gtk.GtkCheckButton('Log To File')
self.show_list.append(self.button_dict['Log To File'])
log_table.attach(self.button_dict['Log To File'], 0,1, 0, 1)
self.button_dict['Select Log'] = gtk.GtkButton('Select Log')
self.show_list.append(self.button_dict['Select Log'])
log_table.attach(self.button_dict['Select Log'], 3,4, 0, 1)
log_label = gtk.GtkLabel('Log File (full path): ')
log_label.set_alignment(0, 0.5)
log_table.attach(log_label, 0,1, 1, 2)
self.entry_dict['log_file'] = gtk.GtkEntry()
self.entry_dict['log_file'].set_editable(gtk.TRUE)
self.entry_dict['log_file'].set_usize(400,25)
self.entry_dict['log_file'].set_text('')
log_table.attach(self.entry_dict['log_file'], 1,4, 1,2)
self.main_panel.pack_start(self.frame_dict['region_info_frame'],gtk.TRUE,gtk.TRUE,0)
self.main_panel.pack_start(self.frame_dict['log_frame'],gtk.FALSE,gtk.FALSE,0)
# Customized connections
self.button_dict['Select Log'].connect('clicked',self.select_log_cb)
# Set default sensitivities for customized tool
self.button_dict['Log To File'].set_active(gtk.FALSE)
self.button_dict['Log To File'].set_sensitive(gtk.TRUE)
self.button_dict['Select Log'].set_sensitive(gtk.TRUE)
glLightModel(GL_LIGHT_MODEL_AMBIENT, [0.2, 0.2, 0.2, 1.0])
glEnable(GL_LIGHTING)
glEnable(GL_LIGHT0)
glDepthFunc(GL_LESS)
glEnable(GL_DEPTH_TEST)
if not gtkgl.query():
print "OpenGL not supported. Bye."
raise SystemExit
win = gtk.GtkWindow()
win.connect("destroy", gtk.mainquit)
win.set_title("Cone")
table = gtk.GtkTable(2, 3)
table.set_border_width(5)
table.set_col_spacings(5)
table.set_row_spacings(5)
win.add(table)
table.show()
vadj = gtk.GtkAdjustment(250, 0, 360, 5, 5, 0)
vscale = gtk.GtkVScale(vadj)
table.attach(vscale, 1, 2, 0, 1, xoptions=gtk.FILL)
vscale.show()
hadj = gtk.GtkAdjustment(0, 0, 360, 5, 5, 0)
hscale = gtk.GtkHScale(hadj)
table.attach(hscale, 0, 1, 1, 2, yoptions=gtk.FILL)
hscale.show()
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, 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()
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 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_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()
