def reset_classification_list(self, *args):
"""Set the contents of class_list to the classification
scheme in the classification object."""
#clear existing UI side items.
self.class_list.clear_items(0, -1)
del self.color_buttons, self.ranges, self.labels
self.color_buttons = []
self.ranges = []
self.labels = []
cls = self.classification
#prepare a default classification if one doesn't exist
if cls.count == 0:
cls.prepare_default(5)
symbol = cls.get_symbol(0)
#setup the column headers
class_item = gtk.GtkListItem()
set_widget_background(class_item, (1.0, 0.0, 0.0))
class_box = gtk.GtkHBox()
clr_frm = gtk.GtkFrame()
clr_frm.add(gtk.GtkLabel('Color'))
clr_frm.set_shadow_type(gtk.SHADOW_OUT)
if symbol is not None:
sym_frm = gtk.GtkFrame()
sym_frm.add(gtk.GtkLabel('Symbol'))
sym_frm.set_shadow_type(gtk.SHADOW_OUT)
scale_frm = gtk.GtkFrame()
scale_frm.add(gtk.GtkLabel('Scale'))
scale_frm.set_shadow_type(gtk.SHADOW_OUT)
else:
sym_frm = None
scale_frm = None
rng_frm = gtk.GtkFrame()
rng_frm.add(gtk.GtkLabel('Range'))
rng_frm.set_shadow_type(gtk.SHADOW_OUT)
lbl_frm = gtk.GtkFrame()
lbl_frm.add(gtk.GtkLabel('Label'))
lbl_frm.set_shadow_type(gtk.SHADOW_OUT)
self.add_classification_item(clr_frm, sym_frm, scale_frm, rng_frm,
lbl_frm, gtk.FALSE)
#for each class, create an entry in the list
for n in range(cls.count):
self.insert_class(n)
self.class_list.show_all()
if self.ramp is not None:
self.apply_ramp(self.ramp)
def init_create_gui_panel(self):
# Basic Buttons...
self.button_dict['Analyze'] = gtk.GtkButton('Analyze')
self.show_list.append(self.button_dict['Analyze'])
self.button_dict['Activate'] = gtk.GtkCheckButton('Activate')
self.show_list.append(self.button_dict['Activate'])
self.button_dict['Auto Update'] = gtk.GtkCheckButton('Auto Update')
self.show_list.append(self.button_dict['Auto Update'])
self.button_dict['Set Tool'] = gtk.GtkButton('Set Tool')
self.show_list.append(self.button_dict['Set Tool'])
# Basic Frames...
# first frame
self.frame_dict['base_frame1'] = gtk.GtkFrame()
self.show_list.append(self.frame_dict['base_frame1'])
hbox1 = gtk.GtkHBox(gtk.TRUE,5)
self.show_list.append(hbox1)
hbox1.pack_end(self.button_dict['Analyze'],gtk.TRUE,gtk.TRUE,0)
self.frame_dict['base_frame1'].add(hbox1)
# second frame- will contain roi or poi info
self.frame_dict['base_frame2'] = gtk.GtkFrame()
self.show_list.append(self.frame_dict['base_frame2'])
# third frame
self.frame_dict['base_frame3'] = gtk.GtkFrame();
self.show_list.append(self.frame_dict['base_frame3'])
hbox3 = gtk.GtkHBox(gtk.TRUE,5)
self.show_list.append(hbox3)
hbox3.pack_start(self.button_dict['Activate'],gtk.TRUE,gtk.TRUE,0)
hbox3.pack_start(self.button_dict['Auto Update'],gtk.TRUE,gtk.TRUE,0)
hbox3.pack_start(self.button_dict['Set Tool'],gtk.TRUE,gtk.TRUE,0)
self.frame_dict['base_frame3'].add(hbox3)
# Top level panel...
self.main_panel = gtk.GtkVBox(gtk.FALSE,5)
self.main_panel.pack_start(self.frame_dict['base_frame1'],gtk.FALSE,gtk.FALSE,0)
self.main_panel.pack_start(self.frame_dict['base_frame2'],gtk.FALSE,gtk.FALSE,0)
self.main_panel.pack_end(self.frame_dict['base_frame3'],gtk.FALSE,gtk.FALSE,0)
self.add(self.main_panel)
self.show_list.append(self.main_panel)
def __init__(self, title, text): self.window = gtk.GtkWindow(gtk.WINDOW_POPUP) self.window.set_title(title) self.window.set_position(gtk.WIN_POS_CENTER) self.window.set_modal(gtk.TRUE) self.label = gtk.GtkLabel(text) self.label.set_line_wrap(gtk.TRUE) box = gtk.GtkFrame() box.set_border_width(8) box.add(self.label) box.set_shadow_type(gtk.SHADOW_NONE) frame = gtk.GtkFrame() frame.set_shadow_type(gtk.SHADOW_OUT) frame.add(box) self.window.add(frame) self.window.show_all()
def __init__(self, size=(300,300), name="Piddle-GTK"):
import gtk
#
width, height = (int(round(size[0])), int(round(size[1])))
top = self.__top = gtk.GtkDialog()
vbox = top.vbox
frame = self.__frame = gtk.GtkFrame()
frame.set_shadow_type(gtk.SHADOW_IN)
da = gtk.GtkDrawingArea()
button = gtk.GtkButton("Dismiss")
button.connect("clicked",
lambda button, top=top: top.destroy())
frame.set_border_width(10)
bbox = self.__bbox = gtk.GtkHButtonBox()
bbox.set_layout(gtk.BUTTONBOX_END)
bbox.pack_end(button)
top.action_area.pack_end(bbox)
frame.add(da)
vbox.pack_start(frame)
InteractiveCanvas.__init__(self, da, top)
top.set_wmclass("canvas", "Canvas")
da.realize()
da.set_usize(width, height)
top.show_all()
top.set_icon_name(name)
top.set_title(name)
self.ensure_size(width, height)
def init_customize_gui_panel(self):
# Inherit all the usual stuff...
General_POIToolDlg.init_customize_gui_panel(self)
# Add new frame with pixel info, keeping track of
# the frame and text object...
self.frame_dict['pixel_info_frame'] = gtk.GtkFrame()
self.show_list.append(self.frame_dict['pixel_info_frame'])
pixel_vbox = gtk.GtkVBox()
self.show_list.append(pixel_vbox)
self.frame_dict['pixel_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['pixel_info_text'] = gtk.GtkText()
self.show_list.append(self.entry_dict['pixel_info_text'])
self.entry_dict['pixel_info_text'].set_line_wrap(gtk.FALSE)
self.entry_dict['pixel_info_text'].set_word_wrap(gtk.FALSE)
self.entry_dict['pixel_info_text'].set_editable(gtk.FALSE)
pixel_scroll.add(self.entry_dict['pixel_info_text'])
self.entry_dict['pixel_info_text'].insert_defaults('')
self.main_panel.pack_start(self.frame_dict['pixel_info_frame'],gtk.TRUE,gtk.TRUE,0)
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 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
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 create_default_frame(self):
self.frames['Default'] = gtk.GtkFrame('')
self.frames['Default'].set_shadow_type(gtk.SHADOW_NONE)
vbox = gtk.GtkVBox()
vbox.set_spacing(spc)
self.frames['Default'].add(vbox)
self.default_scrolled_text = gtk.GtkText()
self.default_scrolled_text.set_line_wrap(gtk.FALSE)
self.default_scrolled_text.set_word_wrap(gtk.FALSE)
self.default_scrolled_text.set_editable(gtk.FALSE)
self.default_scrolled_win = gtk.GtkScrolledWindow()
self.default_scrolled_win.set_usize(200, 200)
self.default_scrolled_win.add(self.default_scrolled_text)
vbox.pack_start(self.default_scrolled_win, expand=gtk.TRUE)
self.frames['Default'].show_all()
self.pack_start(self.frames['Default'])
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 create_gcp_frame(self):
self.frames['GCPs'] = gtk.GtkFrame('')
self.frames['GCPs'].set_shadow_type(gtk.SHADOW_NONE)
vbox = gtk.GtkVBox()
vbox.set_spacing(spc)
self.frames['GCPs'].add(vbox)
self.gcpgrid = pgugrid.pguGrid((3, 1, 0, 1, 7, 0, 0, 0, 3))
self.gcpgrid.set_usize(200, 200)
self.gcplist = []
self.gcpgrid.set_source(
self.gcplist,
members=['Id', 'GCPPixel', 'GCPLine', 'GCPX', 'GCPY', 'GCPZ'],
titles=['ID', 'Pixel', 'Line', 'X', 'Y', 'Z'],
types=['string', 'float', 'float', 'float', 'float', 'float'])
vbox.pack_start(self.gcpgrid)
hbox = gtk.GtkHBox()
hbox.set_spacing(spc)
vbox.pack_start(hbox)
self.add_gcp_button = gtk.GtkButton(' Add GCP ')
self.add_gcp_button.connect('clicked', self.add_gcp_cb)
hbox.pack_start(self.add_gcp_button, expand=gtk.FALSE)
self.tips.set_tip(self.add_gcp_button, 'Add a new GCP')
self.load_gcp_button = gtk.GtkButton('Load GCPs')
self.tips.set_tip(
self.load_gcp_button,
'Clear existing GCPs and load ' + 'new ones from a text file')
self.load_gcp_button.connect('clicked', self.load_gcps_cb)
hbox.pack_start(self.load_gcp_button, expand=gtk.FALSE)
self.copy_gcp_button = gtk.GtkButton('Copy GCPs')
self.copy_gcp_button.connect('clicked', self.copy_gcps_cb)
self.tips.set_tip(
self.copy_gcp_button, 'Clear existing GCPs and copy new ' +
'ones from another GDAL dataset')
hbox.pack_start(self.copy_gcp_button, expand=gtk.FALSE)
self.clear_gcp_button = gtk.GtkButton('Clear GCPs')
self.clear_gcp_button.connect('clicked', self.clear_gcps)
self.tips.set_tip(self.clear_gcp_button, 'Clear all GCPs')
hbox.pack_start(self.clear_gcp_button, expand=gtk.FALSE)
self.gcpprjbox = ProjectionBox(self.tips)
vbox.pack_start(self.gcpprjbox)
self.frames['GCPs'].show_all()
self.pack_start(self.frames['GCPs'])
def init_customize_gui_panel(self):
# Inherit all the usual stuff...
toolexample.General_ROIToolDlg.init_customize_gui_panel(self)
# Add new frame with pixel info, keeping track of
# the frame and text object...
self.frame_dict['histogram_frame'] = gtk.GtkFrame()
self.show_list.append(self.frame_dict['histogram_frame'])
# Initialize with dummy histogram.
histogram = []
for i in range(256):
histogram.append(0)
(pm, mask) = self.get_histview(histogram, 0, 256, -1, 1)
self.viewarea = gtk.GtkPixmap(pm, mask)
self.entry_dict['histogram_view'] = self.viewarea
self.show_list.append(self.viewarea)
self.frame_dict['histogram_frame'].add(self.viewarea)
self.main_panel.pack_start(self.frame_dict['histogram_frame'],
gtk.TRUE, gtk.TRUE, 0)
def __init__(self):
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()
#set events for scrolling (not defined in GDK
#self._area.set_events(1 << 21)
self.contents = []
self.max_width = 0
self.max_length = 0
self.height = 0
self.line_height = 0
self.start_line = 0
self.start_col = 0
self.freeze_count = 0
self.updating = gtk.FALSE
frm = gtk.GtkFrame()
frm.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
frm.add(self._area)
self.attach(frm, 0, 1, 0, 1)
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()
self._area.connect('expose-event', self.expose)
self.connect('configure-event', self.configure)
self.hadj.connect('value-changed', self.changed)
self.vadj.connect('value-changed', self.changed)
self._area.connect("scroll-event", self.event)
self.connect('style-set', self.expose)
def __init__(self, r, a, w):
self.attachment = a
self.reader = r
self.page = gtk.GtkFrame(None)
xml = self.reader.readglade("messageframe", self)
self.frame_widget = sqmail.gui.utils.WidgetStore(xml)
self.frame_widget.frame.hide()
self.frame_widget.frame.reparent(self.page)
self.frame_widget.messageframe.destroy()
xml = self.reader.readglade(w, self)
self.viewer_widget = sqmail.gui.utils.WidgetStore(xml)
self.viewer_widget.frame.hide()
self.viewer_widget.frame.reparent(self.frame_widget.container)
self.viewer_widget[w].destroy()
self.page.show()
self.tab = gtk.GtkLabel(self.attachment[0])
self.frame_widget.attachmentinfo.set_text(self.getdescription())
self.viewer_widget.frame.show()
self.frame_widget.frame.show()
def createGUI(self):
mainbox = gtk.GtkVBox(spacing=5)
mainbox.set_border_width(5)
self.add(mainbox)
# RGB source
frame = gtk.GtkFrame("Setup")
mainbox.add(frame, expand=FALSE)
vbox = gtk.GtkVBox(spacing=5)
vbox.set_border_width(5)
frame.add(vbox)
box = gtk.GtkHBox(spacing=5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('RGB:'), expand=FALSE)
self.rgbCB = gtk.GtkCombo()
self.rgbCB.set_popdown_strings(self.rgbDict.keys())
box.add(self.rgbCB)
# Pan source
box = gtk.GtkHBox(spacing=5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('Pan:'), expand=FALSE)
self.panCB = gtk.GtkCombo()
self.panCB.set_popdown_strings(self.panDict.keys())
box.add(self.panCB)
# output
box = gtk.GtkHBox(spacing=5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('Format:'), expand=FALSE)
self.formatCB = gtk.GtkCombo()
wDrvs = filter(lambda drv: 'DCAP_CREATE' in drv.GetMetadata(),
gdal.GetDriverList())
drivers = map(lambda d: d.ShortName, wDrvs)
drivers.sort()
self.formatCB.set_popdown_strings(drivers)
self.formatCB.entry.set_text('GTiff')
self.tips.set_tip(self.formatCB.entry,
'Output formats. Some may not work.')
box.add(self.formatCB, expand=FALSE)
box = gtk.GtkHBox(spacing=5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('Output file:'), expand=FALSE)
self.outTE = gtk.GtkEntry()
box.add(self.outTE)
# warp options
box = gtk.GtkHBox(spacing=5)
box.set_border_width(5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('Resampling'), expand=FALSE)
self.algCB = gtk.GtkCombo()
self.tips.set_tip(
self.algCB.entry,
'Resampling algorithm. Cubic Spline is recommended for best results'
)
box.add(self.algCB, expand=FALSE)
self.algCB.set_popdown_strings(
['Nearest Neighbor', 'Bilinear', 'Cubic', 'Cubic Spline'])
box = gtk.GtkHBox(spacing=5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('Create options:'), expand=FALSE)
self.coptTE = gtk.GtkEntry()
self.coptTE.set_text('tiled=yes')
box.add(self.coptTE)
box = gtk.GtkHBox(homogeneous=TRUE, spacing=5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('Pixel: '), expand=FALSE)
self.xoffTE = gtk.GtkEntry()
self.xoffTE.set_usize(50, -1)
box.add(self.xoffTE, expand=FALSE)
box.add(gtk.GtkLabel('Line:'), expand=FALSE)
self.yoffTE = gtk.GtkEntry()
self.yoffTE.set_usize(50, -1)
box.add(self.yoffTE, expand=FALSE)
box = gtk.GtkHBox(homogeneous=TRUE, spacing=5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('Width: '), expand=FALSE)
self.widthTE = gtk.GtkEntry()
self.widthTE.set_usize(50, -1)
box.add(self.widthTE, expand=FALSE)
box.add(gtk.GtkLabel('Height:'), expand=FALSE)
self.heightTE = gtk.GtkEntry()
self.heightTE.set_usize(50, -1)
box.add(self.heightTE, expand=FALSE)
box = gtk.GtkHBox(homogeneous=TRUE, spacing=5)
vbox.add(box, expand=FALSE)
box.add(gtk.GtkLabel('X offset: '), expand=FALSE)
self.panXoffTE = gtk.GtkEntry()
self.panXoffTE.set_usize(50, -1)
self.panXoffTE.set_text('0')
self.tips.set_tip(self.panXoffTE, 'Pan X offset')
box.add(self.panXoffTE, expand=FALSE)
box.add(gtk.GtkLabel('Y offset:'), expand=FALSE)
self.panYoffTE = gtk.GtkEntry()
self.panYoffTE.set_usize(50, -1)
self.panYoffTE.set_text('0')
self.tips.set_tip(self.panYoffTE, 'Pan Y offset')
box.add(self.panYoffTE, expand=FALSE)
box = gtk.GtkHBox(spacing=5)
vbox.add(box)
self.swapTO = gtk.GtkCheckButton(label='Swap R-B')
self.tips.set_tip(self.swapTO,
'Swap Red and Blue bands. Used for Quickbird.')
box.add(self.swapTO)
box.add(gtk.GtkLabel('Datatype:'), expand=FALSE)
self.sat0RB = gtk.GtkRadioButton(label='Byte')
box.add(self.sat0RB)
self.sat1RB = gtk.GtkRadioButton(label='UInt16', group=self.sat0RB)
box.add(self.sat1RB)
box = gtk.GtkHBox(spacing=5)
vbox.add(box)
box.add(gtk.GtkLabel('Resize:'), expand=FALSE)
self.reszFn0CB = gtk.GtkRadioButton(label='Gdalwarp')
box.add(self.reszFn0CB)
self.reszFn1CB = gtk.GtkRadioButton(label='gdal.py',
group=self.reszFn0CB)
box.add(self.reszFn1CB)
# Params
frame = gtk.GtkFrame('Fusion Method')
mainbox.add(frame, expand=FALSE)
vbox = gtk.GtkVBox(spacing=3)
vbox.set_border_width(5)
frame.add(vbox)
box = gtk.GtkHBox(spacing=5)
vbox.add(box)
self.met0RB = gtk.GtkRadioButton(label='IHS')
tipTxt = 'Standard Intensity-Hue-Saturation merging. '
tipTxt += 'Sharpness setting has no effect. '
self.tips.set_tip(self.met0RB, tipTxt)
box.add(self.met0RB)
self.met1RB = gtk.GtkRadioButton(label='Kernel', group=self.met0RB)
tipTxt = 'Pan is run through a convolution kernel and added to RGB. '
tipTxt += 'Recommended sharpness: 0.15-0.25 for Ikonos and Quickbird, '
tipTxt += '0.3-0.5 for Landsat and SPOT. '
tipTxt += 'Can be set higher if imagery is enhanced.'
self.tips.set_tip(self.met1RB, tipTxt)
box.add(self.met1RB)
# params
vbox2 = gtk.GtkVBox(spacing=5)
vbox2.set_border_width(5)
vbox.add(vbox2)
box = gtk.GtkHBox(spacing=5)
vbox2.add(box)
box.add(gtk.GtkLabel('Sharpness:'), expand=FALSE)
self.adjSharp = gtk.GtkAdjustment(0.15, 0.0, 1.0, 0.01, 0.1)
slider = gtk.GtkHScale(self.adjSharp)
slider.set_digits(2)
box.add(slider)
# Buttons
box = gtk.GtkHBox(homogeneous=1, spacing=5)
mainbox.add(box, expand=FALSE)
mergeBT = gtk.GtkButton("Merge")
mergeBT.connect("clicked", self.compute, 'merge')
self.tips.set_tip(mergeBT, 'Proceed with merging')
box.add(mergeBT)
pviewBT = gtk.GtkButton("Preview")
pviewBT.connect("clicked", self.compute, 'pview')
self.tips.set_tip(pviewBT, 'Preview merging')
box.add(pviewBT)
closeBT = gtk.GtkButton("Close")
closeBT.connect("clicked", self.close)
box.add(closeBT)
# do the connects last so events are not fired during init
self.panCB.entry.connect('changed', self.panChanged)
self.rgbCB.entry.connect('changed', self.rgbChanged)
self.formatCB.entry.connect('changed', self.formatChanged)
return 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()
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__(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, tips):
self.frame = gtk.GtkFrame('Raster Bands')
self.tips = tips
self.input_bands = get_list_of_bands_as_dict()
self.output_bands = {}
hbox1 = gtk.GtkHBox(spacing=spc)
hbox1.set_border_width(spc)
self.frame.add(hbox1)
# source (input)
srcvbox = gtk.GtkVBox(spacing=spc)
label = gtk.GtkLabel('Input:')
label.set_alignment(0, 0.5)
srcvbox.pack_start(label, expand=gtk.FALSE)
hbox1.pack_start(srcvbox)
source_win = gtk.GtkScrolledWindow()
source_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
source_win.set_usize(300, 200)
srcvbox.pack_start(source_win)
source_list = gtk.GtkList()
source_list.set_selection_mode(gtk.SELECTION_MULTIPLE)
source_win.add_with_viewport(source_list)
source_list.append_items(self.input_bands.keys())
# signals sent up to top level so that defaults can
# be updated. Defaults are updated whenever the output
# bands are cleared, or the first one is specified.
self.publish('output-bands-empty')
self.publish('output-bands-notempty')
def src_load(_button, *args):
fname = GtkExtra.file_sel_box(title="Select GDAL Dataset")
if fname is None:
return
ds = gdal.OpenShared(fname)
if ds is None:
gvutils.error('Not a valid gdal dataset!')
return
dict = {}
for i in range(1, ds.RasterCount + 1):
curband = fname + '.band[' + str(i) + ']'
dict[gtk.GtkListItem(curband)] = (ds, i, curband)
if srctoggle.get_active() == gtk.TRUE:
slist = vrtutils.GetSimilarFiles(fname)
for nname in slist:
ds = gdal.OpenShared(nname)
if ds is None:
continue
for i in range(1, ds.RasterCount + 1):
curband = nname + '.band[' + str(i) + ']'
dict[gtk.GtkListItem(curband)] = (ds, i, curband)
self.add_input_bands(dict)
def src_get_active_layers(_button, *args):
size = None
if len(self.input_bands) > 0:
ckey = self.input_bands.keys()[0]
size = (self.input_bands[ckey][0].RasterXSize,
self.input_bands[ckey][0].RasterYSize)
new_dict = get_list_of_bands_as_dict(size)
self.add_input_bands(new_dict)
def src_clear(_button, *args):
self.clear_input_bands()
self.source_list = source_list
# source control buttons
srcbbox = gtk.GtkHBox(spacing=spc)
srcvbox.pack_start(srcbbox, expand=gtk.FALSE)
load_btn = gtk.GtkButton("Load File")
self.tips.set_tip(load_btn, 'Add bands from a file to the input list')
srcbbox.pack_start(load_btn)
load_btn.connect("clicked", src_load)
act_btn = gtk.GtkButton("Views->List")
self.tips.set_tip(act_btn, 'Add bands from views to the input list')
srcbbox.pack_start(act_btn)
act_btn.connect("clicked", src_get_active_layers)
clear_btn = gtk.GtkButton("Clear")
srcbbox.pack_start(clear_btn)
clear_btn.connect("clicked", src_clear)
srctoggle = gtk.GtkCheckButton("Include Similar")
self.tips.set_tip(
srctoggle, 'Include bands from same-size files ' +
'in the same directory when using Load File.')
srcbbox.pack_start(srctoggle, expand=gtk.FALSE)
srctoggle.set_active(gtk.TRUE)
# destination
btn_box = gtk.GtkVBox(spacing=10)
btn_box.set_border_width(10)
hbox1.pack_start(btn_box, expand=gtk.FALSE)
btn_box.show()
def dest_add(_button, *args):
sel = source_list.get_selection()
sel.reverse() # add in order of selection
if len(self.output_bands.keys()) == 0:
refreshflag = 1
else:
refreshflag = 0
for i in sel:
list_item = gtk.GtkListItem(self.input_bands[i][2])
self.dest_list.append_items([list_item])
list_item.show()
self.dest_list.select_child(self.dest_list.children()[-1])
self.output_bands[list_item] = self.input_bands[i]
if (refreshflag == 1) and (len(sel) > 0):
self.notify('output-bands-notempty')
def dest_del(_button, *args):
selection = self.dest_list.get_selection()
self.dest_list.remove_items(selection)
for i in selection:
del self.output_bands[i]
i.destroy()
rest = self.dest_list.children()
if len(rest) > 0:
self.dest_list.select_child(self.dest_list.children()[-1])
else:
self.notify('output-bands-empty')
def dest_raise(_button, *args):
selection = self.dest_list.get_selection()
if len(selection) != 1:
return
pos = self.dest_list.child_position(selection[0])
if pos < 1:
return
self.dest_list.remove_items(selection)
self.dest_list.insert_items(selection, pos - 1)
self.dest_list.select_item(pos - 1)
def dest_lower(_button, *args):
selection = self.dest_list.get_selection()
if len(selection) != 1:
return
pos = self.dest_list.child_position(selection[0])
if pos > len(self.output_bands) - 2:
return
self.dest_list.remove_items(selection)
self.dest_list.insert_items(selection, pos + 1)
self.dest_list.select_item(pos + 1)
add_btn = gtk.GtkButton("Add->")
add_btn.connect("clicked", dest_add)
# The label below just makes things align more nicely (adds space)
btn_box.pack_start(gtk.GtkLabel(''), expand=gtk.FALSE)
btn_box.pack_start(add_btn, expand=gtk.FALSE)
destvbox = gtk.GtkVBox(spacing=spc)
label = gtk.GtkLabel('Output:')
label.set_alignment(0, 0.5)
destvbox.pack_start(label, expand=gtk.FALSE)
dest_win = gtk.GtkScrolledWindow()
dest_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
dest_win.set_usize(300, 200)
destvbox.pack_start(dest_win)
hbox1.pack_start(destvbox)
destbbox = gtk.GtkHBox(spacing=spc)
destvbox.pack_start(destbbox, expand=gtk.FALSE)
del_btn = gtk.GtkButton()
del_btn.add(
gtk.GtkPixmap(parent,
os.path.join(gview.home_dir, 'pics', 'delete.xpm')))
del_btn.connect("clicked", dest_del)
destbbox.pack_start(del_btn, expand=gtk.FALSE)
r_btn = gtk.GtkButton()
r_btn.add(
gtk.GtkPixmap(parent,
os.path.join(gview.home_dir, 'pics', 'raise.xpm')))
r_btn.connect("clicked", dest_raise)
destbbox.pack_start(r_btn, expand=gtk.FALSE)
l_btn = gtk.GtkButton()
l_btn.add(
gtk.GtkPixmap(parent,
os.path.join(gview.home_dir, 'pics', 'lower.xpm')))
l_btn.connect("clicked", dest_lower)
destbbox.pack_start(l_btn, expand=gtk.FALSE)
self.dest_list = gtk.GtkList()
self.dest_list.set_selection_mode(gtk.SELECTION_BROWSE)
dest_win.add_with_viewport(self.dest_list)
parent.shell.pack_start(self.frame)
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)
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):
# Create a window to put all the widgets in
# connect main_quit() to the "destroy" event of
# the window to handle window manager close-window-events
window = gtk.GtkWindow(gtk.WINDOW_TOPLEVEL)
window.set_title("GtkList Example")
window.connect("destroy", gtk.mainquit)
# Inside the window we need a box to arrange the widgets
# vertically
vbox = gtk.GtkVBox(gtk.FALSE, 5)
vbox.set_border_width(5)
window.add(vbox)
vbox.show()
# This is the scrolled window to put the List widget inside
scrolled_window = gtk.GtkScrolledWindow()
scrolled_window.set_usize(250, 150)
vbox.add(scrolled_window)
scrolled_window.show()
# Create the GtkList widget.
# Connect the sigh_print_selection() signal handler
# function to the "selection_changed" signal of the List
# to print out the selected items each time the selection
# has changed
gtklist = gtk.GtkList()
scrolled_window.add_with_viewport(gtklist)
gtklist.show()
gtklist.connect("selection_changed", self.sigh_print_selection)
# We create a "Prison" to put a list item in )
frame = gtk.GtkFrame("Prison")
frame.set_usize(200, 50)
frame.set_border_width(5)
frame.set_shadow_type(gtk.SHADOW_OUT)
vbox.add(frame)
frame.show()
# Connect the sigh_button_event() signal handler to the List
# which will handle the "arresting" of list items
gtklist.connect("button_release_event", self.sigh_button_event, frame)
# Create a separator
separator = gtk.GtkHSeparator()
vbox.add(separator)
separator.show()
# Finally create a button and connect its "clicked" signal
# to the destruction of the window
button = gtk.GtkButton("Close")
vbox.add(button)
button.show()
button.connect_object("clicked", window.destroy, window)
# Now we create 5 list items, each having its own
# label and add them to the List using add()
# Also we query the text string from the label and
# associate it with the list_item_data_key for each list item
for i in range(5):
buffer = "ListItemContainer with Label #%d" % i
label = gtk.GtkLabel(buffer)
list_item = gtk.GtkListItem()
list_item.add(label)
label.show()
gtklist.add(list_item)
list_item.show()
string = label.get()
list_item.set_data(self.list_item_data_key, string)
# Here, we are creating another 5 labels, this time
# we use GtkListItem() for the creation
# For adding of the list items we put them all into a
# list, and then add them by a single call to
# append_items().
dlist = []
for i in range(5, 10):
buffer = "List Item with Label %d" % i
list_item = gtk.GtkListItem(buffer)
dlist.append(list_item)
list_item.show()
list_item.set_data(self.list_item_data_key,
list_item.children()[0].get())
gtklist.append_items(dlist)
# Finally we want to see the window, don't we? )
window.show()
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 prefs_window():
win = gtk.GtkWindow()
gui["prefs_window"] = win
win.set_policy(gtk.TRUE, gtk.TRUE, gtk.FALSE)
win.set_title("Preferences")
win.connect("delete_event", prefs_window_close)
win.set_border_width(2)
window_pos_mode(win)
frame = gtk.GtkFrame()
frame.show()
frame.set_border_width(2)
win.add(frame)
vbox = gtk.GtkVBox(spacing=5)
vbox.show()
frame.add(vbox)
gui["cb_ascii"] = gtk.GtkCheckButton("ASCII only")
vbox.pack_start(gui["cb_ascii"])
gui["cb_ascii"].connect("toggled", prefs_toggled, 0)
gui["cb_ascii"].show()
gui["cb_rexp"] = gtk.GtkCheckButton("Remember last expression")
vbox.pack_start(gui["cb_rexp"])
gui["cb_rexp"].connect("toggled", prefs_toggled, 1)
gui["cb_rexp"].show()
hbox = gtk.GtkHBox()
vbox.pack_start(hbox)
hbox.show()
label = gtk.GtkLabel(" Window placement: ")
label.show()
hbox.pack_start(label)
menu = gtk.GtkMenu()
menuitem = gtk.GtkMenuItem("None")
menuitem.connect("activate", prefs_selected_1, 0)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("Center")
menuitem.connect("activate", prefs_selected_1, 1)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("Mouse")
menuitem.connect("activate", prefs_selected_1, 2)
menu.append(menuitem)
menuitem.show()
gui["wp_menu"] = gtk.GtkOptionMenu()
gui["wp_menu"].set_menu(menu)
gui["wp_menu"].set_history(
hive.get_integer("/window/placement", default_window_placement))
hbox.pack_start(gui["wp_menu"])
gui["wp_menu"].show()
hbox = gtk.GtkHBox()
vbox.pack_start(hbox)
hbox.show()
label = gtk.GtkLabel(" Binary separators: ")
label.show()
hbox.pack_start(label)
menu = gtk.GtkMenu()
menuitem = gtk.GtkMenuItem("0")
menuitem.connect("activate", prefs_selected_2, 0)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("1")
menuitem.connect("activate", prefs_selected_2, 1)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("3")
menuitem.connect("activate", prefs_selected_2, 2)
menu.append(menuitem)
menuitem.show()
menuitem = gtk.GtkMenuItem("7")
menuitem.connect("activate", prefs_selected_2, 3)
menu.append(menuitem)
menuitem.show()
gui["bs_menu"] = gtk.GtkOptionMenu()
gui["bs_menu"].set_menu(menu)
gui["bs_menu"].set_history(
hive.get_integer("/binary_separators", default_binary_separators))
hbox.pack_start(gui["bs_menu"])
gui["bs_menu"].show()
if hive.get_bool("/ascii_only", default_ascii_only):
gui["cb_ascii"].set_active(gtk.TRUE)
else:
gui["cb_ascii"].set_active(gtk.FALSE)
if hive.get_bool("/remember_expression", default_remember_expression):
gui["cb_rexp"].set_active(gtk.TRUE)
else:
gui["cb_rexp"].set_active(gtk.FALSE)
button = gtk.GtkButton("Close")
button.connect("clicked", prefs_window_close)
vbox.pack_start(button, expand=gtk.FALSE)
button.set_flags(gtk.CAN_DEFAULT)
button.grab_default()
button.show()
gui["main_window"].set_sensitive(gtk.FALSE)
gui["prefs_window"].show()
