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()