def create_geotransform_frame(self): self.frames['Geotransform'] = gtk.GtkFrame('') self.frames['Geotransform'].set_shadow_type(gtk.SHADOW_NONE) vbox = gtk.GtkVBox() vbox.set_spacing(spc) self.frames['Geotransform'].add(vbox) label = gtk.GtkLabel('Xgeo = GT(0) + XPixel*GT(1) + YLine*GT(2)') label.set_alignment(0, 0.5) vbox.pack_start(label) label = gtk.GtkLabel('Ygeo = GT(3) + XPixel*GT(4) + YLine*GT(5)') label.set_alignment(0, 0.5) vbox.pack_start(label) table = gtk.GtkTable(rows=6, cols=3) self.geotransform_entries = [] for idx in range(6): label = gtk.GtkLabel('GT(' + str(idx) + '):') label.set_alignment(0, 0.5) table.attach(label, 0, 1, idx, idx + 1) newentry = gtk.GtkEntry() self.geotransform_entries.append(newentry) table.attach(newentry, 1, 2, idx, idx + 1) vbox.pack_start(table) self.geotransformprjbox = ProjectionBox(self.tips) vbox.pack_start(self.geotransformprjbox) self.frames['Geotransform'].show_all() self.pack_start(self.frames['Geotransform'])
def __init__(self, master, jabberObj): gtk.GtkDialog.__init__(self) self.jid_str = None self.done = None self.connect("delete_event", self.delete_event) self.master = master self.jabber = jabberObj if self.master: self.set_transient_for(self.master) self.set_usize(200, 150) self.table = gtk.GtkTable(5, 2, gtk.FALSE) self.jid_lbl = gtk.GtkLabel('JID') self.jid_entry = gtk.GtkEntry() self.table.attach(self.jid_lbl, 0, 1, 0, 1) self.table.attach(self.jid_entry, 1, 2, 0, 1) self.add_button = gtk.GtkButton('Add') self.add_button.connect('clicked', self.add) self.action_area.pack_start(self.add_button, expand=gtk.FALSE) self.vbox.pack_start(self.table) self.vbox.show_all() self.action_area.show_all() self.show() self.set_modal(gtk.TRUE)
def __init__(self): gtk.GtkFileSelection.__init__(self) self.set_title('Select GCP Text File') self.connect("destroy", self.quit) self.connect("delete_event", self.quit) gtk.grab_add(self) # is modal table = gtk.GtkTable(rows=8, cols=3) self.entries = [] labels = [ 'Delimiter: ', 'Pixel Column # (1-N: required): ', 'Line Column # (required): ', 'X (East/West) Column # (required): ', 'Y (North/South) Column # (required): ', 'Z (Height) Column # (optional): ', 'ID Column # (optional): ', 'Info Column # (optional): ' ] for idx in range(len(labels)): nl = gtk.GtkLabel(labels[idx]) nl.set_alignment(0, 0.5) self.entries.append(gtk.GtkEntry(maxlen=3)) table.attach(nl, 0, 1, idx, idx + 1) table.attach(self.entries[idx], 1, 2, idx, idx + 1) self.main_vbox.pack_end(table) table.show_all() self.cancel_button.connect('clicked', self.quit) self.ok_button.connect('clicked', self.ok_cb) self.ret = None
def __init__(self, fontspec=None, use_font=FALSE): """ Initialize the font selector and optionally load a previous font spec """ gtk.GtkHBox.__init__(self) self.use_font = use_font self.font = XLFDFontSpec() tips = gtk.GtkTooltips() if fontspec is not None: self.font.parse_font_spec(fontspec) else: self.font.set_font_part('Family', 'Arial') self.font.set_font_part('Point Size', '100') table = gtk.GtkTable() self.pack_start(table) table.set_row_spacings(6) table.set_col_spacings(6) table.set_border_width(6) self.font_label = pguFontDisplay() self.font_label.set_text(self.font.get_display_string()) table.attach(self.font_label, 0, 1, 0, 1, xoptions=gtk.SHRINK, yoptions=gtk.SHRINK) tips.set_tip(self.font_label, 'double click to toggle sample mode') font_button = gtk.GtkButton('...') font_button.connect('clicked', self.show_font_dialog) table.attach(font_button, 1, 2, 0, 1, xoptions=gtk.SHRINK, yoptions=gtk.SHRINK) tips.set_tip(font_button, 'click to select a different font') self.show_all() self.font_label.set_events(gtk.GDK.BUTTON_PRESS_MASK) self.font_label.connect('button-press-event', self.label_clicked) self.update_gui() self.publish('font-changed')
def __init__(self, master, jabber, agent=None): gtk.GtkWindow.__init__(self) self.connect("delete_event", self.delete_event) self.master = master self.jabber = jabber self.done = None self.agent = agent self.vbox = gtk.GtkVBox(gtk.FALSE, 5) self.add(self.vbox) self.frame = gtk.GtkFrame("New Account") self.jabber.requestRegInfo(self.agent) req = self.jabber.getRegInfo() self.table = gtk.GtkTable(6, 6, gtk.FALSE) self.instr_lbl = gtk.GtkLabel(req[u'instructions']) self.entrys = {} i = 0 for info in req.keys(): if info != u'instructions' and \ info != u'key': self.entrys[info] = {} self.entrys[info]['lbl'] = gtk.GtkLabel(info) self.entrys[info]['lbl'].set_alignment(1, 0.5) self.entrys[info]['entry'] = gtk.GtkEntry() self.table.attach(self.entrys[info]['lbl'], 0, 2, 1 + i, 2 + i, xpadding=3, ypadding=2) self.table.attach(self.entrys[info]['entry'], 2, 6, 1 + i, 2 + i, xpadding=3, ypadding=2) i = i + 1 self.reg_button = gtk.GtkButton('Register') self.table.attach(self.reg_button, 2, 6, 0, 1, xpadding=3, ypadding=2) self.reg_button.connect('clicked', self.register) self.frame.add(self.table) self.vbox.pack_start(self.frame) self.vbox.show_all() self.show() self.set_modal(gtk.TRUE)
def __init__(self, shapes, shapesgridtool=None): gtk.GtkWindow.__init__(self) self.set_title('Schema') shell = gtk.GtkVBox(spacing=5) shell.set_border_width(10) self.add(shell) self.grid = pgugrid.pguGrid(config=(2, 0, 0, 1, 4, 0, 0, 0)) self.grid.subscribe("cell-changed", self.changed_field) self.shapes = shapes self.shapesgridtool = shapesgridtool shell.pack_start(self.grid) # New field box3 = gtk.GtkTable(rows=5, cols=3) box3.set_row_spacings(5) box3.set_col_spacings(5) box3.set_border_width(10) nf_frame = gtk.GtkFrame('Add Field') nf_frame.add(box3) self.new_field_name_entry = gtk.GtkEntry(10) self.new_field_name_entry.set_text('') self.new_field_name_entry.set_editable(gtk.TRUE) self.new_field_width_entry = gtk.GtkEntry(2) self.new_field_width_entry.set_text('20') self.new_field_width_entry.set_editable(gtk.TRUE) self.new_field_precision_entry = gtk.GtkEntry(2) self.new_field_precision_entry.set_text('0') self.new_field_precision_entry.set_editable(gtk.FALSE) self.new_field_precision_entry.set_sensitive(gtk.FALSE) self.new_field_types = ('string', 'integer', 'float') self.new_field_type_menu = gvutils.GvOptionMenu( self.new_field_types, self.new_field_precision_cb) self.new_field_type_menu.set_history(0) box3.attach(gtk.GtkLabel('Name'), 0, 1, 0, 1) box3.attach(self.new_field_name_entry, 1, 2, 0, 1) box3.attach(gtk.GtkLabel('Type'), 0, 1, 1, 2) box3.attach(self.new_field_type_menu, 1, 2, 1, 2) box3.attach(gtk.GtkLabel('Width'), 0, 1, 2, 3) box3.attach(self.new_field_width_entry, 1, 2, 2, 3) box3.attach(gtk.GtkLabel('Precision'), 0, 1, 3, 4) box3.attach(self.new_field_precision_entry, 1, 2, 3, 4) button = gtk.GtkButton("Add") box3.attach(button, 0, 2, 4, 5) button.connect("clicked", self.add_field) shell.pack_start(nf_frame) nf_frame.show_all() # Ability to delete fields? self.fill_grid() self.grid.resize_to_default() self.show_all()
def init_customize_gui_panel(self): # By now, main panel, basic frames, buttons have been created # Middle frame (region display) must be filled in. patch_table = gtk.GtkTable(1,4,FALSE) self.show_list.append(patch_table) self.frame_dict['base_frame2'].add(patch_table) patch_table.set_border_width(5) patch_table.set_col_spacings(5) patch_table.set_col_spacing(1, 20) label1 = gtk.GtkLabel('Line: ') label1.set_alignment(0, 0.5) patch_table.attach(label1, 0,1, 0, 1) self.entry_dict['line'] = gtk.GtkEntry() self.entry_dict['line'].set_editable(gtk.FALSE) self.entry_dict['line'].set_usize(90, 25) self.entry_dict['line'].set_text('1') patch_table.attach(self.entry_dict['line'], 1,2, 0,1) label2 = gtk.GtkLabel('Pixel: ') label2.set_alignment(0, 0.5) patch_table.attach(label2, 2,3,0, 1) self.entry_dict['pixel'] = gtk.GtkEntry() self.entry_dict['pixel'].set_editable(gtk.FALSE) self.entry_dict['pixel'].set_usize(90, 25) self.entry_dict['pixel'].set_text('1') patch_table.attach(self.entry_dict['pixel'], 3,4, 0,1) # Create tooltips self.tooltips = gtk.GtkTooltips() tip_text = "Re-enable point-of-interest selection mode (" + \ "required for this tool's operation)." self.tooltips.set_tip(self.button_dict['Set Tool'],tip_text) tip_text = 'Automatically update every time the point of ' + \ 'interest changes.' self.tooltips.set_tip(self.button_dict['Auto Update'],tip_text) tip_text = 'Enable/Disable this tool.' self.tooltips.set_tip(self.button_dict['Activate'],tip_text) tip_text = 'Perform analysis.' self.tooltips.set_tip(self.button_dict['Analyze'],tip_text) self.frame_dict['base_frame2'].show_all()
def __init__(self): gtk.GtkDialog.__init__(self) self.jid_str = None self.done = None self.type = 'available' self.connect("delete_event", self.delete_event) #self.master = master #self.jabber = jabberObj self.set_usize(200, 150) self.table = gtk.GtkTable(5, 2, gtk.FALSE) self.jid_lbl = gtk.GtkLabel('Status') self.jid_entry = gtk.GtkEntry() self.table.attach(self.jid_lbl, 0, 1, 0, 1) self.table.attach(self.jid_entry, 1, 2, 0, 1) self.add_button = gtk.GtkButton('Set') self.add_button.connect('clicked', self.set) self.action_area.pack_start(self.add_button, expand=gtk.FALSE) self.avail_radio = gtk.GtkRadioButton(None, 'available') self.unavail_radio = gtk.GtkRadioButton(self.avail_radio, 'unavailable') self.avail_radio.connect('clicked', self.avail) self.unavail_radio.connect('clicked', self.unavail) self.avail_radio.set_active(gtk.TRUE) self.table.attach(self.avail_radio, 0, 2, 1, 2) self.table.attach(self.unavail_radio, 0, 2, 2, 3) self.vbox.pack_start(self.table) self.vbox.show_all() self.action_area.show_all() self.show() self.set_modal(gtk.TRUE)
glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue ) gear( 1.3, 2.0, 0.5, 10, 0.7 ) glEndList() glEnable( GL_NORMALIZE ) if not gtkgl.query(): print "OpenGL not supported. Bye." raise SystemExit win = gtk.GtkWindow() win.connect("destroy", gtk.mainquit) win.set_title("Gears") table = gtk.GtkTable(4, 2) win.add(table) table.show() glarea = gtkgl.GtkGLArea((gtkgl.RGBA, gtkgl.DEPTH_SIZE, 1, gtkgl.DOUBLEBUFFER)) glarea.size(300, 300) glarea.connect("realize", init) glarea.connect("size_allocate", reshape) glarea.connect("expose_event", draw) gtk.idle_add(idle) table.attach(glarea, 0,2, 0,1) glarea.show()
def __init__(self, callback, referenceable=None, initialUser="******", initialPassword="******", initialHostname="localhost", initialPortno=str(pb.portno), initialService="", initialPerspective=""): gtk.GtkWindow.__init__(self, gtk.WINDOW_TOPLEVEL) version_label = gtk.GtkLabel("Twisted v%s" % copyright.version) self.pbReferenceable = referenceable self.pbCallback = callback # version_label.show() self.username = gtk.GtkEntry() self.password = gtk.GtkEntry() self.service = gtk.GtkEntry() self.perspective = gtk.GtkEntry() self.hostname = gtk.GtkEntry() self.port = gtk.GtkEntry() self.password.set_visibility(gtk.FALSE) self.username.set_text(initialUser) self.password.set_text(initialPassword) self.service.set_text(initialService) self.perspective.set_text(initialPerspective) self.hostname.set_text(initialHostname) self.port.set_text(str(initialPortno)) userlbl = gtk.GtkLabel("Username:"******"Password:"******"Service:") perspeclbl = gtk.GtkLabel("Perspective:") hostlbl = gtk.GtkLabel("Hostname:") portlbl = gtk.GtkLabel("Port #:") self.allLabels = [ userlbl, passlbl, servicelbl, perspeclbl, hostlbl, portlbl ] self.logstat = gtk.GtkLabel("Protocol PB-%s" % pb.Broker.version) self.okbutton = cbutton("Log In", self.login) self.okbutton["can_default"] = 1 self.okbutton["receives_default"] = 1 okbtnbx = gtk.GtkHButtonBox() okbtnbx.add(self.okbutton) vbox = gtk.GtkVBox() vbox.add(version_label) table = gtk.GtkTable(2, 6) row = 0 for label, entry in [(userlbl, self.username), (passlbl, self.password), (hostlbl, self.hostname), (servicelbl, self.service), (perspeclbl, self.perspective), (portlbl, self.port)]: table.attach(label, 0, 1, row, row + 1) table.attach(entry, 1, 2, row, row + 1) row = row + 1 vbox.add(table) vbox.add(self.logstat) vbox.add(okbtnbx) self.add(vbox) self.username.grab_focus() self.okbutton.grab_default() for fld in self.username, self.password, self.hostname, self.service, self.perspective: fld.signal_connect('activate', self.login) fld.signal_connect('focus_in_event', selectAll) self.signal_connect('destroy', gtk.mainquit, None)
def showgui_cb(self, *args): if self.dialog is None: self.dialog = gtk.GtkWindow() self.dialog.connect('delete-event', self.close) table = gtk.GtkTable(9, 4) table.set_border_width(10) table.set_row_spacings(10) table.set_col_spacings(10) vbox = gtk.GtkVBox() self.dialog.add(vbox) vbox.pack_start(table) iconbar = gtk.GtkToolbar(gtk.ORIENTATION_HORIZONTAL, gtk.TOOLBAR_ICONS) arrows = [] atypes = [ gtk.ARROW_LEFT, gtk.ARROW_UP, gtk.ARROW_DOWN, gtk.ARROW_RIGHT ] cbs = [ self.rewind_cb, self.speed_up_cb, self.speed_down_cb, self.play_cb ] for atype, cb in map(None, atypes, cbs): arr = gtk.GtkButton() arr.set_border_width(0) arr.set_relief(gtk.RELIEF_NONE) arr.add(gtk.GtkArrow(atype)) arr.connect('clicked', cb) arrows.append(arr) vbox = gtk.GtkVBox(spacing=0, homogeneous=gtk.FALSE) vbox.pack_start(arrows[1], expand=gtk.FALSE) vbox.pack_start(arrows[2], expand=gtk.FALSE) # Now put them in the toolbar iconbar.append_widget(arrows[0], 'Rewind', 'Rewind') iconbar.append_widget(vbox, 'Adjust speed', 'Adjust speed') iconbar.append_widget(arrows[3], 'Play', 'Play') table.attach(iconbar, 0, 1, 0, 1) but = gtk.GtkButton('Stop') table.attach(but, 1, 2, 0, 1) but.connect('clicked', self.stop_pan_cb) but = gtk.GtkButton('Pause') table.attach(but, 2, 3, 0, 1) but.connect('clicked', self.pause_pan_cb) label = gtk.GtkLabel('Block Size Mode:') label.set_alignment(0, 0.5) table.attach(label, 0, 1, 1, 2) self.block_size_menu = gvutils.GvOptionMenu( ('Relative to Pan Extents', 'View Coordinates', 'Constant Resolution'), self.block_mode_changed) table.attach(self.block_size_menu, 1, 3, 1, 2) self.block_label_list = [ 'Block x size (0-1):', 'Block x size:', 'View units/Pixel:' ] self.block_label = gtk.GtkLabel(self.block_label_list[0]) self.block_label.set_alignment(0, 0.5) table.attach(self.block_label, 0, 1, 2, 3) self.block_entry = gtk.GtkEntry() self.block_entry.set_editable(gtk.TRUE) self.block_entry.set_text('0.125') self.block_entry.connect('leave-notify-event', self.block_size_changed) table.attach(self.block_entry, 1, 3, 2, 3) label = gtk.GtkLabel('Overlap (0-1):') label.set_alignment(0, 0.5) table.attach(label, 0, 1, 3, 4) self.overlap_entry = gtk.GtkEntry() self.overlap_entry.set_editable(gtk.TRUE) self.overlap_entry.set_text('0.1') self.overlap_entry.connect('leave-notify-event', self.overlap_changed) table.attach(self.overlap_entry, 1, 3, 3, 4) label = gtk.GtkLabel('Path type:') label.set_alignment(0, 0.5) table.attach(label, 0, 1, 4, 5) self.path_menu = gvutils.GvOptionMenu(('0', '1', '2', '3', '4'), self.path_changed) table.attach(self.path_menu, 1, 3, 4, 5) label = gtk.GtkLabel('Show trail:') label.set_alignment(0, 0.5) table.attach(label, 0, 1, 5, 6) self.trail_menu = gvutils.GvOptionMenu(('No', 'Yes'), self.trail_changed) table.attach(self.trail_menu, 1, 2, 5, 6) button = gtk.GtkButton('Clear Trail') table.attach(button, 2, 3, 5, 6) button.connect('clicked', self.clear_trail) label = gtk.GtkLabel('Trail Color:') label.set_alignment(0, 0.5) table.attach(label, 0, 1, 6, 7) self.trail_color = pgucolorsel.ColorControl( 'Trail Color', self.trail_color_cb) table.attach(self.trail_color, 1, 3, 6, 7) self.trail_color.set_color((1.0, 0.75, 0.0, 0.5)) self.second_view = gview.GvViewArea() self.second_view.set_usize(300, 300) table.attach(self.second_view, 0, 3, 7, 8) self.dialog.show_all() self.dialog.connect('delete-event', self.close) self.viewtitle = args[1] self.dialog.show() self.dialog.get_window()._raise()
def __init__(self, parent_box, title='Input Window'): self.frame = gtk.GtkFrame(title) self.show_list = [] self.show_list.append(self.frame) patch_table = gtk.GtkTable(2, 4, gtk.FALSE) self.show_list.append(patch_table) self.frame.add(patch_table) patch_table.set_border_width(5) patch_table.set_col_spacings(5) patch_table.set_col_spacing(1, 20) label1 = gtk.GtkLabel('Start Line: ') label1.set_alignment(0, 0.5) patch_table.attach(label1, 0, 1, 0, 1) self.entry_dict = {} self.entry_dict['start_line'] = gtk.GtkEntry() self.entry_dict['start_line'].set_editable(gtk.TRUE) self.entry_dict['start_line'].set_usize(90, 25) self.entry_dict['start_line'].set_text('0') patch_table.attach(self.entry_dict['start_line'], 1, 2, 0, 1) label2 = gtk.GtkLabel('Start Pixel: ') label2.set_alignment(0, 0.5) patch_table.attach(label2, 2, 3, 0, 1) self.entry_dict['start_pix'] = gtk.GtkEntry() self.entry_dict['start_pix'].set_editable(gtk.TRUE) self.entry_dict['start_pix'].set_usize(90, 25) self.entry_dict['start_pix'].set_text('0') patch_table.attach(self.entry_dict['start_pix'], 3, 4, 0, 1) label3 = gtk.GtkLabel('Num. of Lines: ') label3.set_alignment(0, 0.5) patch_table.attach(label3, 0, 1, 1, 2) self.entry_dict['num_lines'] = gtk.GtkEntry() self.entry_dict['num_lines'].set_editable(gtk.TRUE) self.entry_dict['num_lines'].set_usize(90, 25) self.entry_dict['num_lines'].set_text('1') patch_table.attach(self.entry_dict['num_lines'], 1, 2, 1, 2) label4 = gtk.GtkLabel('Num. of Pixels: ') label4.set_alignment(0, 0.5) patch_table.attach(label4, 2, 3, 1, 2) self.entry_dict['num_pix'] = gtk.GtkEntry() self.entry_dict['num_pix'].set_editable(gtk.TRUE) self.entry_dict['num_pix'].set_usize(90, 25) self.entry_dict['num_pix'].set_text('1') patch_table.attach(self.entry_dict['num_pix'], 3, 4, 1, 2) self.show_list.append(label1) self.show_list.append(label2) self.show_list.append(label3) self.show_list.append(label4) self.show_list.append(self.entry_dict['start_line']) self.show_list.append(self.entry_dict['start_pix']) self.show_list.append(self.entry_dict['num_lines']) self.show_list.append(self.entry_dict['num_pix']) parent_box.pack_start(self.frame, gtk.FALSE, gtk.FALSE, 0)
def init_dialog(self): self.dialog = gtk.GtkWindow() self.dialog.set_title('GDAL Export Tool') self.dialog.set_border_width(10) self.tips = gtk.GtkTooltips() #self.dialog.set_default_size(500,400) self.dialog.set_policy(gtk.FALSE, gtk.TRUE, gtk.TRUE) # main shell mainshell = gtk.GtkHBox(spacing=1, homogeneous=gtk.FALSE) self.dialog.add(mainshell) self.show_list = [] self.adv_show_list = [] # advanced show list self.show_list.append(mainshell) #navigation shell navshell = gtk.GtkVBox(spacing=1, homogeneous=gtk.FALSE) mainshell.pack_start(navshell) self.show_list.append(navshell) self.frame_dict = {} self.button_dict = {} self.frame_dict['Files'] = gvutils.GvDataFilesFrame( 'Data Files', sel_list=('Input', 'Output')) self.frame_dict['Files'].set_border_width(5) self.frame_dict['Files'].set_spacings(5, 5) self.frame_dict['Files'].show_all() navshell.pack_start(self.frame_dict['Files']) self.show_list.append(self.frame_dict['Files']) bopt_frame = gtk.GtkFrame('Basic Options') self.frame_dict['Basic Options'] = bopt_frame self.show_list.append(bopt_frame) navshell.pack_start(bopt_frame, gtk.FALSE, gtk.FALSE, 0) bopt_table = gtk.GtkTable(2, 4, gtk.FALSE) bopt_table.set_border_width(5) bopt_table.set_row_spacings(5) bopt_table.set_col_spacings(5) bopt_frame.add(bopt_table) self.show_list.append(bopt_table) # Might be nice to have more formats below, but # this involves error checking to test for # supported data types, etc. fmtlabel = gtk.GtkLabel('Output Format: ') fmtlabel.set_alignment(0, 0.5) self.show_list.append(fmtlabel) bopt_table.attach(fmtlabel, 0, 1, 0, 1) self.format_list = [] hist_idx = 0 for iDriver in gdal.GetDriverList(): create = None try: create = iDriver.GetMetadata()["DCAP_CREATE"] except KeyError: try: create = iDriver.GetMetadata()["DCAP_CREATECOPY"] except KeyError: pass if create == "YES": if iDriver.ShortName == 'DTED': # DTED is a special case that needs certain # conditions to be valid. Skip it. continue self.format_list.append(iDriver.ShortName) self.format_list.sort() # Default to GTiff if possible try: hist_idx = self.format_list.index('GTiff') except ValueError: pass self.format_menu = gvutils.GvOptionMenu(self.format_list) self.format_menu.set_history(hist_idx) self.show_list.append(self.format_menu) bopt_table.attach(self.format_menu, 1, 2, 0, 1) self.button_dict['Format_help'] = gtk.GtkButton('Help') self.show_list.append(self.button_dict['Format_help']) bopt_table.attach(self.button_dict['Format_help'], 2, 3, 0, 1) reslabel = gtk.GtkLabel('Output Resolution: ') reslabel.set_alignment(0, 0.5) self.show_list.append(reslabel) bopt_table.attach(reslabel, 0, 1, 1, 2) self.res_list = ['Full', '1:2', '1:4', '1:8'] self.res_menu = gvutils.GvOptionMenu(self.res_list) bopt_table.attach(self.res_menu, 1, 2, 1, 2) self.show_list.append(self.res_menu) self.button_dict['Mode'] = gtk.GtkCheckButton('Advanced Options') navshell.pack_start(self.button_dict['Mode']) self.show_list.append(self.button_dict['Mode']) self.frame_dict['IP_window'] = DataWindowFrame(navshell) self.adv_show_list.append(self.frame_dict['IP_window']) iopt_frame = gtk.GtkFrame('Interactive Options') self.frame_dict['Interactive Options'] = iopt_frame self.adv_show_list.append(iopt_frame) navshell.pack_start(iopt_frame, gtk.FALSE, gtk.FALSE, 0) iopt_table = gtk.GtkTable(3, 3, gtk.FALSE) iopt_table.set_border_width(5) iopt_table.set_row_spacings(5) iopt_table.set_col_spacings(5) iopt_frame.add(iopt_table) self.adv_show_list.append(iopt_table) self.button_dict['IP_window'] = gtk.GtkCheckButton('Window Input File') iopt_table.attach(self.button_dict['IP_window'], 0, 2, 0, 1) self.adv_show_list.append(self.button_dict['IP_window']) self.button_dict['Scale'] = gtk.GtkCheckButton( 'Scale to View Settings') self.tips.set_tip( self.button_dict['Scale'], 'Scale the output bands ' + 'according to the min/max settings of the ' + 'currently active raster layer. This only ' + 'applies to real data.') iopt_table.attach(self.button_dict['Scale'], 0, 2, 1, 2) self.adv_show_list.append(self.button_dict['Scale']) self.button_dict['Refresh'] = gtk.GtkButton( 'Active Layer->Input Filename') self.tips.set_tip( self.button_dict['Refresh'], 'Set the input ' + 'filename to that of the currently active layer') iopt_table.attach(self.button_dict['Refresh'], 0, 1, 2, 3) self.adv_show_list.append(self.button_dict['Refresh']) self.button_dict['Enable_ROI'] = gtk.GtkButton('Draw ROI mode') self.tips.set_tip( self.button_dict['Enable_ROI'], 'Re-activate the ' + 'ROI mode used for interactive input file window definition') iopt_table.attach(self.button_dict['Enable_ROI'], 1, 2, 2, 3) self.adv_show_list.append(self.button_dict['Enable_ROI']) self.frame_dict['Other_Advanced'] = gtk.GtkFrame('') self.frame_dict['Other_Advanced'].set_shadow_type(gtk.SHADOW_NONE) self.adv_show_list.append(self.frame_dict['Other_Advanced']) oadvbox = gtk.GtkVBox(spacing=5, homogeneous=gtk.FALSE) oadvbox.set_border_width(5) self.adv_show_list.append(oadvbox) self.frame_dict['Other_Advanced'].add(oadvbox) otable = gtk.GtkTable(2, 3, gtk.FALSE) otable.set_row_spacings(5) otable.set_col_spacings(5) self.adv_show_list.append(otable) oadvbox.pack_start(otable) self._overview_list = ['None', 'Nearest', 'Average'] self.overview_menu = gvutils.GvOptionMenu(self._overview_list) ovrlabel = gtk.GtkLabel('Overviews:') self.tips.set_tip(self.overview_menu, 'Tiled overview creation options') ovrlabel.set_alignment(0, 0.5) self.adv_show_list.append(ovrlabel) otable.attach(ovrlabel, 0, 1, 0, 1) otable.attach(self.overview_menu, 1, 2, 0, 1) self.adv_show_list.append(self.overview_menu) self._geocode_list = ['Default', 'GCP', 'Geotransform'] self.geocoding_menu = gvutils.GvOptionMenu(self._geocode_list) geolabel = gtk.GtkLabel('Geocoding:') self.tips.set_tip( self.geocoding_menu, 'Specify the type of georeferencing ' + 'information to output. Default is to output ' + 'all available geocoding from the input file. ' + 'If GCP or Geotransform is selected, geocoding ' + 'information will only be output if it is of the ' + 'selected type. This may later be updated to ' + 'generate information of the specified form if ' + 'it is not present but can be accurately computed ' + 'from the existing information.') geolabel.set_alignment(0, 0.5) self.adv_show_list.append(geolabel) otable.attach(geolabel, 0, 1, 1, 2) otable.attach(self.geocoding_menu, 1, 2, 1, 2) self.adv_show_list.append(self.geocoding_menu) opthbox = gtk.GtkHBox(spacing=5, homogeneous=gtk.FALSE) self.adv_show_list.append(opthbox) oadvbox.pack_start(opthbox) optlabel = gtk.GtkLabel('Create Options:') optlabel.set_alignment(0, 0.5) self.adv_show_list.append(optlabel) self.optentry = gtk.GtkEntry() self.optentry.set_editable(editable=gtk.TRUE) self.optentry.set_usize(400, 25) self.optentry.set_text('') self.adv_show_list.append(self.optentry) opthbox.pack_start(optlabel) opthbox.pack_start(self.optentry) navshell.pack_start(self.frame_dict['Other_Advanced'], gtk.FALSE, gtk.FALSE, 0) echbox = gtk.GtkHBox(spacing=5, homogeneous=gtk.FALSE) echbox.set_border_width(3) navshell.pack_end(echbox, gtk.FALSE, gtk.FALSE, 0) self.show_list.append(echbox) self.button_dict['Close'] = gtk.GtkButton('Close') echbox.pack_end(self.button_dict['Close'], expand=gtk.TRUE) self.show_list.append(self.button_dict['Close']) self.button_dict['Export'] = gtk.GtkButton('Export') echbox.pack_end(self.button_dict['Export'], expand=gtk.TRUE) self.show_list.append(self.button_dict['Export']) self.button_dict['Format_help'].connect('clicked', self.format_help_cb) self.button_dict['Enable_ROI'].connect('clicked', self.set_roitool) self.button_dict['Refresh'].connect('clicked', self.refresh_fileinfo) self.button_dict['Export'].connect('clicked', self.export_cb) self.button_dict['Close'].connect('clicked', self.close) self.button_dict['IP_window'].connect('toggled', self.ip_window_toggled_cb) self.button_dict['Mode'].connect('toggled', self.mode_toggled_cb) self.button_dict['IP_window'].set_active(gtk.FALSE) self.button_dict['Mode'].set_active(gtk.FALSE) self.frame_dict['IP_window'].set_entry_sensitivities(gtk.FALSE) # Trap window close event self.dialog.connect('delete-event', self.close) for item in self.show_list: item.show() if self.button_dict['Mode'].get_active(): for item in self.adv_show_list: item.show() else: for item in self.adv_show_list: item.hide()
def _interact(func_name): (blurb, help, author, copyright, date, menupath, imagetypes, plugin_type, params, results, function) = _registered_plugins_[func_name] # short circuit for no parameters ... if len(params) == 0: return [] import gtk import gimpui gtk.rc_parse(gimp.gtkrc()) defaults = _get_defaults(func_name) # define a mapping of param types to edit objects ... class StringEntry(gtk.GtkEntry): def __init__(self, default=''): import gtk gtk.GtkEntry.__init__(self) self.set_text(str(default)) def get_value(self): return self.get_text() class IntEntry(StringEntry): def get_value(self): import string return string.atoi(self.get_text()) class FloatEntry(StringEntry): def get_value(self): import string return string.atof(self.get_text()) class ArrayEntry(StringEntry): def get_value(self): return eval(self.get_text()) class SliderEntry(gtk.GtkHScale): # bounds is (upper, lower, step) def __init__(self, default=0, bounds=(0, 100, 5)): import gtk self.adj = gtk.GtkAdjustment(default, bounds[0], bounds[1], bounds[2], bounds[2], bounds[2]) gtk.GtkHScale.__init__(self, self.adj) def get_value(self): return self.adj.value class SpinnerEntry(gtk.GtkSpinButton): # bounds is (upper, lower, step) def __init__(self, default=0, bounds=(0, 100, 5)): import gtk self.adj = gtk.GtkAdjustment(default, bounds[0], bounds[1], bounds[2], bounds[2], bounds[2]) gtk.GtkSpinButton.__init__(self, self.adj, 1, 0) def get_value(self): return int(self.adj.value) class ToggleEntry(gtk.GtkToggleButton): def __init__(self, default=0): import gtk gtk.GtkToggleButton.__init__(self) self.label = gtk.GtkLabel("No") self.add(self.label) self.label.show() self.connect("toggled", self.changed) self.set_active(default) def changed(self, tog): if tog.active: self.label.set_text("Yes") else: self.label.set_text("No") def get_value(self): return self.get_active() _edit_mapping = { PF_INT8 : IntEntry, PF_INT16 : IntEntry, PF_INT32 : IntEntry, PF_FLOAT : FloatEntry, PF_STRING : StringEntry, PF_INT8ARRAY : ArrayEntry, PF_INT16ARRAY : ArrayEntry, PF_INT32ARRAY : ArrayEntry, PF_FLOATARRAY : ArrayEntry, PF_STRINGARRAY : ArrayEntry, PF_COLOUR : gimpui.ColourSelector, PF_REGION : IntEntry, # should handle differently ... PF_IMAGE : gimpui.ImageSelector, PF_LAYER : gimpui.LayerSelector, PF_CHANNEL : gimpui.ChannelSelector, PF_DRAWABLE : gimpui.DrawableSelector, PF_TOGGLE : ToggleEntry, PF_SLIDER : SliderEntry, PF_SPINNER : SpinnerEntry, PF_FONT : gimpui.FontSelector, PF_FILE : gimpui.FileSelector, PF_BRUSH : gimpui.BrushSelector, PF_PATTERN : gimpui.PatternSelector, PF_GRADIENT : gimpui.GradientSelector, } tooltips = gtk.GtkTooltips() dialog = gtk.GtkDialog() dialog.set_title(func_name) table = gtk.GtkTable(len(params), 3, gtk.FALSE) table.set_border_width(5) table.set_row_spacings(2) table.set_col_spacings(10) dialog.vbox.pack_start(table) table.show() vbox = gtk.GtkVBox(gtk.FALSE, 15) table.attach(vbox, 0,1, 0,len(params), xoptions=gtk.FILL) vbox.show() pix = _get_logo(vbox.get_colormap()) vbox.pack_start(pix, expand=gtk.FALSE) pix.show() label = gtk.GtkLabel(blurb) label.set_line_wrap(TRUE) label.set_justify(gtk.JUSTIFY_LEFT) label.set_usize(100, -1) vbox.pack_start(label, expand=gtk.FALSE) label.show() edit_wids = [] for i in range(len(params)): type = params[i][0] name = params[i][1] desc = params[i][2] def_val = defaults[i] label = gtk.GtkLabel(name) label.set_alignment(1.0, 0.5) table.attach(label, 1,2, i,i+1, xoptions=gtk.FILL) label.show() if type in (PF_SPINNER, PF_SLIDER): wid = _edit_mapping[type](def_val, params[i][4]) else: wid = _edit_mapping[type](def_val) table.attach(wid, 2,3, i,i+1) tooltips.set_tip(wid, desc, None) wid.show() edit_wids.append(wid) def delete_event(win, event=None): import gtk win.hide() gtk.mainquit() return TRUE # this is a hack ... finished = [ 0 ] def ok_clicked(button, win=dialog, finished=finished): import gtk win.hide() finished[0] = 1 gtk.mainquit() b = gtk.GtkButton("OK") b.set_flags(gtk.CAN_DEFAULT) dialog.action_area.pack_start(b) b.grab_default() b.connect("clicked", ok_clicked) b.show() b = gtk.GtkButton("Cancel") b.set_flags(gtk.CAN_DEFAULT) dialog.action_area.pack_start(b) b.connect("clicked", delete_event) b.show() dialog.show() tooltips.enable() # run the main loop gtk.mainloop() ret = None if finished[0]: # OK was clicked ret = map(lambda wid: wid.get_value(), edit_wids) _set_defaults(func_name, ret) dialog.destroy() return ret
def init_customize_gui_panel(self): # Inherit all the usual stuff... General_ROIToolDlg.init_customize_gui_panel(self) # Add new frame with pixel info, keeping track of # the frame and text object... self.frame_dict['region_info_frame'] = gtk.GtkFrame() self.show_list.append(self.frame_dict['region_info_frame']) pixel_vbox = gtk.GtkVBox() self.show_list.append(pixel_vbox) self.frame_dict['region_info_frame'].add(pixel_vbox) pixel_scroll = gtk.GtkScrolledWindow() self.show_list.append(pixel_scroll) pixel_vbox.pack_start(pixel_scroll,expand = gtk.TRUE) self.entry_dict['region_info_text'] = gtk.GtkText() self.show_list.append(self.entry_dict['region_info_text']) self.entry_dict['region_info_text'].set_line_wrap(gtk.FALSE) self.entry_dict['region_info_text'].set_word_wrap(gtk.FALSE) self.entry_dict['region_info_text'].set_editable(gtk.FALSE) pixel_scroll.add(self.entry_dict['region_info_text']) self.entry_dict['region_info_text'].insert_defaults('') # Add a frame with the log file options self.frame_dict['log_frame']=gtk.GtkFrame() self.show_list.append(self.frame_dict['log_frame']) log_table = gtk.GtkTable(2,4,gtk.FALSE) self.show_list.append(log_table) self.frame_dict['log_frame'].add(log_table) log_table.set_border_width(5) log_table.set_col_spacings(5) log_table.set_col_spacing(1, 20) self.button_dict['Log To File'] = gtk.GtkCheckButton('Log To File') self.show_list.append(self.button_dict['Log To File']) log_table.attach(self.button_dict['Log To File'], 0,1, 0, 1) self.button_dict['Select Log'] = gtk.GtkButton('Select Log') self.show_list.append(self.button_dict['Select Log']) log_table.attach(self.button_dict['Select Log'], 3,4, 0, 1) log_label = gtk.GtkLabel('Log File (full path): ') log_label.set_alignment(0, 0.5) log_table.attach(log_label, 0,1, 1, 2) self.entry_dict['log_file'] = gtk.GtkEntry() self.entry_dict['log_file'].set_editable(gtk.TRUE) self.entry_dict['log_file'].set_usize(400,25) self.entry_dict['log_file'].set_text('') log_table.attach(self.entry_dict['log_file'], 1,4, 1,2) self.main_panel.pack_start(self.frame_dict['region_info_frame'],gtk.TRUE,gtk.TRUE,0) self.main_panel.pack_start(self.frame_dict['log_frame'],gtk.FALSE,gtk.FALSE,0) # Customized connections self.button_dict['Select Log'].connect('clicked',self.select_log_cb) # Set default sensitivities for customized tool self.button_dict['Log To File'].set_active(gtk.FALSE) self.button_dict['Log To File'].set_sensitive(gtk.TRUE) self.button_dict['Select Log'].set_sensitive(gtk.TRUE)
glLightModel(GL_LIGHT_MODEL_AMBIENT, [0.2, 0.2, 0.2, 1.0]) glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) glDepthFunc(GL_LESS) glEnable(GL_DEPTH_TEST) if not gtkgl.query(): print "OpenGL not supported. Bye." raise SystemExit win = gtk.GtkWindow() win.connect("destroy", gtk.mainquit) win.set_title("Cone") table = gtk.GtkTable(2, 3) table.set_border_width(5) table.set_col_spacings(5) table.set_row_spacings(5) win.add(table) table.show() vadj = gtk.GtkAdjustment(250, 0, 360, 5, 5, 0) vscale = gtk.GtkVScale(vadj) table.attach(vscale, 1, 2, 0, 1, xoptions=gtk.FILL) vscale.show() hadj = gtk.GtkAdjustment(0, 0, 360, 5, 5, 0) hscale = gtk.GtkHScale(hadj) table.attach(hscale, 0, 1, 1, 2, yoptions=gtk.FILL) hscale.show()
def __init__(self, master): gtk.GtkWindow.__init__(self) self.password = '' self.username = '' self.server = 'jabber.org' self.done = None self.connect("delete_event", self.delete_event) self.master = master self.vbox = gtk.GtkVBox(gtk.FALSE, 5) self.add(self.vbox) self.frame_s = gtk.GtkFrame("Server to use") self.table_s = gtk.GtkTable(1, 6, gtk.FALSE) self.server_lbl = gtk.GtkLabel('Server') self.server_lbl.set_alignment(1, 0.5) self.server_entry = gtk.GtkEntry() self.table_s.attach(self.server_lbl, 0, 2, 0, 1, xpadding=3, ypadding=2) self.table_s.attach(self.server_entry, 2, 6, 0, 1, xpadding=3, ypadding=2) self.frame_s.add(self.table_s) self.vbox.pack_start(self.frame_s) self.frame = gtk.GtkFrame("Have Account?") self.table = gtk.GtkTable(6, 6, gtk.FALSE) self.username_lbl = gtk.GtkLabel('Username') self.username_lbl.set_alignment(1, 0.5) self.password_lbl = gtk.GtkLabel('Password') self.password_lbl.set_alignment(1, 0.5) self.username_entry = gtk.GtkEntry() self.password_entry = gtk.GtkEntry() self.password_entry.set_visibility(gtk.FALSE) self.table.attach(self.username_lbl, 0, 2, 1, 2, xpadding=3, ypadding=2) self.table.attach(self.password_lbl, 0, 2, 2, 3, xpadding=3, ypadding=2) self.table.attach(self.username_entry, 2, 6, 1, 2, xpadding=3, ypadding=2) self.table.attach(self.password_entry, 2, 6, 2, 3, xpadding=3, ypadding=2) self.save_check = gtk.GtkCheckButton('Save Details') self.table.attach(self.save_check, 3, 6, 4, 5, xpadding=3, ypadding=2) self.login_button = gtk.GtkButton('Login') self.login_button.connect('clicked', self.login) self.table.attach(self.login_button, 3, 6, 5, 6, xpadding=5) self.frame.add(self.table) self.vbox.pack_start(self.frame) self.frame_acc = gtk.GtkFrame("New User?") self.table_acc = gtk.GtkTable(1, 1, gtk.FALSE) self.button_acc = gtk.GtkButton("Get an Account") self.button_acc.connect('clicked', self.new_account) self.table_acc.attach(self.button_acc, 0, 1, 0, 1, xpadding=5, ypadding=5) self.frame_acc.add(self.table_acc) self.vbox.pack_end(self.frame_acc) self.readRC() self.username_entry.set_text(self.username) self.password_entry.set_text(self.password) self.server_entry.set_text(self.server) self.vbox.show_all() self.show() self.set_modal(gtk.TRUE)
def __init__(self, classification): """Initialize a GvClassificationDlg on a particular GvLayer""" gtk.GtkWindow.__init__(self) self.set_title('Layer Classification') self.set_usize(-1, 400) self.connect('delete-event', self.close) self.set_border_width(5) self.color_buttons = [] self.sym_menus = [] self.scale_spinners = [] self.view_mgr = None self.ranges = [] self.labels = [] self.reclassdlg = None self.updating = FALSE items = load_ramp_config_file() self.ramp = None if classification is None: self.classification = GvClassification() elif issubclass(classification.__class__, GvClassification): self.classification = classification else: raise TypeError, 'GvClassificationDlg now requires a \ GvClassification instance' if self.classification.count <= 0: self.ramp = items[0] self.classification.prepare_default() #d = self.classification.serialize() #main vertical box vbox = gtk.GtkVBox(spacing=3) save_box = gtk.GtkHButtonBox() btn_save = gtk.GtkButton('Save ...') btn_save.connect('clicked', self.save_cb) btn_load = gtk.GtkButton('Load ...') btn_load.connect('clicked', self.load_cb) save_box.pack_start(btn_load) save_box.pack_start(btn_save) try: import pgucombo self.property_list = pgucombo.pguCombo() except: self.property_list = gtk.GtkCombo() self.property_list.entry.connect('changed', self.property_select_cb) self.update_property_list() save_box.pack_start(self.property_list) vbox.pack_start(save_box, expand=gtk.FALSE) #classification frame class_frame = gtk.GtkFrame() frame_box = gtk.GtkVBox(spacing=3) title_box = gtk.GtkHBox() title_lbl = gtk.GtkLabel('Legend Title: ') self.title_txt = gtk.GtkEntry() self.title_txt.set_text(self.classification.get_title()) self.title_txt.connect('changed', self.title_changed_cb) title_box.pack_start(title_lbl, expand=gtk.FALSE) title_box.pack_start(self.title_txt) frame_box.pack_start(title_box, expand=gtk.FALSE) frame_box.set_border_width(5) #classification list class_box = gtk.GtkScrolledWindow() self.class_list = gtk.GtkList() self.class_list.connect('select-child', self.list_selected) class_box.add_with_viewport(self.class_list) frame_box.pack_start(class_box) self.reset_classification_list() class_frame.add(frame_box) vbox.pack_start(class_frame) ar_box = gtk.GtkHButtonBox() add_btn = gtk.GtkButton('Add class') add_btn.connect('clicked', self.add_class_cb) classify_btn = gtk.GtkButton('reclassify ...') classify_btn.connect('clicked', self.reclassify_cb) reset_btn = gtk.GtkButton('Revert') reset_btn.connect('clicked', self.reset_cb) ar_box.pack_start(add_btn) ar_box.pack_start(classify_btn) ar_box.pack_start(reset_btn) vbox.pack_start(ar_box, expand=gtk.FALSE) #Color Ramp choices ramp_table = gtk.GtkTable(rows=2, cols=2) ramp_table.show() ramp_lbl = gtk.GtkLabel('Color Ramps: ') ramp_lbl.show() ramp_table.attach(ramp_lbl, 0, 1, 0, 1) ramp_opt = gtk.GtkOptionMenu() ramp_opt.show() self.ramp_menu = gtk.GtkMenu() self.ramp_menu.show() ramp_item = gtk.GtkMenuItem() ramp_item.add(gtk.GtkHSeparator()) ramp_item.set_sensitive(gtk.FALSE) ramp_item.show_all self.ramp_menu.append(ramp_item) for n in items: ramp_item = gtk.GtkMenuItem() ramp_item.add(n) ramp_item.show_all() if issubclass(n.__class__, ColorRamp): ramp_item.connect('activate', self.ramp_cb, n) else: ramp_item.set_sensitive(gtk.FALSE) self.ramp_menu.append(ramp_item) ramp_opt.set_menu(self.ramp_menu) ramp_opt.show() ramp_opt.set_history(0) ramp_table.attach(ramp_opt, 1, 2, 0, 1) ramp_table.show_all() vbox.pack_start(ramp_table, expand=gtk.FALSE) #buttons button_box = gtk.GtkHButtonBox() #button_box.set_layout_default(gtk.BUTTONBOX_START) self.ok_button = gtk.GtkButton('OK') self.ok_button.connect('clicked', self.ok_cb) self.apply_button = gtk.GtkButton('Apply') self.apply_button.connect('clicked', self.apply_cb) self.cancel_button = gtk.GtkButton('Cancel') self.cancel_button.connect('clicked', self.cancel_cb) button_box.pack_start(self.ok_button, expand=gtk.FALSE) button_box.pack_start(self.apply_button, expand=gtk.FALSE) button_box.pack_start(self.cancel_button, expand=gtk.FALSE) vbox.pack_start(button_box, expand=gtk.FALSE) vbox.show_all() self.add(vbox) #make ok_button a default button ? why isn't it working ? self.ok_button.set_flags(gtk.CAN_DEFAULT) self.ok_button.grab_default() self.publish('classification-changed') self.update_property_list()
def __init__(self, title=None, cwd=None, dialog_type=FILE_OPEN, filter=None, app=None, multiselect=0): gtk.GtkWindow.__init__(self) if dialog_type >= FILE_OPEN and dialog_type <= DIRECTORY_SELECT: self.dialog_type = dialog_type else: self.dialog_type = FILE_OPEN self.filter = None #current filter self.filters = {} #active filter objects self.filter_keys = [] #ordered list of the names of the filters self.file_selection = [] self.multiselect = multiselect self.set_border_width(5) self.set_policy(as=gtk.FALSE, ag=gtk.FALSE, autos=gtk.TRUE) self.drives = None if title == None: if dialog_type == FILE_OPEN: title = nls.get('filedlg-title-open-file', 'Open File ...') elif dialog_type == FILE_SAVE: title = nls.get('filedlg-title-save-file', 'Save File ...') elif dialog_type == DIRECTORY_SELECT: title = nls.get('filedlg-title-select-directory', 'Select Directory ...') self.set_title(title) #setup the current working directory if cwd is None or not os.path.exists(cwd): cwd = gview.get_preference('working-directory') if cwd is None: cwd = os.getcwd() self.cwd = cwd #widgets vbox = gtk.GtkVBox(spacing=5) if dialog_type == FILE_OPEN or dialog_type == DIRECTORY_SELECT: lbl = gtk.GtkLabel(nls.get('filedlg-label-open-from', 'Open From:')) elif dialog_type == FILE_SAVE: lbl = gtk.GtkLabel(nls.get('filedlg-label-save-in', 'Save In:')) self.opt_menu = gtk.GtkOptionMenu() self.opt_menu.set_menu(gtk.GtkMenu()) hbox = gtk.GtkHBox() hbox.pack_start(lbl, expand=gtk.FALSE) hbox.pack_start(self.opt_menu) vbox.pack_start(hbox, expand = gtk.FALSE) self.list_directory = gtk.GtkCList() scr_directories = gtk.GtkScrolledWindow() scr_directories.add(self.list_directory) self.list_directory.connect('button-press-event', self.directory_selected_cb) if dialog_type == DIRECTORY_SELECT: self.list_files = None vbox.pack_start(scr_directories) else: self.list_files = gtk.GtkCList() if self.multiselect: self.list_files.set_selection_mode( gtk.SELECTION_EXTENDED ) scr_files = gtk.GtkScrolledWindow() scr_files.add(self.list_files) self.list_files.connect('button-press-event', self.file_clicked_cb) self.list_files.connect('select-row', self.file_selected_cb ) self.list_files.connect('unselect-row', self.file_unselected_cb ) pane = gtk.GtkHPaned() scr_directories.set_usize(100, -1) scr_files.set_usize(100, -1) pane.add1(scr_directories) pane.add2(scr_files) pane.set_position(200) vbox.pack_start(pane) widget = None if dialog_type == FILE_SAVE: self.txt_filename = gtk.GtkEntry() widget = self.txt_filename elif dialog_type == FILE_OPEN: combo = gtk.GtkCombo() combo.set_value_in_list(gtk.FALSE, gtk.FALSE) combo.disable_activate() if app is not None: rfl = app.get_rfl() rfl.insert(0, '') combo.set_popdown_strings( rfl ) self.txt_filename = combo.entry widget = combo if widget is not None: table = gtk.GtkTable(rows=2, cols=2) lbl = gtk.GtkLabel(nls.get('filedlg-label-file-name', 'File Name:')) self.txt_filename.connect('focus-out-event', self.map_path_cb) self.txt_filename.connect('key-press-event', self.map_path_cb) table.attach(lbl, 0, 1, 0, 1) table.attach(widget, 1, 2, 0, 1) lbl = gtk.GtkLabel(nls.get('filedlg-label-filter-extension', 'Filter extension:')) self.cmb_filter = pguCombo() self.set_filter(filter) self.cmb_filter.entry.connect('changed', self.filter_cb) table.attach(lbl, 0, 1, 1, 2) table.attach(self.cmb_filter, 1, 2, 1, 2) vbox.pack_start(table, expand=gtk.FALSE) if dialog_type == FILE_SAVE: self.ok_button = gtk.GtkButton(nls.get('filedlg-button-ok', 'OK')) elif dialog_type == FILE_OPEN: self.ok_button = gtk.GtkButton(nls.get('filedlg-button-open', 'Open')) elif dialog_type == DIRECTORY_SELECT: self.ok_button = gtk.GtkButton(nls.get('filedlg-button-ok', 'OK')) self.cancel_button = gtk.GtkButton(nls.get('filedlg-button-cancel', 'Cancel')) self.ok_button.connect('clicked', self.remove_grab) self.ok_button.connect('clicked', self.update_cwd) self.cancel_button.connect('clicked', self.remove_grab) btn_box = gtk.GtkHButtonBox() btn_box.pack_start(self.ok_button) btn_box.pack_start(self.cancel_button) vbox.pack_start(btn_box, expand=gtk.FALSE) self.add(vbox) self.show_all() #make modal gtk.grab_add(self) self.ok_button.set_flags(gtk.CAN_DEFAULT) self.ok_button.grab_default() self.set_usize(400, 400) self.menu_update = gtk.FALSE while gtk.events_pending(): gtk.mainiteration(FALSE) self.refresh_directory() self.connect('delete-event', self.quit) self.ok_button.connect('clicked', self.quit) self.cancel_button.connect('clicked', self.quit) self.publish('quit') self.add_events(gtk.GDK.KEY_PRESS_MASK) self.connect('key-press-event', self.key_press_cb) self.result = 'cancel'
def create_main_window(*args): win = gtk.GtkWindow() gui["main_window"] = win win.set_policy(gtk.TRUE, gtk.TRUE, gtk.FALSE) win.set_title("Clarence " + version) win.set_usize(hive.get_integer("/window/width", default_win_width), hive.get_integer("/window/height", default_win_height)) win.connect("delete_event", gtk.mainquit) window_pos_mode(win) vbox1 = gtk.GtkVBox(spacing=5) win.add(vbox1) vbox1.show() ag = gtk.GtkAccelGroup() itemf = gtk.GtkItemFactory(gtk.GtkMenuBar, "<main>", ag) gui["main_window"].add_accel_group(ag) itemf.create_items([ ('/_Misc', None, None, 0, '<Branch>'), ('/_Misc/_Clear', 'Escape', main_menu, 1, ''), ('/_Misc/sep1', None, None, 0, '<Separator>'), ('/_Misc/Pre_ferences', '<control>P', main_menu, 3, ''), ('/_Misc/sep1', None, None, 0, '<Separator>'), ('/_Misc/E_xit', '<alt>X', main_menu, 2, ''), ('/_Insert', None, None, 0, '<Branch>'), ('/_Insert/_Bin value', '<control>comma', insert_menu, 1, ''), ('/_Insert/_ASCII chars', '<control>period', insert_menu, 2, ''), ('/_Insert/_Last result', '<control>slash', insert_menu, 3, ''), ('/_Select', None, None, 0, '<Branch>'), ('/_Select/_Decimal field', '<control>1', select_menu, 1, ''), ('/_Select/_Hexadecimal field', '<control>2', select_menu, 2, ''), ('/_Select/_Octal field', '<control>3', select_menu, 3, ''), ('/_Select/_ASCII field', '<control>4', select_menu, 4, ''), ('/_Select/_Binary field', '<control>5', select_menu, 5, ''), ('/_Select/sep1', None, None, 0, '<Separator>'), ('/_Select/_Clear fields', '<control>0', select_menu, 6, ''), ('/_Help', None, None, 0, '<LastBranch>'), ('/_Help/Functions list', 'F1', functions_help_window, 1, ''), ('/_Help/sep1', None, None, 0, '<Separator>'), ('/_Help/_About', '<control>I', help_menu, 1, '') ]) menubar = itemf.get_widget('<main>') if (gui["disable_menu"] == 0): vbox1.pack_start(menubar, expand=gtk.FALSE) menubar.show() vbox2 = gtk.GtkVBox(spacing=5) vbox1.pack_start(vbox2, expand=gtk.TRUE) vbox2.show() entry = gtk.GtkEntry() gui["main_entry"] = entry vbox2.pack_start(entry, expand=gtk.FALSE) vbox2.set_border_width(4) set_font(entry) if hive.get_bool("/remember_expression", default_remember_expression): entry.set_text( hive.get_string("/last_expression", default_last_expression)) entry.connect("key_press_event", key_function) entry.grab_focus() gui["main_entry"].show() frame = gtk.GtkFrame() vbox2.pack_start(frame) frame.show() vbox3 = gtk.GtkVBox() frame.add(vbox3) vbox3.show() table = gtk.GtkTable(2, 5, gtk.FALSE) table.set_row_spacings(5) table.set_col_spacings(5) table.set_border_width(10) vbox3.pack_start(table) table.show() for y in range(5): label = gtk.GtkLabel(labels[y]) set_font(label) label.show() table.attach(label, 0, 1, y, y + 1) entry = gtk.GtkEntry() gui[entries[y]] = entry entry.set_editable(gtk.FALSE) entry.set_usize(260, -2) set_font(entry) entry.show() table.attach(entry, 1, 2, y, y + 1) gui["main_window"].show() if hive.get_string("/remember_expression", default_remember_expression): result(hive.get_string("/last_expression", default_last_expression)) else: result(0)
def init_dialog(self): self.dialog = gtk.GtkWindow() self.dialog.set_title('Available Image Formats') self.dialog.set_usize(300, 500) self.dialog.set_border_width(10) self.dialog.set_policy(gtk.FALSE, gtk.TRUE, gtk.TRUE) self.tooltips = gtk.GtkTooltips() self.button_dict = {} # main shell mainshell = gtk.GtkVBox(spacing=1, homogeneous=gtk.FALSE) self.dialog.add(mainshell) self.show_list = [] self.show_list.append(mainshell) #frame1=gtk.GtkFrame('Supported') #self.show_list.append(frame1) #mainshell.pack_start(frame1,expand=gtk.FALSE) #num_s=len(self.supported_list) #if num_s > 0: # s_table = gtk.GtkTable(num_s,3) # row=0 # for fmt_list in self.supported_list: # clabel=gtk.GtkEntry() # clabel.set_editable(gtk.FALSE) # clabel.set_text(fmt_list[0]) # self.show_list.append(clabel) # self._make_tooltip(clabel,fmt_list) # s_table.attach(clabel,0,1,row,row+1) # if fmt_list[4] is not None: # self.button_dict[fmt_list[1]]=gtk.GtkButton('Help') # self.button_dict[fmt_list[1]].connect('clicked',self.help_clicked_cb,fmt_list[4]) # s_table.attach(self.button_dict[fmt_list[1]],1,2,row,row+1) # row=row+1 # frame1.add(s_table) # self.show_list.append(s_table) num_us = len(self.unsupported_list) frame2 = gtk.GtkFrame() pixel_scroll = gtk.GtkScrolledWindow() self.show_list.append(pixel_scroll) self.show_list.append(frame2) mainshell.pack_start(frame2) frame2.add(pixel_scroll) num_us = len(self.unsupported_list) if num_us > 0: us_table = gtk.GtkTable(num_us, 3) row = 0 for fmt_list in self.unsupported_list: clabel = gtk.GtkEntry() clabel.set_editable(gtk.FALSE) clabel.set_text(fmt_list[0]) self.show_list.append(clabel) self._make_tooltip(clabel, fmt_list) us_table.attach(clabel, 0, 1, row, row + 1) if fmt_list[4] is not None: self.button_dict[fmt_list[1]] = gtk.GtkButton('Help') self.button_dict[fmt_list[1]].connect( 'clicked', self.help_clicked_cb, fmt_list[4]) us_table.attach(self.button_dict[fmt_list[1]], 1, 2, row, row + 1) row = row + 1 pixel_scroll.add_with_viewport(us_table) self.show_list.append(us_table) self.button_dict['close'] = gtk.GtkButton('Close') self.button_dict['close'].connect('clicked', self.close) mainshell.pack_start(self.button_dict['close'], expand=gtk.FALSE) self.show_list.append(self.button_dict['close']) self.dialog.connect('delete-event', self.close) for item in self.show_list: item.show()