def createLineWidget(self): self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL) options = ["None", "Solid", "Dashed", "Dotted"] frame = gtk.Frame('Line') frame.set_border_width(0) frame.set_size_request(200, 400) frame.show() label = gtk.Label("Line option: ") label.show() vbox = gtk.VBox(False, 5) hbox = gtk.HBox(False, 0) hbox.pack_start(label, False, True, 0) hbox.show() option_line = gtk.combo_box_new_text() for opt in options: option_line.append_text(opt) option_line.set_active(0) option_line.set_size_request(85, -1) option_line.show() global_var.dialogWidget[ 'lineOption'] = option_line # Keep line option on global variable hbox.pack_start(option_line, False, True, 0) vbox.pack_start(hbox, False, True, 0) #Create Line Color label_color = gtk.Label("Line color : ") label_color.show() hbox = gtk.HBox(False, 0) hbox.pack_start(label_color, False, True, 0) hbox.show() #...Create color button colorbutton = gtk.ColorButton( gtk.gdk.color_parse('#CC3300')) # Display current fill color colorbutton.connect('color-set', self.color_set_cb) colorbutton.show() colorbutton.set_size_request(45, 45) global_var.dialogWidget['lineColor'] = colorbutton hbox.pack_start(colorbutton, False, True, 0) vbox.pack_start(hbox, False, True, 0) #----Line 3--------------------------- label_width = gtk.Label("Line width : ") label_width.show() hbox = gtk.HBox(False, 0) hbox.pack_start(label_width, False, True, 0) hbox.show() vbox.pack_start(hbox, False, True, 0) # add combo with image line width combo_img = self.createLineWidth() hbox.pack_start(combo_img, False, True, 0) global_var.dialogWidget['lineWidth'] = combo_img #line 4---dash---------------------------- label_dash = gtk.Label("Dash Type : ") label_dash.show() hbox = gtk.HBox(False, 0) hbox.pack_start(label_dash, False, True, 0) hbox.show() vbox.pack_start(hbox, False, True, 0) # add combo with image line width combo_dash = self.createDashType() hbox.pack_start(combo_dash, False, True, 0) global_var.dialogWidget['lineDash'] = combo_dash #label.show() #line 5 ------------------------------ label_curve = gtk.Label("Radius : ") label_curve.show() hbox = gtk.HBox(False, 0) hbox.pack_start(label_curve, False, True, 0) hbox.show() adj_hscale = gtk.Adjustment(0, 0, 50, 1.0, 5.0, 0.0) hscale = gtk.HScale(adj_hscale) hscale.set_size_request(30, -1) hscale.set_value_pos(gtk.POS_RIGHT) hscale.set_draw_value(False) hscale.set_digits(1) hbox.pack_start(hscale, True, True, 0) hscale.show() global_var.dialogWidget['lineCurve_hscale'] = hscale adj_spin = gtk.Adjustment(0, 0, 50, 1.0, 5.0, 0.0) spinner = gtk.SpinButton(adj_spin, 0, 0) spinner.set_wrap(False) spinner.set_size_request(35, -1) hbox.pack_start(spinner, True, True, 0) spinner.show() global_var.dialogWidget['lineCurve_spinner'] = spinner item = None adj_spin.connect("value_changed", self.change_curve_level, spinner, adj_hscale, item, "spinner") adj_hscale.connect("value_changed", self.change_curve_level, spinner, adj_hscale, item, "hscale") vbox.pack_start(hbox, False, True, 0) frame.add(vbox) vbox.show() self.size_group.add_widget(label) self.size_group.add_widget(label_color) self.size_group.add_widget(label_width) self.size_group.add_widget(label_dash) self.size_group.add_widget(label_curve) return frame
def __init__(self): self.agregar = gtk.VBox() self.agregar.show() #<uncomment for PC> # #Guardar y cargar #herr = gtk.Frame(_("Tools")) #herr.show() #cont1 = gtk.VBox(False, 5) #cont1.show() #h3 = gtk.VBox(False, 5) #h3.show() #h4 = gtk.HBox() #h4.show() #</uncomment for PC> self.adj = None self.history = None #Deshacer y borrar herr = gtk.Frame(_("Tools")) herr.show() cont1 = gtk.VBox(False, 5) cont1.show() h3 = gtk.VBox() h3.show() h4 = gtk.HBox() h4.show() self.borrar = gtk.Button(_("Erase")) self.borrar.connect("button_press_event", self.__clicBorrar) self.borrar.show() h3.add(self.borrar) #<uncomment for PC> #self.keep = gtk.Button(_("Save")) #self.keep.show() #h3.add(self.keep) #self.open = gtk.Button(_("Load")) #self.open.show() #h3.add(self.open) #</uncomment for PC> h = gtk.Frame(_("History")) h.show() h3.add(h) self.cont2 = gtk.VBox() self.cont2.show() h.add(self.cont2) self.undo = gtk.Button(_("Undo")) self.undo.show() self.cont2.add(self.undo) self.cargarAdj(0, 0, 0, 1, 1) z = gtk.Frame(_("Zoom")) z.show() h3.add(z) self.adj2 = gtk.Adjustment(2, 1, 4, 1, 1) self.zoom = gtk.HScale(self.adj2) self.zoom.set_digits(0) self.zoom.show() z.add(self.zoom) cont1.add(h3) cont1.add(h4) herr.add(cont1) #Operaciones oper = gtk.Frame(_("Start new operation")) oper.show() cont = gtk.VBox(False, 5) cont.show() h1 = gtk.HBox() h1.show() h2 = gtk.HBox() h2.show() self.suma = gtk.Button(_("Addition")) self.suma.show() h1.add(self.suma) self.resta = gtk.Button(_("Subtraction")) self.resta.show() h1.add(self.resta) self.mult = gtk.Button(_("Multiplication")) self.mult.show() h2.add(self.mult) self.div = gtk.Button(_("Division")) self.div.show() h2.add(self.div) cont.add(h1) cont.add(h2) oper.add(cont) self.agregar.add(oper) self.agregar.add(herr)
def __init__(self, handle): """Set up the Chutar activity.""" activity.Activity.__init__(self, handle) # we do not have collaboration features # make the share option insensitive self.max_participants = 1 # toolbar with the new toolbar redesign toolbar_box = ToolbarBox() activity_button = ActivityButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() title_entry = TitleEntry(self) toolbar_box.toolbar.insert(title_entry, -1) title_entry.show() share_button = ShareButton(self) toolbar_box.toolbar.insert(share_button, -1) share_button.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() hbox = gtk.HBox() vbox = gtk.VBox() #se usaran para el marcador self.label = gtk.Label() self.label.modify_font(pango.FontDescription("Purisa 14")) frame = gtk.Frame("Marcador") #asignacion de variables a widgest de gtk self.vadjustment = gtk.Adjustment() self.hadjustment = gtk.Adjustment() #asignacion de valores por defecto del adjustment self.vadjustment.set_upper(100) self.vadjustment.set_value(0) self.hadjustment.set_upper(100) self.hadjustment.set_value(0) #asignacion de propiedades de widgets self.vslide = gtk.VScale(self.vadjustment) self.hslide = gtk.HScale(self.hadjustment) #propiedad para que no se muestre valor del slide self.vslide.set_draw_value(False) self.hslide.set_draw_value(False) #variables globales que se utilizan en los slides self.increment_x = self.increment_y = 1 self.indicator_x = self.indicator_y = -1 self.goles = 0 #asignacion de variables de widgets self.drawing_area = gtk.DrawingArea() self.drawing_area.set_size_request(WIDTH, HEIGHT) #asignando cancha y arquero self.cancha = gtk.gdk.pixbuf_new_from_file('images/arcosugar.jpg') self.portero = gtk.gdk.pixbuf_new_from_file( 'images/goalkeeper_downcenter.png') #window.connect("destroy", lambda w: gtk.main_quit()) #callbacks al invocar el area de dibujo self.drawing_area.connect('configure_event', self.__configure_cb) self.drawing_area.connect('expose-event', self.__expose_cb) #evento que invoca funcion al presionar cualquier tecla self.connect('key-press-event', self.__key_press_event_cb) #anhadiendo widgets dentro del contenedor principal self.set_canvas(hbox) hbox.add(vbox) frame.add(self.label) vbox.add(frame) vbox.add(self.drawing_area) vbox.add(self.hslide) hbox.add(self.vslide) #mostrando los widgets self.show_all() #invocacion de la funcion que realiza loop del slider horizontal gobject.timeout_add(DELAY, self.__hslider_move_cb)
pack(notebook, row, col) row += 1 button = gtk.Button("Button") pack(button, row, col) row += 1 checkbutton = gtk.CheckButton("CheckButton") pack(checkbutton, row, col) row += 1 progress = gtk.ProgressBar() pack(progress, row, col) row += 1 scale = gtk.HScale() pack(scale, row, col) row += 1 entry = gtk.Entry() pack(entry, row, col) row += 1 togglebutton = gtk.ToggleButton() pack(togglebutton, row, col) togglebutton.set_active(True) row += 1 drawing_area.connect("expose-event", save_callback) # gobject.timeout_add(2000, save_callback)
def __init__(self): # read initialisation file try: initVals = fileIO.readInitFile("InitFile.sem") except IOError: print "Initialisation file not found. Creating new file..." fileIO.writeInitFile("InitFile.sem") initVals = fileIO.readInitFile("InitFile.sem") #make serial connection try: self.serial = serial.Serial(port='COM5', baudrate=115200, bytesize=8, parity='N', stopbits=1, timeout=2) self.serial.close() except serial.serialutil.SerialException: self.serial = None #make an empty list of objects to show toShow = [] # create a new window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) toShow.append(self.window) self.window.set_title("SEM Control Panel") #self.window.set_default_size(800,600) # When the window is given the "delete_event" signal (this is given # by the window manager, usually by the "close" option, or on the # titlebar), we ask it to call the delete_event () function # as defined above. The data passed to the callback # function is NULL and is ignored in the callback function. self.window.connect("delete_event", self.delete_event) # Here we connect the "destroy" event to a signal handler. # This event occurs when we call gtk_widget_destroy() on the window, # or if we return FALSE in the "delete_event" callback. self.window.connect("destroy", self.destroy) #next, we make the layout boxes of the window self.mainBox = gtk.VBox() toShow.append(self.mainBox) self.window.add(self.mainBox) self.bottomBox = gtk.HBox() toShow.append(self.bottomBox) self.mainBox.pack_end(self.bottomBox, fill=False) self.textFirst = gtk.Label("Get Screenshot") toShow.append(self.textFirst) self.buttonFirst = gtk.Button("Start") toShow.append(self.buttonFirst) self.buttonFirst.connect("clicked", self.makeScreenshot, None) self.bottomBox.pack_start(self.textFirst, fill=False) self.bottomBox.pack_end(self.buttonFirst, fill=False) #mode buttons self.modeButtonBox = gtk.HBox() toShow.append(self.modeButtonBox) self.mainBox.pack_start(self.modeButtonBox, fill=False) self.modeButtonSubBox1 = gtk.VBox() toShow.append(self.modeButtonSubBox1) self.modeButtonSubBox2 = gtk.VBox() toShow.append(self.modeButtonSubBox2) self.modeButtonBox.pack_start(self.modeButtonSubBox1, fill=False) self.modeButtonBox.pack_start(self.modeButtonSubBox2, fill=False) self.modeLabel = gtk.Label("Current mode :") toShow.append(self.modeLabel) self.currentMode = gtk.Label("Slow 1") toShow.append(self.currentMode) self.modeButtonSubBox1.pack_start(self.modeLabel, fill=False) self.modeButtonSubBox1.pack_start(self.currentMode, fill=False) #===================== making variable ===================== self.modeVar = "Slow 1" #===================== making variable ===================== self.modeButtonSubBox2Top = gtk.HBox() toShow.append(self.modeButtonSubBox2Top) self.modeButtonSubBox2Bot = gtk.HBox() toShow.append(self.modeButtonSubBox2Bot) self.modeButtonSubBox2.pack_start(self.modeButtonSubBox2Top, fill=False) self.modeButtonSubBox2.pack_start(self.modeButtonSubBox2Bot, fill=False) self.slowOneButton = gtk.Button("Slow 1") toShow.append(self.slowOneButton) self.slowTwoButton = gtk.Button("Slow 2") toShow.append(self.slowTwoButton) self.photoButton = gtk.Button("Photo") toShow.append(self.photoButton) self.fastButton = gtk.Button("Fast") toShow.append(self.fastButton) self.TVButton = gtk.Button("TV") toShow.append(self.TVButton) self.modeButtonSubBox2Top.pack_start(self.slowOneButton, fill=False) self.modeButtonSubBox2Top.pack_start(self.slowTwoButton, fill=False) self.modeButtonSubBox2Top.pack_start(self.photoButton, fill=False) self.modeButtonSubBox2Bot.pack_start(self.fastButton, fill=False) self.modeButtonSubBox2Bot.pack_start(self.TVButton, fill=False) self.slowOneButton.connect("clicked", self.changeMode, self.slowOneButton.get_label()) self.slowTwoButton.connect("clicked", self.changeMode, self.slowTwoButton.get_label()) self.photoButton.connect("clicked", self.changeMode, self.photoButton.get_label()) self.fastButton.connect("clicked", self.changeMode, self.fastButton.get_label()) self.TVButton.connect("clicked", self.changeMode, self.TVButton.get_label()) # next, we set up buttons that choose input type # values are either secondary electrons, x-ray or auxillary self.collectionModeButtonBox = gtk.HBox() toShow.append(self.collectionModeButtonBox) self.mainBox.pack_start(self.collectionModeButtonBox, fill=False) self.inputTypeLabel = gtk.Label("Input type: ") toShow.append(self.inputTypeLabel) self.collectionModeButtonBox.pack_start(self.inputTypeLabel, fill=False) self.SEButton = gtk.Button("Secondary Electron") toShow.append(self.SEButton) self.collectionModeButtonBox.pack_start(self.SEButton, fill=False) self.xRayButton = gtk.Button("X-Ray") toShow.append(self.xRayButton) self.collectionModeButtonBox.pack_start(self.xRayButton, fill=False) self.auxButton = gtk.Button("Auxiliary") toShow.append(self.auxButton) self.collectionModeButtonBox.pack_start(self.auxButton, fill=False) self.SEButton.connect("clicked", self.inputModeChangeWrapper, self.SEButton.get_label()) self.xRayButton.connect("clicked", self.inputModeChangeWrapper, self.xRayButton.get_label()) self.auxButton.connect("clicked", self.inputModeChangeWrapper, self.auxButton.get_label()) #===================== making variable ===================== self.inTypeVar = None #===================== making variable ===================== # sliders/spinbuttons # format is: # Name of variable; value in spinbutton; slider that is connected to the same variable #------------------------------------------------------------------------------------------------- toAdd = [None, 0, -100, 100, 1, 10] for varHold in initVals: if varHold[0] == "xShift": toAdd = varHold self.shiftXBox = gtk.HBox() self.mainBox.pack_start(self.shiftXBox, fill=False) toShow.append(self.shiftXBox) self.shiftXLabel = gtk.Label("X Shift") toShow.append(self.shiftXLabel) self.shiftXBox.pack_start(self.shiftXLabel, fill=False) self.shiftXAdjustment = gtk.Adjustment(value=toAdd[1], lower=toAdd[2], upper=toAdd[3], step_incr=toAdd[4], page_incr=toAdd[5]) #===================== making variable ===================== self.shiftXVar = self.shiftXAdjustment.get_value() #===================== making variable ===================== self.shiftXAdjustment.connect("value_changed", self.adjusted, 1) self.shiftXSpinButton = gtk.SpinButton( adjustment=self.shiftXAdjustment, climb_rate=0.0, digits=0) toShow.append(self.shiftXSpinButton) self.shiftXBox.pack_start(self.shiftXSpinButton, fill=False) self.shiftXSlider = gtk.HScale(adjustment=self.shiftXAdjustment) toShow.append(self.shiftXSlider) self.shiftXBox.pack_start(self.shiftXSlider, fill=True) #------------------------------------------------------------------------------------------------- toAdd = [None, 0, -100, 100, 1, 10] for varHold in initVals: if varHold[0] == "yShift": toAdd = varHold self.shiftYBox = gtk.HBox() self.mainBox.pack_start(self.shiftYBox, fill=False) toShow.append(self.shiftYBox) self.shiftYLabel = gtk.Label("Y Shift") toShow.append(self.shiftYLabel) self.shiftYBox.pack_start(self.shiftYLabel, fill=False) self.shiftYAdjustment = gtk.Adjustment(value=toAdd[1], lower=toAdd[2], upper=toAdd[3], step_incr=toAdd[4], page_incr=toAdd[5]) #===================== making variable ===================== self.shiftYVar = self.shiftYAdjustment.get_value() #===================== making variable ===================== self.shiftYAdjustment.connect("value_changed", self.adjusted, 2) self.shiftYSpinButton = gtk.SpinButton( adjustment=self.shiftYAdjustment, climb_rate=0.0, digits=0) toShow.append(self.shiftYSpinButton) self.shiftYBox.pack_start(self.shiftYSpinButton, fill=False) self.shiftYSlider = gtk.HScale(adjustment=self.shiftYAdjustment) toShow.append(self.shiftYSlider) self.shiftYBox.pack_start(self.shiftYSlider, fill=True) #------------------------------------------------------------------------------------------------- toAdd = [None, 0, -100, 100, 1, 10] for varHold in initVals: if varHold[0] == "xStig": toAdd = varHold self.stigXBox = gtk.HBox() self.mainBox.pack_start(self.stigXBox, fill=False) toShow.append(self.stigXBox) self.stigXLabel = gtk.Label("X Stigmation") toShow.append(self.stigXLabel) self.stigXBox.pack_start(self.stigXLabel, fill=False) self.stigXAdjustment = gtk.Adjustment(value=toAdd[1], lower=toAdd[2], upper=toAdd[3], step_incr=toAdd[4], page_incr=toAdd[5]) #===================== making variable ===================== self.stigXVar = self.stigXAdjustment.get_value() #===================== making variable ===================== self.stigXAdjustment.connect("value_changed", self.adjusted, 3) self.stigXSpinButton = gtk.SpinButton(adjustment=self.stigXAdjustment, climb_rate=0.0, digits=0) toShow.append(self.stigXSpinButton) self.stigXBox.pack_start(self.stigXSpinButton, fill=False) self.stigXSlider = gtk.HScale(adjustment=self.stigXAdjustment) toShow.append(self.stigXSlider) self.stigXBox.pack_start(self.stigXSlider, fill=True) #------------------------------------------------------------------------------------------------- toAdd = [None, 0, -100, 100, 1, 10] for varHold in initVals: if varHold[0] == "yStig": toAdd = varHold self.stigYBox = gtk.HBox() self.mainBox.pack_start(self.stigYBox, fill=False) toShow.append(self.stigYBox) self.stigYLabel = gtk.Label("Y Stigmation") toShow.append(self.stigYLabel) self.stigYBox.pack_start(self.stigYLabel, fill=False) self.stigYAdjustment = gtk.Adjustment(value=toAdd[1], lower=toAdd[2], upper=toAdd[3], step_incr=toAdd[4], page_incr=toAdd[5]) #===================== making variable ===================== self.stigYVar = self.stigYAdjustment.get_value() #===================== making variable ===================== self.stigYAdjustment.connect("value_changed", self.adjusted, 4) self.stigYSpinButton = gtk.SpinButton(adjustment=self.stigYAdjustment, climb_rate=0.0, digits=0) toShow.append(self.stigYSpinButton) self.stigYBox.pack_start(self.stigYSpinButton, fill=False) self.stigYSlider = gtk.HScale(adjustment=self.stigYAdjustment) toShow.append(self.stigYSlider) self.stigYBox.pack_start(self.stigYSlider, fill=True) #------------------------------------------------------------------------------------------------- toAdd = [None, 0, -100, 100, 1, 10] for varHold in initVals: if varHold[0] == "condLens": toAdd = varHold self.condBox = gtk.HBox() self.mainBox.pack_start(self.condBox, fill=False) toShow.append(self.condBox) self.condLabel = gtk.Label("Condenser Lens") toShow.append(self.condLabel) self.condBox.pack_start(self.condLabel, fill=False) self.condAdjustment = gtk.Adjustment(value=toAdd[1], lower=toAdd[2], upper=toAdd[3], step_incr=toAdd[4], page_incr=toAdd[5]) #===================== making variable ===================== self.condVar = self.condAdjustment.get_value() #===================== making variable ===================== self.condAdjustment.connect("value_changed", self.adjusted, 5) self.condSpinButton = gtk.SpinButton(adjustment=self.condAdjustment, climb_rate=0.0, digits=0) toShow.append(self.condSpinButton) self.condBox.pack_start(self.condSpinButton, fill=False) self.condSlider = gtk.HScale(adjustment=self.condAdjustment) toShow.append(self.condSlider) self.condBox.pack_start(self.condSlider, fill=True) #------------------------------------------------------------------------------------------------- toAdd = [None, 0, -100, 100, 1, 10] for varHold in initVals: if varHold[0] == "objLens": toAdd = varHold self.objBox = gtk.HBox() self.mainBox.pack_start(self.objBox, fill=False) toShow.append(self.objBox) self.objLabel = gtk.Label("Objective Lens") toShow.append(self.objLabel) self.objBox.pack_start(self.objLabel, fill=False) self.objAdjustment = gtk.Adjustment(value=toAdd[1], lower=toAdd[2], upper=toAdd[3], step_incr=toAdd[4], page_incr=toAdd[5]) #===================== making variable ===================== self.objVar = self.objAdjustment.get_value() #===================== making variable ===================== self.objAdjustment.connect("value_changed", self.adjusted, 6) self.objSpinButton = gtk.SpinButton(adjustment=self.objAdjustment, climb_rate=0.0, digits=0) toShow.append(self.objSpinButton) self.objBox.pack_start(self.objSpinButton, fill=False) self.objSlider = gtk.HScale(adjustment=self.objAdjustment) toShow.append(self.objSlider) self.objBox.pack_start(self.objSlider, fill=True) #------------------------------------------------------------------------------------------------- toAdd = [None, 0, -100, 100, 1, 10] for varHold in initVals: if varHold[0] == "filaCurrent": toAdd = varHold self.filaBox = gtk.HBox() self.mainBox.pack_start(self.filaBox, fill=False) toShow.append(self.filaBox) self.filaLabel = gtk.Label("Filament Current") toShow.append(self.filaLabel) self.filaBox.pack_start(self.filaLabel, fill=False) self.filaAdjustment = gtk.Adjustment(value=toAdd[1], lower=toAdd[2], upper=toAdd[3], step_incr=toAdd[4], page_incr=toAdd[5]) #===================== making variable ===================== self.filaVar = self.filaAdjustment.get_value() #===================== making variable ===================== self.filaAdjustment.connect("value_changed", self.adjusted, 7) self.filaSpinButton = gtk.SpinButton(adjustment=self.filaAdjustment, climb_rate=0.0, digits=0) toShow.append(self.filaSpinButton) self.filaBox.pack_start(self.filaSpinButton, fill=False) self.filaSlider = gtk.HScale(adjustment=self.filaAdjustment) toShow.append(self.filaSlider) self.filaBox.pack_start(self.filaSlider, fill=True) #------------------------------------------------------------------------------------------------- toAdd = [None, 0, -100, 100, 1, 10] for varHold in initVals: if varHold[0] == "mag": toAdd = varHold self.magBox = gtk.HBox() self.mainBox.pack_start(self.magBox, fill=False) toShow.append(self.magBox) self.magLabel = gtk.Label("Magnification") toShow.append(self.magLabel) self.magBox.pack_start(self.magLabel, fill=False) self.magAdjustment = gtk.Adjustment(value=toAdd[1], lower=toAdd[2], upper=toAdd[3], step_incr=toAdd[4], page_incr=toAdd[5]) #===================== making variable ===================== self.magVar = self.magAdjustment.get_value() #===================== making variable ===================== self.magAdjustment.connect("value_changed", self.adjusted, 8) self.magSpinButton = gtk.SpinButton(adjustment=self.magAdjustment, climb_rate=0.0, digits=0) toShow.append(self.magSpinButton) self.magBox.pack_start(self.magSpinButton, fill=False) self.magSlider = gtk.HScale(adjustment=self.magAdjustment) toShow.append(self.magSlider) self.magBox.pack_start(self.magSlider, fill=True) #------------------------------------------------------------------------------------------------- # save / load values # format is .ssf (for SEM saved file): # self.saveLoadBox = gtk.HBox() toShow.append(self.saveLoadBox) self.mainBox.pack_start(self.saveLoadBox, fill=False) self.saveButton = gtk.Button("Save Settings") toShow.append(self.saveButton) self.saveLoadBox.pack_start(self.saveButton, fill=False) self.loadButton = gtk.Button("Load Settings") toShow.append(self.loadButton) self.saveLoadBox.pack_start(self.loadButton, fill=False) self.saveButton.connect("clicked", self.saveToFile, None) self.loadButton.connect("clicked", self.loadFromFile, None) #------------------------------------------------------------------------------------------------- # connectivity / sync values # format is: # "Connecttion status; connected flag value; ungrey reconnect button if connected flag lowered # "Sync status; sync flag value; ungrey resync if connected and sync flag lowered self.connectBox = gtk.HBox() toShow.append(self.connectBox) self.mainBox.pack_start(self.connectBox, fill=False) self.syncBox = gtk.HBox() toShow.append(self.syncBox) self.mainBox.pack_start(self.syncBox, fill=False) self.connectLabel = gtk.Label("Connection status: not connected") toShow.append(self.connectLabel) self.connectBox.pack_start(self.connectLabel, fill=False) self.connectButton = gtk.Button("Reconnect") toShow.append(self.connectButton) self.connectBox.pack_start(self.connectButton, fill=False) self.connectButton.connect("clicked", self.connect, None) self.syncLabel = gtk.Label("Sync status: not connected") toShow.append(self.syncLabel) self.syncBox.pack_start(self.syncLabel, fill=False) self.syncButton = gtk.Button("Resync") toShow.append(self.syncButton) self.syncBox.pack_start(self.syncButton, fill=False) #TODO #self.syncButton.connect("clicked", self.changeMode, None) #------------------------------------------------------------------------------------------------- # The final step is to display all widgets. for i in toShow: i.show() self.runThread = commThread() self.runThread.start()
def __init__(self, size=None, view_port_center=(0, 0), view_port_width=None, view_port_height=None, recording=True, max_num_frames=None, flip_y=False, title='Euv', time_step=0.1): gobject.threads_init() gtk.gdk.threads_init() if size is None: size = (800, 600) self.view_port_center = view_port_center if view_port_width == None and view_port_height == None: raise Exception( "Either view_port_width or view_port_height must be set!") self.view_port_width = view_port_width self.view_port_height = view_port_height super(App, self).__init__(gtk.WINDOW_TOPLEVEL) self.set_title(title) settings = gtk.settings_get_default() settings.set_long_property("gtk-button-images", 1, '*') self.set_resizable(True) self.vbox = gtk.VBox(False, 0) self.add(self.vbox) self.canvas = gtk.DrawingArea() self.set_default_size(size[0], size[1]) self.canvas.connect("expose_event", self.on_canvas_expose) self.vbox.pack_start(self.canvas, True, True, 0) hbox = gtk.HBox(False, 0) self.vbox.pack_start(hbox, False, True, 0) self.recording = recording self.flip_y = flip_y self.time_step = time_step if recording: self.buttonbox = gtk.HBox(False, 0) hbox.pack_start(self.buttonbox, True, False, 0) self.button_previous = image_button(stock=gtk.STOCK_MEDIA_REWIND) self.button_previous.connect("clicked", self.on_button_previous_clicked) self.buttonbox.pack_start(self.button_previous, False, False, 0) self.button_pause = image_button(stock=gtk.STOCK_MEDIA_PAUSE) self.button_pause.connect("clicked", self.on_button_pause_clicked) self.buttonbox.pack_start(self.button_pause, False, False, 0) self.button_next = image_button(stock=gtk.STOCK_MEDIA_FORWARD) self.button_next.connect("clicked", self.on_button_next_clicked) self.buttonbox.pack_start(self.button_next, False, False, 0) self.frame_scale = gtk.HScale() self.frame_adjustment = self.frame_scale.get_adjustment() self.frame_scale.set_digits(0) self.frame_adjustment.connect( "value-changed", self.on_frame_adjustment_value_changed) self.frame_scale.set_size_request(400, -1) self.buttonbox.pack_start(self.frame_scale, True, True, 0) if not max_num_frames is None: self.set_max_num_frames(max_num_frames) self.connect("delete_event", self.on_delete_event) self._user_break = False self.frames = [] self.current_frame = -1 self.pause = False gobject.timeout_add(int(self.time_step * 1000), self.play)
def add(self, widget): widget_type = type(widget) print widget_type if (widget_type == Button or isinstance(widget, Button)): widget.controller = gtk.Button(widget.text) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() if (widget.callbackMethod != None): widget.controller.connect('clicked', widget.callbackMethod) elif (widget_type == TextArea or isinstance(widget, TextArea)): widget.controller = gtk.TextView(widget.buffer) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() if (widget.callbackMethod != None): widget.controller.connect('clicked', widget.callbackMethod) elif (widget_type == TextField or isinstance(widget, TextField)): widget.controller = gtk.Entry() widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.set_text(widget.title) widget.controller.show() elif (widget_type == CheckBox or isinstance(widget, CheckBox)): widget.controller = gtk.CheckButton(widget.title) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() widget.controller.set_active(widget.value) elif (widget_type == RadioGroup or isinstance(widget, RadioGroup)): widget.controller = [] radio_controller = gtk.RadioButton(None, widget.labels[0]) radio_controller.set_size_request(widget.width, widget.height) self.fixed.put(radio_controller, widget.position_X[0], widget.position_Y[0]) radio_controller.show() widget.controller.append(radio_controller) for i in range(1, len(widget.labels)): radio_controller = gtk.RadioButton(widget.controller[0], widget.labels[i]) radio_controller.set_size_request(widget.width, widget.height) self.fixed.put(radio_controller, widget.position_X[i], widget.position_Y[i]) radio_controller.show() widget.controller.append(radio_controller) if (widget.selected_pos != None): widget.controller[widget.selected_pos].set_active(True) elif (widget_type == ValueList or isinstance(widget, ValueList)): widget.controller = gtk.OptionMenu() widget.controller.set_size_request(widget.width, widget.height) menu = gtk.Menu() for name in widget.choices: item = gtk.MenuItem(name) item.show() menu.append(item) print "gis" widget.controller.set_menu(menu) widget.controller.show() self.fixed.put(widget.controller, widget.position_X, widget.position_Y) elif (widget_type == LabelText or isinstance(widget, LabelText)): widget.controller = gtk.Label(widget.text) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.set_markup("<span font_desc='Calibri " + str(widget.size) + "'>" + widget.text + "</span>") widget.controller.show() elif (widget_type == Slider or isinstance(widget, Slider)): widget.controller = gtk.Adjustment(1.0, widget._from, widget._to, 1.0, 1.0, 0.0) widget.scale = gtk.HScale(widget.controller) widget.scale.set_digits(0) widget.scale.set_size_request(widget.width, widget.height) self.fixed.put(widget.scale, widget.position_X, widget.position_Y) widget.scale.show() elif (widget_type == Dialog or isinstance(widget, Dialog)): widget.title = widget.title
def __init__(self, coherence, device): self.coherence = coherence self.device = device self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.connect("delete_event", self.hide) self.window.set_default_size(480, 200) try: title = 'MediaRenderer %s' % device.get_friendly_name() except: title = 'MediaRenderer' self.window.set_title(title) self.window.drag_dest_set( gtk.DEST_DEFAULT_DROP, [('upnp/metadata', 0, 1)], gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_PRIVATE) self.window.connect('drag_motion', self.motion_cb) self.window.connect('drag_drop', self.drop_cb) self.window.connect("drag_data_received", self.received_cb) vbox = gtk.VBox(homogeneous=False, spacing=10) hbox = gtk.HBox(homogeneous=False, spacing=10) hbox.set_border_width(2) self.album_art_image = gtk.Image() icon = resource_filename(__name__, os.path.join('icons', 'blankalbum.png')) self.blank_icon = gtk.gdk.pixbuf_new_from_file(icon) self.album_art_image.set_from_pixbuf(self.blank_icon) hbox.pack_start(self.album_art_image, False, False, 2) #icon_loader = gtk.gdk.PixbufLoader() #icon_loader.write(urllib.urlopen(str(res.data)).read()) #icon_loader.close() vbox.pack_start(hbox, False, False, 2) textbox = gtk.VBox(homogeneous=False, spacing=10) self.title_text = gtk.Label("<b>title</b>") self.title_text.set_use_markup(True) textbox.pack_start(self.title_text, False, False, 2) self.album_text = gtk.Label("album") self.album_text.set_use_markup(True) textbox.pack_start(self.album_text, False, False, 2) self.artist_text = gtk.Label("artist") self.artist_text.set_use_markup(True) textbox.pack_start(self.artist_text, False, False, 2) hbox.pack_start(textbox, False, False, 2) seekbox = gtk.HBox(homogeneous=False, spacing=10) self.position_min_text = gtk.Label("0:00") self.position_min_text.set_use_markup(True) seekbox.pack_start(self.position_min_text, False, False, 2) adjustment = gtk.Adjustment(value=0, lower=0, upper=240, step_incr=1, page_incr=20) #, page_size=20) self.position_scale = gtk.HScale(adjustment=adjustment) self.position_scale.set_draw_value(True) self.position_scale.set_value_pos(gtk.POS_BOTTOM) self.position_scale.set_sensitive(False) self.position_scale.connect("format-value", self.format_position) self.position_scale.connect('change-value', self.position_changed) seekbox.pack_start(self.position_scale, True, True, 2) self.position_max_text = gtk.Label("0:00") self.position_max_text.set_use_markup(True) seekbox.pack_end(self.position_max_text, False, False, 2) vbox.pack_start(seekbox, False, False, 2) buttonbox = gtk.HBox(homogeneous=False, spacing=10) self.prev_button = self.make_button('media-skip-backward.png', self.skip_backward, sensitive=False) buttonbox.pack_start(self.prev_button, False, False, 2) self.seek_backward_button = self.make_button( 'media-seek-backward.png', callback=self.seek_backward, sensitive=False) buttonbox.pack_start(self.seek_backward_button, False, False, 2) self.stop_button = self.make_button('media-playback-stop.png', callback=self.stop, sensitive=False) buttonbox.pack_start(self.stop_button, False, False, 2) self.start_button = self.make_button('media-playback-start.png', callback=self.play_or_pause, sensitive=False) buttonbox.pack_start(self.start_button, False, False, 2) self.seek_forward_button = self.make_button('media-seek-forward.png', callback=self.seek_forward, sensitive=False) buttonbox.pack_start(self.seek_forward_button, False, False, 2) self.next_button = self.make_button('media-skip-forward.png', self.skip_forward, sensitive=False) buttonbox.pack_start(self.next_button, False, False, 2) hbox = gtk.HBox(homogeneous=False, spacing=10) #hbox.set_size_request(240,-1) adjustment = gtk.Adjustment(value=0, lower=0, upper=100, step_incr=1, page_incr=20) #, page_size=20) self.volume_scale = gtk.HScale(adjustment=adjustment) self.volume_scale.set_size_request(140, -1) self.volume_scale.set_draw_value(False) self.volume_scale.connect('change-value', self.volume_changed) hbox.pack_start(self.volume_scale, False, False, 2) button = gtk.Button() self.volume_image = gtk.Image() icon = resource_filename(__name__, os.path.join('icons', 'audio-volume-low.png')) self.volume_low_icon = gtk.gdk.pixbuf_new_from_file(icon) self.volume_image.set_from_pixbuf(self.volume_low_icon) button.set_image(self.volume_image) button.connect("clicked", self.mute) icon = resource_filename( __name__, os.path.join('icons', 'audio-volume-medium.png')) self.volume_medium_icon = gtk.gdk.pixbuf_new_from_file(icon) icon = resource_filename( __name__, os.path.join('icons', 'audio-volume-high.png')) self.volume_high_icon = gtk.gdk.pixbuf_new_from_file(icon) icon = resource_filename( __name__, os.path.join('icons', 'audio-volume-muted.png')) self.volume_muted_icon = gtk.gdk.pixbuf_new_from_file(icon) hbox.pack_end(button, False, False, 2) buttonbox.pack_end(hbox, False, False, 2) vbox.pack_start(buttonbox, False, False, 2) self.pause_button_image = gtk.Image() icon = resource_filename( __name__, os.path.join('icons', 'media-playback-pause.png')) icon = gtk.gdk.pixbuf_new_from_file(icon) self.pause_button_image.set_from_pixbuf(icon) self.start_button_image = self.start_button.get_image() self.status_bar = gtk.Statusbar() context_id = self.status_bar.get_context_id("Statusbar") vbox.pack_end(self.status_bar, False, False, 2) self.window.add(vbox) self.window.show_all() self.position_loop = task.LoopingCall(self.get_position) service = self.device.get_service_by_type('RenderingControl') #volume_variable = service.get_state_variable('Volume') #print "volume_variable",volume_variable.value #try: # volume = int(volume_variable.value) # if int(scale.get_value()) != volume: # self.volume_scale.set_value(volume) #except: # pass service.subscribe_for_variable('Volume', callback=self.state_variable_change) service.subscribe_for_variable('Mute', callback=self.state_variable_change) service = self.device.get_service_by_type('AVTransport') service.subscribe_for_variable('AVTransportURI', callback=self.state_variable_change) service.subscribe_for_variable('CurrentTrackMetaData', callback=self.state_variable_change) service.subscribe_for_variable('TransportState', callback=self.state_variable_change) service.subscribe_for_variable('CurrentTransportActions', callback=self.state_variable_change) service.subscribe_for_variable('AbsTime', callback=self.state_variable_change) service.subscribe_for_variable('TrackDuration', callback=self.state_variable_change) self.get_position()
def create_widget(table, widget_type, value, label, position): i = position watch_options = {} if not widget_type == "scale": gtkLabel = gtk.Label((label + ":")) gtkLabel.set_alignment(xalign=0.0, yalign=0.5) gtkLabel.show() table.attach(gtkLabel, 0, 1, i, i + 1) if widget_type == "entry": entry = gtk.Entry() entry.show() watch_options.update({value: entry}) table.attach(entry, 1, 2, i, i + 1) elif widget_type == "password": entry = gtk.Entry() entry.set_visibility(False) entry.show() watch_options.update({value: entry}) table.attach(entry, 1, 2, i, i + 1) elif widget_type == "scale": scale_table = gtk.Table(rows=2, columns=1, homogeneous=False) adjustment_label = gtk.Label((label + ":")) adjustment_label.set_alignment(xalign=0.0, yalign=0.5) adjustment_label.show() scale_table.attach(adjustment_label, 0, 1, 0, 1) _adjustment = gtk.Adjustment(value=2.0, lower=0, upper=50, \ step_incr=0.1, page_incr=1.0, page_size=10) scale = gtk.HScale(adjustment=_adjustment) scale.set_digits(1) scale.set_value_pos(gtk.POS_RIGHT) scale.show() scale_table.attach(scale, 0, 1, 1, 2) watch_options.update({value: scale}) scale_table.show() table.attach(scale_table, 0, 2, i, i + 1) elif widget_type == "checkbox": checkbox = gtk.CheckButton() checkbox.show() watch_options.update({value: checkbox}) table.attach(checkbox, 1, 2, i, i + 1) elif widget_type == "filechooser": filechooser = gtk.FileChooserButton(_("Choose a file")) filechooser.set_action(gtk.FILE_CHOOSER_ACTION_OPEN) filechooser.show() watch_options.update({value: filechooser}) table.attach(filechooser, 1, 2, i, i + 1) elif widget_type == "dirchooser": dirchooser = gtk.FileChooserButton(_("Choose a directory")) dirchooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) dirchooser.show() watch_options.update({value: dirchooser}) table.attach(dirchooser, 1, 2, i, i + 1) elif widget_type == "calendar": calendar = gtk.Calendar() #calendar.show() watch_options.update({value: calendar}) table.attach(calendar, 1, 2, i, i + 1) elif widget_type == "time": time_table = gtk.Table(rows=1, columns=2, homogeneous=False) minutes_adjustment = gtk.Adjustment(value=1, lower=1, upper=60, \ step_incr=1, page_incr=10, page_size=0) hours_adjustment = gtk.Adjustment(value=1, lower=1, upper=24, \ step_incr=1, page_incr=10, page_size=0) hours = gtk.SpinButton(hours_adjustment) hours.show() minutes = gtk.SpinButton(minutes_adjustment) minutes.show() time_table.attach(hours, 1, 2, 1, 2) time_table.attach(minutes, 2, 3, 1, 2) #time_table.show() watch_options.update({value: (hours, minutes)}) table.attach(time_table, 1, 2, i, i + 1) return watch_options, table
def __init__ (self, img, *args): self.img = img self.x1, self.y1, self.x2, self.y2 = 0, 0, 0, 0 self.direction = DIREC_N self.changed = False self.arrowsize = 30 self.arrowangle = 25 self.num_grad = 0 # Make a new GIMP layer to draw on self.layer = gimp.Layer(img, "arrow", img.width, img.height, RGBA_IMAGE, 100, NORMAL_MODE) img.add_layer(self.layer, 0) # Create the dialog win = gtk.Window.__init__(self, *args) self.set_title("GIMP arrow tool") #self.set_keep_above(True) # keep the window on top # Obey the window manager quit signal: self.connect("destroy", gtk.main_quit) # Make the UI self.set_border_width(10) vbox = gtk.VBox(spacing=10, homogeneous=False) self.add(vbox) label = gtk.Label("Arrow designer by Akkana Peck\nMake a rectangular selection. Will use active colors, brush and gradient.") # Change color of the label first line R. B. attr = pango.AttrList() fg_color = pango.AttrForeground(0, 0, 65535, 0, 30) size = pango.AttrSize(17000, 0, 14) bold = pango.AttrWeight(pango.WEIGHT_ULTRABOLD, 0, 14) attr.insert(fg_color) attr.insert(size) attr.insert(bold) label.set_attributes(attr) vbox.add(label) label.show() table = gtk.Table(rows=3, columns=2, homogeneous=False) table.set_col_spacings(10) vbox.add(table) # Arrow size and sharpness label = gtk.Label("Arrowhead size (px)") label.set_alignment(xalign=0.0, yalign=1.0) table.attach(label, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0) label.show() adj = gtk.Adjustment(self.arrowsize, 1, 200, 1) adj.connect("value_changed", self.arrowsize_cb) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 1, 2, 0, 1) scale.show() label = gtk.Label("Arrowhead angle (°)") label.set_alignment(xalign=0.0, yalign=1.0) table.attach(label, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0) label.show() adj = gtk.Adjustment(self.arrowangle, 1, 80, 1) adj.connect("value_changed", self.arrowangle_cb) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 1, 2, 1, 2) scale.show() label = gtk.Label("Gradient repetitions") label.set_alignment(xalign=0.0, yalign=1.0) table.attach(label, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0) label.show() adj = gtk.Adjustment(self.num_grad, 0, 50, 1) adj.connect("value_changed", self.num_grad_cb) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 1, 2, 2, 3) scale.show() table.show() # Selector for arrow direction hbox = gtk.HBox(spacing=5) btn = gtk.RadioButton(None, "N") btn.set_active(True) btn.connect("toggled", self.direction_cb, DIREC_N) hbox.add(btn) btn.show() btn = gtk.RadioButton(btn, "NE") btn.connect("toggled", self.direction_cb, DIREC_NE) hbox.add(btn) btn.show() btn = gtk.RadioButton(btn, "E") btn.connect("toggled", self.direction_cb, DIREC_E) hbox.add(btn) btn.show() btn = gtk.RadioButton(btn, "SE") btn.connect("toggled", self.direction_cb, DIREC_SE) hbox.add(btn) btn.show() btn = gtk.RadioButton(btn, "S") btn.connect("toggled", self.direction_cb, DIREC_S) hbox.add(btn) btn.show() btn = gtk.RadioButton(btn, "SW") btn.connect("toggled", self.direction_cb, DIREC_SW) hbox.add(btn) btn.show() btn = gtk.RadioButton(btn, "W") btn.connect("toggled", self.direction_cb, DIREC_W) hbox.add(btn) btn.show() btn = gtk.RadioButton(btn, "NW") btn.connect("toggled", self.direction_cb, DIREC_NW) hbox.add(btn) btn.show() vbox.add(hbox) hbox.show() # Make the dialog buttons box hbox = gtk.HBox(spacing=20) btn = gtk.Button("Next arrow") btn.connect("pressed", self.next_arrow) hbox.add(btn) btn.show() btn = gtk.Button("Close") btn.connect("clicked", gtk.main_quit) hbox.add(btn) btn.show() vbox.add(hbox) hbox.show() vbox.show() self.show() timeout_add(300, self.update, self) return win
def __init__(self, img, *args): self.img = img self.img_size = 0 self.svg_image_polygonized = [] self.svg_image_full = [] self.contours_hierarchy = [] # contour thresholds self.c_threshold = 50 # corner detection arguments self.polygonization_distance = 5 self.corn_straw_window, self.corn_median_thresh, self.corn_line_thresh = 3, 95, 98 self.corn_cluster_thresh, self.corn_corner_thresh = 150, 45 self.corn_block_size, self.corn_kernel_size, self.corn_kfree = 2, 7, 1 # curve fitting arguments self.cf_labels = ["l inf", "l1 norm", "l2 norm"] self.cf_error, self.cf_line_err = 9, 2 self.cf_metric = 0 # final result self.svg_final_image = None # create dialog win = gtk.Window.__init__(self, *args) self.connect("destroy", gtk.main_quit) # make user interface self.set_border_width(10) # size of preview images self.preview_size = (300, 300) # image part self.path = gimp.image_list()[0].filename self.process_image = SVGImage(self.path) self.process_image.init() vbox = gtk.VBox(spacing=10, homogeneous=False) self.add(vbox) label = gtk.Label("Vectrabool") vbox.add(label) label.show() # table for live preview table = gtk.Table(rows=7, columns=8, homogeneous=False) table.set_col_spacings(3) table.set_row_spacings(10) vbox.add(table) # # # start with contour detection label = gtk.Label("min threshold") table.attach(label, 0, 1, 0, 1) label.show() adj = gtk.Adjustment(self.c_threshold, 0, 100, 1) adj.connect("value_changed", self.c_threshold_changed) # adj.connect("value_changed", self.update_contours_image) scale = gtk.HScale(adj) table.attach(scale, 1, 2, 0, 1) scale.show() # polygonization distance label = gtk.Label("Polygonization distance") table.attach(label, 0, 1, 1, 2) label.show() adj = gtk.Adjustment(int(self.polygonization_distance), 1, 30, 1) adj.connect("value_changed", self.polygonization_distance_ch) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 1, 2, 1, 2) scale.show() # corner threshold label = gtk.Label("Straw window size") table.attach(label, 2, 3, 0, 1) label.show() adj = gtk.Adjustment(self.corn_straw_window, 3, 10, 1) adj.connect("value_changed", self.corn_straw_window_ch) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 3, 4, 0, 1) scale.show() # corner block size label = gtk.Label("Median threshold") table.attach(label, 2, 3, 1, 2) label.show() adj = gtk.Adjustment(self.corn_median_thresh, 10, 100, 1) adj.connect("value_changed", self.corn_median_thresh_ch) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 3, 4, 1, 2) scale.show() # corner kernel size label = gtk.Label("Line threshold") table.attach(label, 2, 3, 2, 3) label.show() adj = gtk.Adjustment(self.corn_line_thresh, 10, 100, 1) adj.connect("value_changed", self.corn_line_thresh_ch) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 3, 4, 2, 3) scale.show() # boring # curve fitting label = gtk.Label("Bezier curve max error") table.attach(label, 4, 5, 0, 1) label.show() adj = gtk.Adjustment(int(self.cf_error), 1, 30, 1) adj.connect("value_changed", self.cf_error_ch) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 5, 6, 0, 1) scale.show() # line fit label = gtk.Label("Line fit max error") table.attach(label, 4, 5, 1, 2) label.show() adj = gtk.Adjustment(self.cf_line_err, 1, 10, 1) adj.connect("value_changed", self.cf_line_err_ch) scale = gtk.HScale(adj) scale.set_digits(0) table.attach(scale, 5, 6, 1, 2) scale.show() # display preview self.img_contours = gtk.Image() contours_pixbf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, self.preview_size[0], self.preview_size[1]) contours_pixbf.fill(0xffffffff) self.img_contours.set_from_pixbuf(contours_pixbf) self.img_contours.show() corners_pixbf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, self.preview_size[0], self.preview_size[1]) corners_pixbf.fill(0xffffffff) self.img_corners = gtk.Image() self.img_corners.set_from_pixbuf(corners_pixbf) self.img_corners.show() curve_fit_pixbf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, self.preview_size[0], self.preview_size[1]) curve_fit_pixbf.fill(0xffffffff) self.img_curve_fit = gtk.Image() self.img_curve_fit.set_from_pixbuf(curve_fit_pixbf) self.img_curve_fit.show() # add images table.attach(self.img_contours, 0, 2, 5, 6) table.attach(self.img_corners, 2, 4, 5, 6) table.attach(self.img_curve_fit, 4, 6, 5, 6) # table.attach(img_corners, 0, 2, 5, 6) # table.attach(img_curve_fit, 0, 2, 5, 6) # table.attach(img_color, 0, 2, 5, 6) # make buttons hbox = gtk.HBox(spacing=20) btn = gtk.Button("Close") hbox.add(btn) btn.show() btn.connect("clicked", gtk.main_quit) btn1 = gtk.Button("Apply") hbox.add(btn1) btn1.show() btn1.connect("pressed", self.apply_values) table.attach(hbox, 0, 10, 6, 7) table.show() vbox.show() hbox.show() self.show() # This permits to already have a contour image displayed # self.update_svg_image() pdb.gimp_message('This is displayed as a message') timeout_add(100, self.update, self)
def __init__(self, window): gtk.Dialog.__init__(self, _('Enhance image'), window, 0) self._window = window reset = gtk.Button(None, gtk.STOCK_REVERT_TO_SAVED) reset.set_tooltip_text(_('Reset to defaults.')) self.add_action_widget(reset, gtk.RESPONSE_REJECT) save = gtk.Button(None, gtk.STOCK_SAVE) save.set_tooltip_text( _('Save the selected values as default for future files.')) self.add_action_widget(save, gtk.RESPONSE_APPLY) self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK) self.set_has_separator(False) self.set_resizable(False) self.connect('response', self._response) self.set_default_response(gtk.RESPONSE_OK) self._enhancer = window.enhancer self._block = False vbox = gtk.VBox(False, 10) self.set_border_width(4) vbox.set_border_width(6) self.vbox.add(vbox) self._hist_image = gtk.Image() self._hist_image.set_size_request(262, 170) vbox.pack_start(self._hist_image) vbox.pack_start(gtk.HSeparator()) hbox = gtk.HBox(False, 4) vbox.pack_start(hbox, False, False, 2) vbox_left = gtk.VBox(False, 4) vbox_right = gtk.VBox(False, 4) hbox.pack_start(vbox_left, False, False, 2) hbox.pack_start(vbox_right, True, True, 2) label = gtk.Label(_('_Brightness:')) label.set_alignment(1, 0.5) label.set_use_underline(True) vbox_left.pack_start(label, True, False, 2) adj = gtk.Adjustment(0.0, -1.0, 1.0, 0.01, 0.1) self._brightness_scale = gtk.HScale(adj) self._brightness_scale.set_digits(2) self._brightness_scale.set_value_pos(gtk.POS_RIGHT) self._brightness_scale.connect('value-changed', self._change_values) self._brightness_scale.set_update_policy(gtk.UPDATE_DELAYED) label.set_mnemonic_widget(self._brightness_scale) vbox_right.pack_start(self._brightness_scale, True, False, 2) label = gtk.Label(_('_Contrast:')) label.set_alignment(1, 0.5) label.set_use_underline(True) vbox_left.pack_start(label, True, False, 2) adj = gtk.Adjustment(0.0, -1.0, 1.0, 0.01, 0.1) self._contrast_scale = gtk.HScale(adj) self._contrast_scale.set_digits(2) self._contrast_scale.set_value_pos(gtk.POS_RIGHT) self._contrast_scale.connect('value-changed', self._change_values) self._contrast_scale.set_update_policy(gtk.UPDATE_DELAYED) label.set_mnemonic_widget(self._contrast_scale) vbox_right.pack_start(self._contrast_scale, True, False, 2) label = gtk.Label(_('S_aturation:')) label.set_alignment(1, 0.5) label.set_use_underline(True) vbox_left.pack_start(label, True, False, 2) adj = gtk.Adjustment(0.0, -1.0, 1.0, 0.01, 0.1) self._saturation_scale = gtk.HScale(adj) self._saturation_scale.set_digits(2) self._saturation_scale.set_value_pos(gtk.POS_RIGHT) self._saturation_scale.connect('value-changed', self._change_values) self._saturation_scale.set_update_policy(gtk.UPDATE_DELAYED) label.set_mnemonic_widget(self._saturation_scale) vbox_right.pack_start(self._saturation_scale, True, False, 2) label = gtk.Label(_('S_harpness:')) label.set_alignment(1, 0.5) label.set_use_underline(True) vbox_left.pack_start(label, True, False, 2) adj = gtk.Adjustment(0.0, -1.0, 1.0, 0.01, 0.1) self._sharpness_scale = gtk.HScale(adj) self._sharpness_scale.set_digits(2) self._sharpness_scale.set_value_pos(gtk.POS_RIGHT) self._sharpness_scale.connect('value-changed', self._change_values) self._sharpness_scale.set_update_policy(gtk.UPDATE_DELAYED) label.set_mnemonic_widget(self._sharpness_scale) vbox_right.pack_start(self._sharpness_scale, True, False, 2) vbox.pack_start(gtk.HSeparator()) self._autocontrast_button = \ gtk.CheckButton(_('_Automatically adjust contrast')) self._autocontrast_button.set_tooltip_text( _('Automatically adjust contrast (both lightness and darkness), separately for each colour band.' )) vbox.pack_start(self._autocontrast_button, False, False, 2) self._autocontrast_button.connect('toggled', self._change_values) self._block = True self._brightness_scale.set_value(self._enhancer.brightness - 1) self._contrast_scale.set_value(self._enhancer.contrast - 1) self._saturation_scale.set_value(self._enhancer.saturation - 1) self._sharpness_scale.set_value(self._enhancer.sharpness - 1) self._autocontrast_button.set_active(self._enhancer.autocontrast) self._block = False self._contrast_scale.set_sensitive( not self._autocontrast_button.get_active()) self.draw_histogram(self._window.left_image) self.show_all()
def __init__(self, padre): gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL) gtk.Window.set_position(self, gtk.WIN_POS_CENTER_ALWAYS) self.set_title("Nueva Partición") self.padre = padre self.set_size_request(400, 200) self.set_resizable(0) self.set_border_width(0) self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL) self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK) self.set_default_response(gtk.RESPONSE_CANCEL) if self.padre.bext == False: self.inicio = gen.kb(self.padre.lista[-1][5]) self.fin = gen.kb(self.padre.fin) else: self.inicio = gen.kb(self.padre.ext_ini) self.fin = gen.kb(self.padre.ext_fin) # Contenedor General self.cont = gtk.Fixed() self.cont.show() self.vbox.pack_start(self.cont) #Tamaño de la partición self.lbl = gtk.Label('Tamaño') self.lbl.set_alignment(0, 0.5) self.lbl.set_size_request(200, 30) self.lbl.show() self.cont.put(self.lbl, 5, 5) adj = gtk.Adjustment(float(self.fin), float(self.inicio), float(self.fin), 1.0, 5.0, 0.0) self.escala = gtk.HScale() self.escala.set_draw_value(False) self.escala.set_adjustment(adj) self.escala.set_property('value-pos', gtk.POS_RIGHT) self.escala.set_size_request(250, 30) self.escala.connect("value-changed", self.on_changed) self.cont.put(self.escala, 60, 5) self.escala.show() self.lblsize = gtk.Label(gen.hum(self.escala.get_value() - \ float(self.inicio))) self.lblsize.set_alignment(0, 0.5) self.lblsize.set_size_request(100, 30) self.lblsize.show() self.cont.put(self.lblsize, 320, 5) #Tipo de partición self.lbl = gtk.Label('Tipo de partición') self.lbl.set_alignment(0, 0.5) self.lbl.set_size_request(200, 30) self.cont.put(self.lbl, 5, 35) self.lbl.show() self.cmb_tipo = gtk.combo_box_new_text() self.cmb_tipo.set_size_request(100, 30) self.cont.put(self.cmb_tipo, 145, 35) if padre.bext == True: self.cmb_tipo.append_text('Lógica') self.cmb_tipo.set_sensitive(False) else: #if self.padre.primarias < 4: self.cmb_tipo.append_text('Primaria') self.cmb_tipo.append_text('Extendida') self.cmb_tipo.set_active(0) self.cmb_tipo.connect("changed", self.cmb_tipo_on_changed) self.cmb_tipo.show() #Sistema de Archivos self.lbl = gtk.Label('Sistema de Archivos') self.lbl.set_alignment(0, 0.5) self.lbl.set_size_request(200, 30) self.lbl.show() self.cont.put(self.lbl, 5, 65) self.cmb_fs = gtk.combo_box_new_text() self.cmb_fs.set_size_request(100, 30) self.cont.put(self.cmb_fs, 145, 65) self.cmb_fs.append_text('ext2') self.cmb_fs.append_text('ext3') self.cmb_fs.append_text('ext4') self.cmb_fs.append_text('linux-swap') self.cmb_fs.append_text('reiserfs') self.cmb_fs.append_text('fat16') self.cmb_fs.append_text('fat32') self.cmb_fs.set_active(2) self.cmb_fs.connect("changed", self.cmb_fs_on_changed) self.cmb_fs.show() # Punto de Montaje self.lbl = gtk.Label('Punto de Montaje') self.lbl.set_alignment(0, 0.5) self.lbl.set_size_request(200, 30) self.cont.put(self.lbl, 5, 95) self.lbl.show() self.cmb_montaje = gtk.combo_box_new_text() self.cmb_montaje.set_size_request(200, 30) self.cont.put(self.cmb_montaje, 145, 95) self.agregar('/') self.agregar('/boot') self.agregar('/home') self.agregar('/tmp') self.agregar('/usr') self.agregar('/var') self.agregar('/srv') self.agregar('/opt') self.agregar('/usr/local') self.cmb_montaje.append_text('Ninguno') self.cmb_montaje.append_text('Escoger manualmente') self.cmb_montaje.set_active(0) self.cmb_montaje.connect("changed", self.cmb_montaje_on_changed) self.cmb_montaje.show() self.entrada = gtk.Entry() self.entrada.set_text('/') self.entrada.set_size_request(200, 30) self.cont.put(self.entrada, 145, 125) self.entrada.connect("changed", self.validar_punto) response = self.run() if response == gtk.RESPONSE_OK: tipo = gen.get_active_text(self.cmb_tipo) formato = gen.get_active_text(self.cmb_fs) montaje = gen.get_active_text(self.cmb_montaje) if tipo == 'Extendida': formato = 'Ninguno' montaje = 'Ninguno' if formato == 'linux-swap': montaje = 'Ninguno' if montaje == 'Escoger manualmente': montaje = self.entrada.get_text().strip() if self.padre.lista[-1][1] == 'Espacio Libre': self.padre.lista.pop() if len(self.padre.lista) > 0: if self.padre.lista[-1][1] == 'Espacio Libre Extendida': self.padre.lista.pop() # Si la partición nueva es Primaria if tipo == 'Primaria': # Calculo el tamaño inicio = int(self.inicio) fin = int(self.escala.get_value()) tamano = gen.hum(fin - inicio) # Elimina ultimo elemento de la lista #self.padre.lista.pop() # Se crea elemento particion primaria y se agrega a la lista particion = [ self.padre.disco, #Dispositivo tipo, #Tipo formato, #Formato montaje, #Punto de montaje tamano, #Tamaño inicio, #inicio fin ] #fin self.padre.lista.append(particion) # Si la partición nueva es Extendida elif tipo == 'Extendida': # Calculo el tamaño inicio = int(self.inicio) fin = int(self.escala.get_value()) tamano = gen.hum(fin - inicio) # Cambia variable bext a True self.padre.bext = True # Establece las variables ext_ini y ext_fin self.padre.ext_ini = inicio self.padre.ext_fin = fin # Elimina ultimo elemento de la lista #self.padre.lista.pop() # Se crea elemento particion extendida y se agrega a la lista particion = [ self.padre.disco, #Dispositivo tipo, #Tipo '', #formato, #Formato montaje, #Punto de montaje tamano, #Tamaño inicio, #inicio fin ] #fin self.padre.lista.append(particion) # Se crea elemento espacio libre en partición extendida particion = [ '', #self.padre.disco, #Dispositivo 'Espacio Libre Extendida', #Tipo '', #self.get_active_text(self.cmb_fs), #Formato '', #self.get_active_text(self.cmb_montaje),#Punto de montaje tamano, #Tamaño inicio, #inicio fin ] #fin self.padre.lista.append(particion) # Si la partición nueva es Lógica elif tipo == 'Lógica': # Calculo el tamaño inicio = int(self.padre.ext_ini) fin = int(self.escala.get_value()) tamano = gen.hum(fin - inicio) # Elimina los dos ultimos elementos de la lista #self.padre.lista.pop() #self.padre.lista.pop() # Se crea elemento particion lógica y se agrega a la lista particion = [ self.padre.disco, #Dispositivo tipo, #Tipo formato, #Formato montaje, #Punto de montaje tamano, #Tamaño inicio, #inicio fin ] #fin self.padre.lista.append(particion) # Si self.padre.ext_fin != fin entonces if self.padre.ext_fin == fin: # No se crea elemento espacio libre en partición extendida # Cambia variable bext a False self.padre.bext = False # Si no else: # se calcula el tamaño de la partición libre ext_ini = fin ext_fin = self.padre.ext_fin tamano = gen.hum(ext_fin - ext_ini) self.padre.ext_ini = ext_ini # Se crea elemento espacio libre en partición extendida particion = [ '', #self.padre.disco, #Dispositivo 'Espacio Libre Extendida', #Tipo '', #self.get_active_text(self.cmb_fs), #Formato '', #self.get_active_text(self.cmb_montaje),#Punto de montaje tamano, #Tamaño ext_ini, #inicio ext_fin ] #fin self.padre.lista.append(particion) # Calculamos el tamaño de la partición libre # si bext == True entonces se usará ext_fin como fin if self.padre.bext == True: fin = self.padre.ext_fin #print 'Inicio:', inicio, 'fin:', fin, "self.fin", int(self.fin) # Si fin == self.fin entonces if fin == int(gen.kb(self.padre.fin)): pass # No se crea elemento espacio libre #print "No crea la elemento espacio libre" # Si no else: #print "Crea elemento espacio libre" # se calcula el tamaño de la partición libre inicio = fin fin = int(gen.kb(self.padre.fin)) tamano = gen.hum(fin - inicio) # Se crea elemento espacio libre libre = [ '', #Dispositivo 'Espacio Libre', #Tipo '', #Formato '', #Punto de montaje tamano, #Tamaño inicio, #inicio fin ] #fin self.padre.lista.append(libre) # Se actualiza la tabla self.padre.llenar_tabla(self.padre.lista) else: pass self.destroy() return None
def __init__(self): gtk.VBox.__init__(self) from application import get_app app = get_app() self.app = app self.ani = app.doc.ani.model self.is_playing = False self.set_size_request(200, 150) self.app.doc.model.doc_observers.append(self.doc_structure_modified_cb) # create list: self.listmodel = self.create_list() # create tree view: self.treeview = gtk.TreeView(self.listmodel) self.treeview.set_rules_hint(True) self.treeview.set_headers_visible(False) treesel = self.treeview.get_selection() treesel.set_mode(gtk.SELECTION_SINGLE) self.changed_handler = treesel.connect('changed', self.on_row_changed) self.add_columns() layers_scroll = gtk.ScrolledWindow() layers_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) layers_scroll.set_placement(gtk.CORNER_TOP_RIGHT) layers_scroll.add(self.treeview) # xsheet controls: def pixbuf_button(pixbuf): b = gtk.Button() img = gtk.Image() img.set_from_pixbuf(pixbuf) b.add(img) return b pixbuf_key = self.app.pixmaps.keyframe_add self.key_button = pixbuf_button(pixbuf_key) self.key_button.connect('clicked', self.on_toggle_key) self.key_button.set_tooltip_text(_('Toggle Keyframe')) pixbuf_skip = self.app.pixmaps.cel_skip self.skip_button = pixbuf_button(pixbuf_skip) self.skip_button.connect('clicked', self.on_toggle_skip) self.skip_button.set_tooltip_text(_('Set/Unset onion skin')) self.chdesc_button = stock_button(gtk.STOCK_ITALIC) self.chdesc_button.connect('clicked', self.on_change_description) self.chdesc_button.set_tooltip_text(_('Change Cel Description')) pixbuf_add = self.app.pixmaps.cel_add self.add_cel_button = pixbuf_button(pixbuf_add) self.add_cel_button.connect('clicked', self.on_add_cel) self.add_cel_button.set_tooltip_text(_('Add cel to this frame')) pixbuf_remove = self.app.pixmaps.cel_remove self.remove_cel_button = pixbuf_button(pixbuf_remove) self.remove_cel_button.connect('clicked', self.on_remove_cel) self.remove_cel_button.set_tooltip_text(_('Remove cel of this frame')) buttons_hbox = gtk.HBox() buttons_hbox.pack_start(self.key_button) buttons_hbox.pack_start(self.skip_button) buttons_hbox.pack_start(self.chdesc_button) buttons_hbox.pack_start(self.add_cel_button) buttons_hbox.pack_start(self.remove_cel_button) # player controls: self.previous_button = stock_button(gtk.STOCK_GO_UP) self.previous_button.connect('clicked', self.on_previous_frame) self.previous_button.set_tooltip_text(_('Previous Frame')) self.next_button = stock_button(gtk.STOCK_GO_DOWN) self.next_button.connect('clicked', self.on_next_frame) self.next_button.set_tooltip_text(_('Next Frame')) self.play_button = stock_button(gtk.STOCK_MEDIA_PLAY) self.play_button.connect('clicked', self.on_animation_play) self.play_button.set_tooltip_text(_('Play animation')) self.pause_button = stock_button(gtk.STOCK_MEDIA_PAUSE) self.pause_button.connect('clicked', self.on_animation_pause) self.pause_button.set_tooltip_text(_('Pause animation')) self.stop_button = stock_button(gtk.STOCK_MEDIA_STOP) self.stop_button.connect('clicked', self.on_animation_stop) self.stop_button.set_tooltip_text(_('Stop animation')) anibuttons_hbox = gtk.HBox() anibuttons_hbox.pack_start(self.previous_button) anibuttons_hbox.pack_start(self.next_button) anibuttons_hbox.pack_start(self.play_button) anibuttons_hbox.pack_start(self.pause_button) anibuttons_hbox.pack_start(self.stop_button) # frames edit controls: insert_frame_button = stock_button(gtk.STOCK_ADD) insert_frame_button.connect('clicked', self.on_insert_frames) insert_frame_button.set_tooltip_text(_('Insert frames')) self.insert_frame_button = insert_frame_button remove_frame_button = stock_button(gtk.STOCK_REMOVE) remove_frame_button.connect('clicked', self.on_remove_frames) remove_frame_button.set_tooltip_text(_('Remove frames')) self.remove_frame_button = remove_frame_button cut_button = stock_button(gtk.STOCK_CUT) cut_button.connect('clicked', self.on_cut) cut_button.set_tooltip_text(_('Cut cel')) self.cut_button = cut_button copy_button = stock_button(gtk.STOCK_COPY) copy_button.connect('clicked', self.on_copy) copy_button.set_tooltip_text(_('Copy cel')) self.copy_button = copy_button paste_button = stock_button(gtk.STOCK_PASTE) paste_button.connect('clicked', self.on_paste) paste_button.set_tooltip_text(_('Paste cel')) self.paste_button = paste_button editbuttons_hbox = gtk.HBox() editbuttons_hbox.pack_start(insert_frame_button) editbuttons_hbox.pack_start(remove_frame_button) editbuttons_hbox.pack_start(cut_button) editbuttons_hbox.pack_start(copy_button) editbuttons_hbox.pack_start(paste_button) # lightbox controls: adj = gtk.Adjustment(lower=0, upper=100, step_incr=1, page_incr=10) self.opacity_scale = gtk.HScale(adj) opa = self.app.preferences.get('lightbox.factor', 100) self.opacity_scale.set_value(opa) self.opacity_scale.set_value_pos(gtk.POS_LEFT) opacity_lbl = gtk.Label(_('Opacity:')) opacity_hbox = gtk.HBox() opacity_hbox.pack_start(opacity_lbl, expand=False) opacity_hbox.pack_start(self.opacity_scale, expand=True) self.opacity_scale.connect('value-changed', self.on_opacityfactor_changed) self.expander_prefs_loaded = False self.connect("show", self.show_cb) def opacity_checkbox(attr, label, tooltip=None): cb = gtk.CheckButton(label) pref = "lightbox.%s" % (attr, ) default = DEFAULT_ACTIVE_CELS[attr] cb.set_active(self.app.preferences.get(pref, default)) cb.connect('toggled', self.on_opacity_toggled, attr) if tooltip is not None: cb.set_tooltip_text(tooltip) opacityopts_vbox.pack_start(cb, expand=False) opacityopts_vbox = gtk.VBox() opacity_checkbox('cel', _('Inmediate'), _("Show the inmediate next and previous cels.")) opacity_checkbox( 'key', _('Inmediate keys'), _("Show the cel keys that are after and before the current cel.")) opacity_checkbox( 'inbetweens', _('Inbetweens'), _("Show the cels that are between the inmediate key cels.")) opacity_checkbox('other keys', _('Other keys'), _("Show the other keys cels.")) opacity_checkbox('other', _('Other'), _("Show the rest of the cels.")) self.framerate_adjustment = gtk.Adjustment(value=self.ani.framerate, lower=1, upper=120, step_incr=0.01) self.framerate_adjustment.connect("value-changed", self.on_framerate_changed) self.framerate_entry = gtk.SpinButton( adjustment=self.framerate_adjustment, digits=2, climb_rate=1.5) framerate_lbl = gtk.Label(_('Frame rate:')) framerate_hbox = gtk.HBox() framerate_hbox.pack_start(framerate_lbl, False, False) framerate_hbox.pack_start(self.framerate_entry, False, False) icons_cb = gtk.CheckButton(_("Small icons")) icons_cb.set_active( self.app.preferences.get("xsheet.small_icons", False)) icons_cb.connect('toggled', self.on_smallicons_toggled) icons_cb.set_tooltip_text( _("Use smaller icons, better to see more rows.")) play_lightbox_cb = gtk.CheckButton(_("Play with lightbox on")) play_lightbox_cb.set_active( self.app.preferences.get("xsheet.play_lightbox", False)) play_lightbox_cb.connect('toggled', self.on_playlightbox_toggled) play_lightbox_cb.set_tooltip_text( _("Show other frames while playing, this is slower.")) showprev_cb = gtk.CheckButton(_("Lightbox show previous")) showprev_cb.set_active( self.app.preferences.get("xsheet.lightbox_show_previous", True)) showprev_cb.connect('toggled', self.on_shownextprev_toggled, 'previous') showprev_cb.set_tooltip_text(_("Show previous cels in the lightbox.")) shownext_cb = gtk.CheckButton(_("Lightbox show next")) shownext_cb.set_active( self.app.preferences.get("xsheet.lightbox_show_next", False)) shownext_cb.connect('toggled', self.on_shownextprev_toggled, 'next') shownext_cb.set_tooltip_text(_("Show next cels in the lightbox.")) controls_vbox = gtk.VBox() controls_vbox.pack_start(buttons_hbox, expand=False) controls_vbox.pack_start(anibuttons_hbox, expand=False) controls_vbox.pack_start(editbuttons_hbox, expand=False) preferences_vbox = gtk.VBox() preferences_vbox.pack_start(framerate_hbox, expand=False) preferences_vbox.pack_start(icons_cb, expand=False) preferences_vbox.pack_start(play_lightbox_cb, expand=False) preferences_vbox.pack_start(showprev_cb, expand=False) preferences_vbox.pack_start(shownext_cb, expand=False) preferences_vbox.pack_start(opacity_hbox, expand=False) preferences_vbox.pack_start(opacityopts_vbox, expand=False) self.controls_expander = gtk.Expander(label=_('Controls')) self.controls_expander.add(controls_vbox) self.controls_expander.connect("notify::expanded", self.expanded_cb, 'controls') self.prefs_expander = gtk.Expander(label=_('Preferences')) self.prefs_expander.add(preferences_vbox) self.prefs_expander.connect("notify::expanded", self.expanded_cb, 'preferences') self.pack_start(layers_scroll) self.pack_start(self.controls_expander, expand=False) self.pack_start(self.prefs_expander, expand=False) self.show_all() self._change_player_buttons() self.app.doc.model.doc_observers.append(self.update)
def add(self, widget): widget_type = type(widget) print widget_type if (widget_type == Button): widget.controller = gtk.Button(widget.text) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() if (widget.callbackMethod != None): widget.controller.connect('clicked', widget.callbackMethod) elif (widget_type == TextArea): widget.controller = gtk.TextView(widget.buffer) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() if (widget.callbackMethod != None): widget.controller.connect('clicked', widget.callbackMethod) elif (widget_type == TextLine): widget.controller = gtk.Entry() widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() elif (widget_type == CheckBox): widget.controller = gtk.CheckButton(widget.title) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() widget.controller.set_active(widget.value) #### elif (widget_type == Password): widget.controller = gtk.Entry() widget.controller.set_visibility(0) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() elif (widget_type == Slider): widget.controller = gtk.HScale() widget.controller.set_range(widget.start, widget.end) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() elif (widget_type == SpinBox): widget.controller = gtk.SpinButton() widget.controller.set_range(widget.start, widget.end) widget.controller.set_increments(1, 1) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() elif (widget_type == Label): widget.controller = gtk.Label(widget.text) widget.controller.set_size_request(widget.width, widget.height) self.fixed.put(widget.controller, widget.position_X, widget.position_Y) widget.controller.show() ### elif (widget_type == RadioGroup): widget.controller = [] radio_controller = gtk.RadioButton(None, widget.labels[0]) radio_controller.set_size_request(widget.width, widget.height) self.fixed.put(radio_controller, widget.position_X[0], widget.position_Y[0]) radio_controller.show() widget.controller.append(radio_controller) for i in range(1, len(widget.labels)): radio_controller = gtk.RadioButton(widget.controller[0], widget.labels[num]) radio_controller.set_size_request(widget.width, widget.height) self.fixed.put(radio_controller, widget.position_X[num], widget.position_Y[num]) radio_controller.show() widget.controller.append(radio_controller) if (widget.selected_pos != None): widget.controller[widget.selected_pos].set_active(True) elif (widget_type == ValueList): widget.controller = gtk.OptionMenu() widget.controller.set_size_request(widget.width, widget.height) menu = gtk.Menu() for name in widget.choices: item = gtk.MenuItem(name) item.show() menu.append(item) print "gis" widget.controller.set_menu(menu) widget.controller.show() self.fixed.put(widget.controller, widget.position_X, widget.position_Y)
def __init__(self): window = gtk.Window() hbox = gtk.HBox() vbox = gtk.VBox() #se usaran para el marcador self.label = gtk.Label() self.label.modify_font(pango.FontDescription("Purisa 14")) frame = gtk.Frame("Marcador") #asignacion de variables a widgest de gtk self.vadjustment = gtk.Adjustment() self.hadjustment = gtk.Adjustment() #asignacion de valores por defecto del adjustment self.vadjustment.set_upper(100) self.vadjustment.set_value(0) self.hadjustment.set_upper(100) self.hadjustment.set_value(0) #asignacion de propiedades de widgets self.vslide = gtk.VScale(self.vadjustment) self.hslide = gtk.HScale(self.hadjustment) #propiedad para que no se muestre valor del slide self.vslide.set_draw_value(False) self.hslide.set_draw_value(False) #variables globales que se utilizan en los slides self.increment_x = self.increment_y = 1 self.indicator_x = self.indicator_y = -1 self.goles = 0 self.atajadas = 0 #asignacion de variables de widgets self.drawing_area = gtk.DrawingArea() self.drawing_area.set_size_request(WIDTH, HEIGHT) #asignando cancha y arquero self.cancha = gtk.gdk.pixbuf_new_from_file('images/arco.jpg') self.portero = gtk.gdk.pixbuf_new_from_file( 'images/goalkeeper_downcenter.png') window.connect("destroy", lambda w: gtk.main_quit()) #callbacks al invocar el area de dibujo self.drawing_area.connect('configure_event', self.__configure_cb) self.drawing_area.connect('expose-event', self.__expose_cb) #evento que invoca funcion al presionar cualquier tecla window.connect('key-press-event', self.__key_press_event_cb) #anhadiendo widgets dentro del contenedor principal window.add(hbox) hbox.add(vbox) frame.add(self.label) vbox.add(frame) vbox.add(self.drawing_area) vbox.add(self.hslide) hbox.add(self.vslide) #mostrando los widgets window.show_all() #invocacion de la funcion que realiza loop del slider horizontal gobject.timeout_add(DELAY, self.__hslider_move_cb)
def __init__(self, applet_name): DockXAppletDialog.__init__(self, applet_name) table = gtk.Table(7, 3) table.set_border_width(5) table.set_homogeneous(True) table.set_col_spacings(15) self.vbox.pack_start(table) self.scroll_enabled_btn = gtk.CheckButton("Change workspaces by mouse scroll") self.scroll_enabled_btn.connect("toggled", self.on_checkbox_toggle, "scroll_enabled") table.attach(self.scroll_enabled_btn, 0, 2, 0, 1) label = gtk.Label("Color") label.set_alignment(0, 0.5) table.attach(label, 0, 2, 1, 2) self.color_btn = gtk.ColorButton() self.color_btn.set_title("Color") self.color_btn.set_use_alpha(True) self.color_btn.connect("color-set", self.on_color_set, "color") table.attach(self.color_btn, 2, 3, 1, 2) label = gtk.Label("Active color") label.set_alignment(0, 0.5) table.attach(label, 0, 2, 2, 3) self.active_color_btn = gtk.ColorButton() self.active_color_btn.set_title("Active color") self.active_color_btn.set_use_alpha(True) self.active_color_btn.connect("color-set", self.on_color_set, "active_color") table.attach(self.active_color_btn, 2, 3, 2, 3) label = gtk.Label("Padding") label.set_alignment(0, 0.5) table.attach(label, 0, 1, 3, 4) self.padding_input = gtk.HScale() self.padding_input.set_digits(0) self.padding_input.set_range(0, 10) self.padding_input.set_increments(1, 5) self.padding_input.connect("change-value", self.on_range_value_set, "padding") table.attach(self.padding_input, 1, 3, 3, 4) label = gtk.Label("Cell spacing") label.set_alignment(0, 0.5) table.attach(label, 0, 1, 4, 5) self.cell_spacing_input = gtk.HScale() self.cell_spacing_input.set_digits(0) self.cell_spacing_input.set_range(0, 10) self.cell_spacing_input.set_increments(1, 5) self.cell_spacing_input.connect("change-value", self.on_range_value_set, "cell_spacing") table.attach(self.cell_spacing_input, 1, 3, 4, 5) label = gtk.Label("Aspect ratio") label.set_alignment(0, 0.5) table.attach(label, 0, 1, 5, 6) self.aspect_ratio_input = gtk.HScale() self.aspect_ratio_input.set_digits(1) self.aspect_ratio_input.set_range(0.3, 3.0) self.aspect_ratio_input.set_increments(0.1, 1) self.aspect_ratio_input.connect("change-value", self.on_range_value_set, "aspect_ratio") table.attach(self.aspect_ratio_input, 1, 3, 5, 6) label = gtk.Label("Workspace name pattern") label.set_alignment(0, 0.5) table.attach(label, 0, 1, 6, 7) self.desk_name_pattern_input = gtk.Entry() self.desk_name_pattern_input.set_tooltip_text("%n - workspace number\n%x - workspace column\n%y - workspace row") self.desk_name_pattern_input.connect("changed", self.on_entry_value_set, "desk_name_pattern") table.attach(self.desk_name_pattern_input, 1, 3, 6, 7) self.show_all()
def createColorWidget(self): self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL) frame = gtk.Frame('Color') frame.set_border_width(0) frame.set_size_request(200, 400) frame.show() vbox = gtk.VBox(False, 0) #----Line 1 Opacity --------------- hbox = gtk.HBox(False, 0) hbox.show() label = gtk.Label("Opacity:") label.show() hbox.pack_start(label, False, True, 0) adj_hscale = gtk.Adjustment(0, 0, 100, 1.0, 5.0, 0.0) hscale = gtk.HScale(adj_hscale) hscale.set_size_request(30, -1) hscale.set_value_pos(gtk.POS_RIGHT) hscale.set_draw_value(False) hscale.set_digits(1) hbox.pack_start(hscale, True, True, 0) hscale.show() #keep hscale to global value global_var.dialogWidget['colorOpacity_hscale'] = hscale adj_spin = gtk.Adjustment(0, 0, 100, 1.0, 5.0, 0.0) spinner = gtk.SpinButton(adj_spin, 0, 0) spinner.set_wrap(True) spinner.set_size_request(15, -1) spinner.show() global_var.dialogWidget[ 'colorOpacity_spinner'] = spinner #keep spinner to global value hbox.pack_start(spinner, True, True, 0) global cval # temp value of spinner and hscale item = None color = None adj_spin.connect("value_changed", self.change_alpha_level, spinner, hscale, item, "spinner", color) adj_hscale.connect("value_changed", self.change_alpha_level, spinner, hscale, item, "hscale", color) vbox.pack_start(hbox, False, True, 0) #-----Line 2 Item Color Button ----------- label_color = gtk.Label("Color : ") label_color.show() hbox = gtk.HBox(False, 0) hbox.pack_start(label_color, False, True, 0) hbox.show() #...Create color button colorbutton = gtk.ColorButton( gtk.gdk.color_parse('#CC3300')) # Display current fill color colorbutton.connect('color-set', self.color_set_cb) colorbutton.show() global_var.dialogWidget[ 'colorColor_button'] = colorbutton # keep color button to global value colorbutton.set_size_request(45, 45) hbox.pack_start(colorbutton, False, True, 0) vbox.pack_start(hbox, False, True, 0) #-----Line 3 Item Color Fill Option----------- label_Fill = gtk.Label("Fill : ") label_Fill.show() hbox = gtk.HBox(False, 0) hbox.pack_start(label_Fill, False, True, 0) hbox.show() options = ["None", "Solid", "RGBA", "Gradiant", "Pattern"] option_color = gtk.combo_box_new_text() for opt in options: option_color.append_text(opt) option_color.set_active(0) option_color.set_size_request(85, -1) option_color.show() option_color.connect('changed', self.combo_fill_mode) global_var.dialogWidget[ 'colorFill_option'] = option_color # keep fill color option to global value hbox.pack_start(option_color, False, True, 0) vbox.pack_start(hbox, False, True, 0) #vbox.pack_start(colorbutton,False,True,0) #label.show() frame.add(vbox) vbox.show() #------Line 4 gradiant option area----------- ''' expander = gtk.Expander("Gradiant :") # The Label for the expander label = gtk.Label("Details can be shown or hidden.") expander.add(label) #label_Gradiant = gtk.Label("Gradiant : ") expander.show() hbox = gtk.HBox(False,0) hbox.pack_start(expander,False,True,0) hbox.show() #expander.add(hbox) vbox.pack_start(hbox,False,True,0)''' hbox = gtk.HBox(False, 0) vbox_s = gtk.VBox(False, 0) #scrolled_win = gtk.ScrolledWindow () #scrolled_win.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC) #gtk.POLICY_NEVER #vbox_s.pack_start (scrolled_win, False, True, 0) vbox_s.show() #vbox.pack_start(vbox, False, True, 0) label_Gradiant = gtk.Label("Gradiant Show") label_Gradiant.show() label_Pattern = gtk.Label("Pattern Show ") label_Pattern.show() expander_g = gtk.Expander("Gradiant") expander_g.show() c_pre = self.preview_canvas() expander_g.add(c_pre) expander_p = gtk.Expander("Pattern") expander_p.show() expander_p.add(label_Pattern) #scrolled_win.add(expander_g) #scrolled_win.add(expander_p) #scrolled_win.show() #scrolled_win.add(expander_p) vbox_s.pack_start(expander_g, False, True, 0) vbox_s.pack_start(expander_p, False, True, 0) #vbox_s.set_border_width(0) hbox.pack_start(vbox_s, False, True, 0) hbox.show() vbox.pack_start(hbox, False, True, 0) self.size_group.add_widget(label) self.size_group.add_widget(label_color) self.size_group.add_widget(label_Fill) #self.size_group.add_widget(label_Gradiant) return frame
def _createUI(self): self.leftSizeGroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL) self.props.row_spacing = 2 self.props.column_spacing = 2 self.hadj = gtk.Adjustment() self.vadj = gtk.Adjustment() # zooming slider self._zoomAdjustment = gtk.Adjustment() self._zoomAdjustment.set_value(Zoomable.getCurrentZoomLevel()) self._zoomAdjustment.connect("value-changed", self._zoomAdjustmentChangedCb) self._zoomAdjustment.props.lower = 0 self._zoomAdjustment.props.upper = Zoomable.zoom_steps zoomslider = gtk.HScale(self._zoomAdjustment) zoomslider.props.draw_value = False zoomslider.set_tooltip_text(_("Zoom Timeline")) self.attach(zoomslider, 0, 1, 0, 1, yoptions=0, xoptions=gtk.FILL) # controls for tracks and layers self._controls = TimelineControls() controlwindow = gtk.Viewport(None, self.vadj) controlwindow.add(self._controls) controlwindow.set_size_request(-1, 1) controlwindow.set_shadow_type(gtk.SHADOW_OUT) self.attach(controlwindow, 0, 1, 1, 2, xoptions=0) # timeline ruler self.ruler = ruler.ScaleRuler(self.app, self.hadj) self.ruler.set_size_request(0, 25) self.ruler.set_border_width(2) self.ruler.connect("key-press-event", self._keyPressEventCb) self.ruler.connect("size-allocate", self._rulerSizeAllocateCb) rulerframe = gtk.Frame() rulerframe.set_shadow_type(gtk.SHADOW_OUT) rulerframe.add(self.ruler) self.attach(rulerframe, 1, 2, 0, 1, yoptions=0) # proportional timeline self._canvas = TimelineCanvas(self.app) timelinewindow = gtk.ScrolledWindow(self.hadj, self.vadj) timelinewindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) timelinewindow.add(self._canvas) timelinewindow.set_shadow_type(gtk.SHADOW_IN) timelinewindow.set_name("timelinewindow") # temp fix for padding between scrollbar and scrolled window #FIXME: should be set at an global position for easy editing? gtk.rc_parse_string(""" style 'timelinewindow' { GtkScrolledWindow::scrollbar-spacing = 0 } widget '*.timelinewindow' style 'timelinewindow' """) self.attach(timelinewindow, 1, 2, 1, 2) # error infostub self.infostub = InfoStub() self.attach(self.infostub, 1, 2, 2, 3, yoptions=0) self.show_all() self.infostub.hide() # toolbar actions actions = ( ("ZoomIn", gtk.STOCK_ZOOM_IN, None, "<Control>plus", ZOOM_IN, self._zoomInCb), ("ZoomOut", gtk.STOCK_ZOOM_OUT, None, "<Control>minus", ZOOM_OUT, self._zoomOutCb), # actions for adding additional accelerators ("ControlEqualAccel", gtk.STOCK_ZOOM_IN, None, "<Control>equal", ZOOM_IN, self._zoomInCb), ("ControlKPAddAccel", gtk.STOCK_ZOOM_IN, None, "<Control>KP_Add", ZOOM_IN, self._zoomInCb), ("ControlKPSubtractAccel", gtk.STOCK_ZOOM_OUT, None, "<Control>KP_Subtract", ZOOM_OUT, self._zoomOutCb), ) selection_actions = ( ("DeleteObj", gtk.STOCK_DELETE, None, "Delete", DELETE, self.deleteSelected), ("UnlinkObj", "pitivi-unlink", None, "<Shift><Control>L", UNLINK, self.unlinkSelected), ("LinkObj", "pitivi-link", None, "<Control>L", LINK, self.linkSelected), ("UngroupObj", "pitivi-ungroup", None, "<Shift><Control>G", UNGROUP, self.ungroupSelected), ("GroupObj", "pitivi-group", None, "<Control>G", GROUP, self.groupSelected), ) playhead_actions = ( ("Split", "pitivi-split", _("Split"), "S", SPLIT, self.split), ("Keyframe", "pitivi-keyframe", _("Keyframe"), "K", KEYFRAME, self.keyframe), ) actiongroup = gtk.ActionGroup("timelinepermanent") actiongroup.add_actions(actions) self.ui_manager.insert_action_group(actiongroup, 0) actiongroup = gtk.ActionGroup("timelineselection") actiongroup.add_actions(selection_actions) actiongroup.add_actions(playhead_actions) self.link_action = actiongroup.get_action("LinkObj") self.unlink_action = actiongroup.get_action("UnlinkObj") self.group_action = actiongroup.get_action("GroupObj") self.ungroup_action = actiongroup.get_action("UngroupObj") self.delete_action = actiongroup.get_action("DeleteObj") self.split_action = actiongroup.get_action("Split") self.keyframe_action = actiongroup.get_action("Keyframe") self.ui_manager.insert_action_group(actiongroup, -1) self.ui_manager.add_ui_from_string(ui) # drag and drop self.drag_dest_set(gtk.DEST_DEFAULT_MOTION, [dnd.FILESOURCE_TUPLE, dnd.EFFECT_TUPLE], gtk.gdk.ACTION_COPY) self.connect("drag-data-received", self._dragDataReceivedCb) self.connect("drag-leave", self._dragLeaveCb) self.connect("drag-drop", self._dragDropCb) self.connect("drag-motion", self._dragMotionCb) self._canvas.connect("button-press-event", self._buttonPress) self._canvas.connect("button-release-event", self._buttonRelease) self._canvas.connect("key-press-event", self._keyPressEventCb)
def __init__(self, gui): gtk.Window.__init__(self) self.set_position(gtk.WIN_POS_NONE) self.connect('destroy', self.close) #self.connect('delete_event', self.exit2) self.set_title(_('Movie')) vbox = gtk.VBox() pack(vbox, gtk.Label(_('Image number:'))) self.frame_number = gtk.Adjustment(gui.frame, 0, gui.images.nimages - 1, 1.0, 5.0) self.frame_number.connect('value-changed', self.new_frame) hscale = pack(vbox, gtk.HScale(self.frame_number)) hscale.set_update_policy(gtk.UPDATE_CONTINUOUS) hscale.set_digits(0) buttons = [gtk.Button(stock=gtk.STOCK_GOTO_FIRST), gtk.Button(stock=gtk.STOCK_GO_BACK), gtk.Button(stock=gtk.STOCK_GO_FORWARD), gtk.Button(stock=gtk.STOCK_GOTO_LAST)] buttons[0].connect('clicked', self.click, -1, True) buttons[1].connect('clicked', self.click, -1) buttons[2].connect('clicked', self.click, 1) buttons[3].connect('clicked', self.click, 1, True) pack(vbox, buttons) play = gtk.Button(_('Play')) play.connect('clicked', self.play) stop = gtk.Button(_('Stop')) stop.connect('clicked', self.stop) # TRANSLATORS: This function plays an animation forwards and backwards # alternatingly, e.g. for displaying vibrational movement self.rock = gtk.CheckButton(_('Rock')) pack(vbox, [play, stop, gtk.Label(' '), self.rock]) if gui.images.nimages > 150: skipdefault = gui.images.nimages/150 tdefault = min(max(gui.images.nimages/(skipdefault*5.0), 1.0), 30) else: skipdefault = 0 tdefault = min(max(gui.images.nimages/5.0, 1.0), 30) self.time = gtk.Adjustment(tdefault, 1.0, 99, 0.1) self.time_spin = gtk.SpinButton(self.time, 0, 0) self.time_spin.set_digits(1) self.time.connect("value-changed",self.frame_rate_changed) self.skip = gtk.Adjustment(skipdefault, 0, 99, 1) self.skip_spin = gtk.SpinButton(self.skip, 0, 0) pack(vbox, [gtk.Label(_(' Frame rate: ')), self.time_spin, gtk.Label(_(' Skip frames: ')), self.skip_spin, gtk.Label(' ')]) self.add(vbox) vbox.show() self.show() self.gui = gui #gui.m=self self.direction = 1 self.id = None gui.register_vulnerable(self)
def create_widgets(self): self.W = gtk.Window() self.W.set_title('Cut Recovery') self.W.set_position(gtk.WIN_POS_MOUSE) self.W.set_keep_above(True) self.W.connect('delete_event', self.on_window_delete_event) self.T = gtk.Table() self.T.set_homogeneous(True) self.W.add(self.T) self.rev = gtk.Button('Rev') self.rev.connect('pressed', self.rev_pressed) self.rev.connect('released', self.rev_released) self.T.attach(self.rev, 0, 1, 0, 2) self.rate = gtk.Adjustment(value=50, lower=1, upper=100, step_incr=1, page_incr=10, page_size=0) self.rate.emit('value_changed') self.feed = gtk.HScale(adjustment = self.rate) self.feed.set_digits(0) self.T.attach(self.feed, 1, 4, 0, 2) self.fwd = gtk.Button('Fwd') self.fwd.connect('pressed', self.fwd_pressed) self.fwd.connect('released', self.fwd_released) self.T.attach(self.fwd, 4, 5, 0, 2) self.XminusYplus = gtk.Button('X- Y+') self.XminusYplus.connect('pressed', self.XminusYplus_pressed) self.T.attach(self.XminusYplus, 1, 2, 3, 5) self.Yplus = gtk.Button('Y+') # self.Yplus = gtk.Button() # image = gtk.image_new_from_stock(gtk.STOCK_GO_UP, gtk.ICON_SIZE_SMALL_TOOLBAR) # self.Yplus.add(image) self.Yplus.connect('pressed', self.Yplus_pressed) self.T.attach(self.Yplus, 2, 3, 3, 5) self.XplusYplus = gtk.Button('X- Y-') self.XplusYplus.connect('pressed', self.XplusYplus_pressed) self.T.attach(self.XplusYplus, 3, 4, 3, 5) self.Xminus = gtk.Button('X-') # self.Xminus = gtk.Button() # image = gtk.image_new_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_SMALL_TOOLBAR) # self.Xminus.add(image) self.Xminus.connect('pressed', self.Xminus_pressed) self.T.attach(self.Xminus, 1, 2, 5, 7) self.Xplus = gtk.Button('X+') # self.Xplus = gtk.Button() # image = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR) # self.Xplus.add(image) self.Xplus.connect('pressed', self.Xplus_pressed) self.T.attach(self.Xplus, 3, 4, 5, 7) self.XminusYminus = gtk.Button('X- Y-') self.XminusYminus.connect('pressed', self.XminusYminus_pressed) self.T.attach(self.XminusYminus, 1, 2, 7, 9) self.Yminus = gtk.Button('Y-') # self.Yminus = gtk.Button() # image = gtk.image_new_from_stock(gtk.STOCK_GO_DOWN, gtk.ICON_SIZE_SMALL_TOOLBAR) # self.Yminus.add(image) self.Yminus.connect('pressed', self.Yminus_pressed) self.T.attach(self.Yminus, 2, 3, 7, 9) self.XplusYminus = gtk.Button('X+\nY-') self.XplusYminus.connect('pressed', self.XplusYminus_pressed) self.T.attach(self.XplusYminus, 3, 4, 7, 9) # IMAGES FROM FILES # pixbuf = gtk.gdk.pixbuf_new_from_xpm_data(filename='./wizards/images/downarrow.xbm'.format(wizard)) # image = gtk.Image() # image.set_from_pixbuf(pixbuf) # self.<button_name>.add(image) self.resume = gtk.Button('Resume\nCut') for child in self.resume.children(): child.set_justify(gtk.JUSTIFY_CENTER) self.resume.connect('pressed', self.resume_pressed) self.T.attach(self.resume, 0, 1, 10, 12) self.cancel = gtk.Button('Cancel') self.cancel.connect('pressed', self.cancel_pressed) self.T.attach(self.cancel, 4, 5, 10, 12) hal.set_p('plasmac_run.preview-tab', '1') self.W.show_all()
def __init__(self, theme, ink_canvas): gtk.Toolbar.__init__(self) self._inkcanvas = ink_canvas ### paint button paint_image = gtk.Image() paint_image.set_from_pixbuf(theme.load_icon('paintbrush', 48, 0)) paint_button = gtk.RadioToolButton() paint_button.set_icon_widget(paint_image) paint_button.set_label('Paintbrush') paint_button.connect('clicked', self.__set_paint) ### eraser button erase_image = gtk.Image() erase_image.set_from_pixbuf(theme.load_icon('eraser', 48, 0)) erase_button = gtk.RadioToolButton(paint_button) erase_button.set_icon_widget(erase_image) erase_button.set_label('Eraser') erase_button.connect('clicked', self.__set_eraser) ### Color select self._color_label = ColorLabel(self._inkcanvas.get_stroke_color()) hbox = gtk.HBox() hbox.pack_start(self._color_label) hbox.pack_start(gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)) color_button = gtk.ToolItem() color_button_t = ColorButton(hbox) color_button_t.connect('color-set', self.__color_set, paint_button) color_button.add(color_button_t) ### clear button imgclear = gtk.Image() imgclear.set_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_LARGE_TOOLBAR ) clear = gtk.ToolButton(imgclear) clear.set_label('Clear') clear.connect( 'clicked', self.__clear_canvas ) main_img = gtk.Image() main_img.set_from_pixbuf(theme.load_icon('medium_grid', 48, 0)) blank_img = gtk.Image() blank_img.set_from_pixbuf(theme.load_icon('no_grid', 48, 0) ) small_img = gtk.Image() small_img.set_from_pixbuf(theme.load_icon('small_grid', 48, 0)) medium_img = gtk.Image() medium_img.set_from_pixbuf(theme.load_icon('medium_grid', 48, 0)) large_img = gtk.Image() large_img.set_from_pixbuf(theme.load_icon('large_grid', 48, 0)) ### grid button grid_button_t = GridButton( main_img, blank_img, small_img, medium_img, large_img, self._inkcanvas.get_grid_type()) grid_button_t.connect( 'grid-type-set', self.__set_grid_type) grid_button = gtk.ToolItem() grid_button.add(grid_button_t) ### undo Button undo_button = gtk.ToolButton() undo_button.set_stock_id(gtk.STOCK_UNDO) undo_button.connect("clicked", self.__undo) ### redo Button redo_button = gtk.ToolButton() redo_button.set_stock_id(gtk.STOCK_REDO) redo_button.connect("clicked", self.__redo) ### size Slider brushsmall_t = gtk.Image() brushsmall_t.set_from_pixbuf(theme.load_icon('brush-small', 48, 0)) brushsmall = gtk.ToolItem() brushsmall.add(brushsmall_t) brushlarge_t = gtk.Image() brushlarge_t.set_from_pixbuf(theme.load_icon('brush-large', 48, 0)) brushlarge = gtk.ToolItem() brushlarge.add(brushlarge_t) brush_slider_t = gtk.HScale(gtk.Adjustment(value=8, lower=1, upper=20, step_incr=0.5, page_incr=1, page_size=0)) brush_slider_t.set_size_request(130, -1) brush_slider_t.set_value_pos(gtk.POS_RIGHT) brush_slider_t.set_digits(0) brush_slider_t.set_update_policy(gtk.UPDATE_DISCONTINUOUS) brush_slider_t.connect("value-changed", self.__set_size) brush_slider = gtk.ToolItem() brush_slider.add(brush_slider_t) ### toolbar self.set_show_arrow(True) self.insert(color_button, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(paint_button, -1) self.insert(erase_button, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(undo_button, -1) self.insert(redo_button, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(clear, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(grid_button, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(brushsmall, -1) self.insert(brush_slider, -1) self.insert(brushlarge, -1)
def __init__(self, uistate, dbstate, map, layer, places, lat, lon, function, oldvalue=None): """ We show a selection box for possible places in a region of the map. We can select the diameter of the region which is a circle. Depending of this region, we can show the possible choice. We select the value depending of our need which open the EditPlace box. """ try: ManagedWindow.ManagedWindow.__init__(self, uistate, [], PlaceSelection) except Errors.WindowActiveError: return self.uistate = uistate self.dbstate = dbstate self.lat = lat self.lon = lon self.osm = map self.radius = 1.0 self.circle = None self.oldvalue = oldvalue self.place_list = places self.function = function self.selection_layer = layer self.layer = layer alignment = gtk.Alignment(0, 1, 0, 0) self.set_window( gtk.Dialog(_('Place Selection in a region'), flags=gtk.DIALOG_NO_SEPARATOR, buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)), None, _('Place Selection in a region'), None) label = gtk.Label( _('Choose the radius of the selection.\n' 'On the map you should see a circle or an oval depending on the latitude.' )) alignment.add(label) self.window.vbox.pack_start(alignment, expand=False) adj = gtk.Adjustment( 1.0, 0.1, 3.0, 0.1, 0, 0) # default value is 1.0, minimum is 0.1 and max is 3.0 slider = gtk.HScale(adj) slider.set_update_policy(gtk.UPDATE_DISCONTINUOUS) slider.set_digits(1) slider.set_value_pos(gtk.POS_BOTTOM) slider.connect('value-changed', self.slider_change, self.lat, self.lon) self.window.vbox.pack_start(slider, expand=False) self.vadjust = gtk.Adjustment(page_size=15) self.scroll = gtk.ScrolledWindow(self.vadjust) self.scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self.scroll.set_shadow_type(gtk.SHADOW_IN) self.plist = gtk.ListStore(str, str, str) self.choices = gtk.TreeView(self.plist) self.scroll.add(self.choices) self.renderer = gtk.CellRendererText() self.tvcol1 = gtk.TreeViewColumn(_('Country'), self.renderer, markup=0) self.tvcol2 = gtk.TreeViewColumn(_('State'), self.renderer, markup=1) self.tvcol3 = gtk.TreeViewColumn(_('County'), self.renderer, markup=2) self.tvcol1.set_sort_column_id(0) self.tvcol2.set_sort_column_id(1) self.tvcol3.set_sort_column_id(2) self.choices.append_column(self.tvcol1) self.choices.append_column(self.tvcol2) self.choices.append_column(self.tvcol3) self.window.vbox.pack_start(self.scroll, expand=True) self.label2 = gtk.Label() self.label2.set_markup( '<span background="green" foreground="black">%s</span>' % _('The green values in the row correspond to the current place values.' )) alignment = gtk.Alignment(0, 1, 0, 0) alignment.add(self.label2) self.window.vbox.pack_start(alignment, expand=False) self.window.set_default_size(400, 300) self.choices.connect('row-activated', self.selection, function) self.window.connect('response', self.close) self.window.show_all() self.show() self.label2.hide() self.slider_change(None, lat, lon)
def __init__(self): self.dmxoff = False self.colours = [ ("Red", (255,0,0)), ("Green", (0,255,0)), ("Blue", (0,0,255)), ("Cyan", (0,255,255)), ("Magenta", (255,0,255)), ("Lime", (255,255,0)), ("Orange", (255,55,0)), ("Yellow", (255,72,0)), ("Natural", (255,77,18)), ("White", (255,152,58)), ("Full", (255,255,255)) ] self.window = gtk.Window (gtk.WINDOW_TOPLEVEL) self.window.connect("destroy", lambda w: gtk.main_quit()) self.window.set_title("range controls") self.window.set_position(gtk.WIN_POS_CENTER) self.tooltips = gtk.Tooltips() box1 = gtk.VBox(False, 0) self.window.add(box1) labels = { 1: "R", 2: "G", 3: "B", 4: "white", 5: "strobe & speed", 6: "mode" } self.adjustments = {} boxh = gtk.HBox(False, 20) boxh.set_border_width(20) blackout = gtk.CheckButton("Blackout") self.blackout = blackout blackout.connect("toggled", self.cb_master) boxh.pack_start(blackout, True, True, 0) dmxoff = gtk.CheckButton("DMX Off") self.dmxoff = dmxoff dmxoff.connect("toggled", self.cb_dmxoff) boxh.pack_start(dmxoff, True, True, 2) reset = gtk.Button("Refresh") reset.connect("clicked", self.cb_reset) boxh.pack_start(reset, False, False, 0) fadeout = gtk.Button("Fadeout") fadeout.connect("clicked", self.cb_fadeout) boxh.pack_start(fadeout, False, False, 0) fadein = gtk.Button("Fadein") fadein.connect("clicked", self.cb_fadein) boxh.pack_start(fadein, False, False, 0) box1.pack_start(boxh, True, True, 0) box2 = gtk.HBox(False, 5) box2.set_border_width(5) for colour in self.colours: button = gtk.Button(colour[0]) button.connect("clicked", self.cb_colours, colour[1]) self.tooltips.set_tip(button, str(colour[1])) box2.pack_start(button, True, True, 0) box1.pack_start(box2, False, False, 0) box2 = gtk.HBox(False, 20) box2.set_border_width(20) label = gtk.Label("Master") box2.pack_start(label, False, False, 0) box2 = gtk.HBox(False, 20) box2.set_border_width(20) label = gtk.Label("Master") box2.pack_start(label, False, False, 0) adjm = gtk.Adjustment(1.0, 0.0, 1.0, 1/255.0, 1/255.0, 0.0) self.adjm = adjm adjm.connect("value_changed", self.cb_master) scale = gtk.HScale(adjm) scale.set_digits(3) box2.pack_start(scale, True, True, 0) box1.pack_start(box2, True, True, 0) for i in xrange(1,7): box2 = gtk.HBox(False, 10) box2.set_border_width(10) label = gtk.Label(labels[i]) box2.pack_start(label, False, False, 0) adj3 = gtk.Adjustment(0.0, 0.0, 255.0, 1.0, 25.0, 0.0) self.adjustments[i] = adj3 adj3.connect("value_changed", self.cb_dmx, i) scale = gtk.HScale(adj3) scale.set_digits(0) box2.pack_start(scale, True, True, 0) box1.pack_start(box2, True, True, 0) if i==6: # 0 - 31: normal & strobe # 31 - 63: fade in # 64 - 95: fade out # 96 -127: fade in & out # 128-159: colour change (smooth) # 160-223: colour change (immediate, 3 colors) # 224-255: audio sensitive self.moderange = adj3 combobox = gtk.combo_box_new_text() combobox.append_text("Normal") combobox.append_text("Strobe (& Normal)") combobox.append_text("Fade In") combobox.append_text("Fade Out") combobox.append_text("Fade In & Out") combobox.append_text("Colour Change (smooth)") combobox.append_text("Colour Change (rough, 3 colours)") combobox.append_text("Colour Change (rough, 7 colours)") combobox.append_text("Audio") combobox.connect('changed', self.cb_mode) box2.pack_start(combobox, False, False, 0) combobox.set_active(0) else: reset = gtk.Button("Refresh") reset.connect("clicked", self.cb_reset) zero = gtk.Button(" 0 ") zero.connect("clicked", self.cb_zero, i) box2.pack_start(zero, False, False, 0) if i != 4: full = gtk.Button(" F ") full.connect("clicked", self.cb_full, i) box2.pack_start(full, False, False, 0) separator = gtk.HSeparator() box1.pack_start(separator, False, True, 0) box2 = gtk.VBox(False, 10) box2.set_border_width(10) box2.set_size_request(400, -1) box1.pack_start(box2, False, True, 0) button = gtk.Button("Quit") button.connect("clicked", lambda w: gtk.main_quit()) box2.pack_start(button, True, True, 0) button.set_flags(gtk.CAN_DEFAULT) button.grab_default() self.window.show_all()
def __init__(self, library): self._library = library gtk.HBox.__init__(self, False, 12) self.set_border_width(10) borderbox = gtk.EventBox() borderbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#333')) borderbox.set_size_request(350, -1) insidebox = gtk.EventBox() insidebox.set_border_width(1) insidebox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#ddb')) infobox = gtk.VBox(False, 5) infobox.set_border_width(10) self.pack_start(borderbox, False, False) borderbox.add(insidebox) insidebox.add(infobox) self._namelabel = labels.BoldLabel() self._namelabel.set_ellipsize(pango.ELLIPSIZE_MIDDLE) self._namelabel.set_alignment(0, 0.5) infobox.pack_start(self._namelabel, False, False) self._pageslabel = gtk.Label() self._pageslabel.set_ellipsize(pango.ELLIPSIZE_MIDDLE) self._pageslabel.set_alignment(0, 0.5) infobox.pack_start(self._pageslabel, False, False) self._filelabel = gtk.Label() self._filelabel.set_ellipsize(pango.ELLIPSIZE_MIDDLE) self._filelabel.set_alignment(0, 0.5) infobox.pack_start(self._filelabel, False, False) self._dirlabel = gtk.Label() self._dirlabel.set_ellipsize(pango.ELLIPSIZE_MIDDLE) self._dirlabel.set_alignment(0, 0.5) infobox.pack_start(self._dirlabel, False, False) vbox = gtk.VBox(False, 10) self.pack_start(vbox, True, True) hbox = gtk.HBox(False) vbox.pack_start(hbox, False, False) label = gtk.Label('%s:' % _('Search')) hbox.pack_start(label, False, False) search_entry = gtk.Entry() search_entry.connect('activate', self._filter_books) search_entry.set_tooltip_text( _('Display only those books that have the specified text string in their full path. The search is not case sensitive.' )) hbox.pack_start(search_entry, True, True, 6) label = gtk.Label('%s:' % _('Cover size')) hbox.pack_start(label, False, False, 6) adjustment = gtk.Adjustment(prefs['library cover size'], 50, 128, 1, 10, 0) cover_size_scale = gtk.HScale(adjustment) cover_size_scale.set_size_request(150, -1) cover_size_scale.set_draw_value(False) cover_size_scale.connect('value_changed', self._change_cover_size) hbox.pack_start(cover_size_scale, False, False) vbox.pack_start(gtk.HBox(), True, True) hbox = gtk.HBox(False, 10) vbox.pack_start(hbox, False, False) add_book_button = gtk.Button(_('Add books')) add_book_button.set_image( gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON)) add_book_button.connect('clicked', self._add_books) add_book_button.set_tooltip_text(_('Add more books to the library.')) hbox.pack_start(add_book_button, False, False) add_collection_button = gtk.Button(_('Add collection')) add_collection_button.connect('clicked', self._add_collection) add_collection_button.set_image( gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON)) add_collection_button.set_tooltip_text( _('Add a new empty collection.')) hbox.pack_start(add_collection_button, False, False) hbox.pack_start(gtk.HBox(), True, True) self._open_button = gtk.Button(None, gtk.STOCK_OPEN) self._open_button.connect('clicked', self._library.book_area.open_selected_book) self._open_button.set_tooltip_text(_('Open the selected book.')) self._open_button.set_sensitive(False) hbox.pack_start(self._open_button, False, False)
def on_treeEffects_button_release_event(self, widget, *args): print "on_treeEffects_button_release_event" # get correct gettext method _ = self._ # get selected effect (if any) selected_effect, unique_id = self.get_selected_effect() real_effect = self.OSTreeEffects.get_real_effect( service=selected_effect) clip_effect = self.get_clip_effect(unique_id) if real_effect: # show the settings panel self.vbox_effect_settings.set_property('visible', True) # Clear Effect Edit Controls self.clear_effect_controls() # Loop through Params param_index = 1 for param in real_effect.params: # get hbox hbox = self.vbox_effect_settings.get_children()[param_index] label = hbox.get_children()[0] self.sizegroup1.add_widget(label) # Get actual value for param user_param_value = self.get_clip_parameter( clip_effect, param.name) # update label with title label.set_text(_(param.title)) label.set_tooltip_text(_(param.title)) if param.type == "spinner": # create spinner adj = gtk.Adjustment(float(user_param_value), float(param.min), float(param.max), float(param.step), float(param.step), 0.0) spinner = gtk.SpinButton(adj, float(param.step), int(param.digits)) # connect signal spinner.connect("value-changed", self.effect_spinner_changed, real_effect, param, unique_id) # add to hbox hbox.pack_start(spinner, expand=True, fill=True) elif param.type == "hscale": # create hscale adj = gtk.Adjustment(float(user_param_value), float(param.min), float(param.max), float(param.step), float(param.step), 0.0) hscale = gtk.HScale(adj) hscale.set_digits(int(param.digits)) # connect signal hscale.connect("value-changed", self.effect_hscale_changed, real_effect, param, unique_id) # add to hbox hbox.pack_start(hscale, expand=True, fill=True) elif param.type == "dropdown": cboBox = gtk.combo_box_new_text() # add values box_index = 0 for k, v in param.values.items(): # add dropdown item cboBox.append_text(k) # select dropdown (if default) if v == user_param_value: cboBox.set_active(box_index) box_index = box_index + 1 # connect signal cboBox.connect("changed", self.effect_dropdown_changed, real_effect, param, unique_id) # add to hbox hbox.pack_start(cboBox, expand=True, fill=True) elif param.type == "color": colorButton = gtk.ColorButton() # set color default_color = gtk.gdk.color_parse(user_param_value) colorButton.set_color(default_color) # connect signal colorButton.connect("color-set", self.effect_color_changed, real_effect, param, unique_id) # add to hbox hbox.pack_start(colorButton, expand=True, fill=True) # show all new controls hbox.show_all() # increment param index param_index = param_index + 1
snakewindow.connect("key-press-event", sens) # BOTTOM SETTINGS def pixelset_fun(widget): global pixelsize pixelsize = int(widget.get_value()) box = gtk.HBox(True) mainbox.pack_end(box, False) adj = gtk.Adjustment(0.0, 1.0, 100.0, 1.0, 10.0, 0.0) pixelset = gtk.HScale(adj) box.pack_start(pixelset) pixelset.set_value(pixelsize) pixelset.connect("value-changed", pixelset_fun) def speedset_fun(widget): global tickspeed tickspeed = int(widget.get_value()) adj2 = gtk.Adjustment(0.0, 1.0, 1000.0, 1.0, 10.0, 0.0) speedset = gtk.HScale(adj2) box.pack_start(speedset)
def __init__(self, tareas): """ days es el número de días totales que se pueden representar. Los que actualmente se muestren depende del zoom aplicado. tareas es el conjunto de datos *inicial* a ser mostrado. El valor en cada momento (self.tareas) puede ser diferente en función de las operaciones con el backend. """ self.ventana = gtk.Window() self.ventana.set_size_request(800, 400) self.ventana.connect("delete_event", lambda *a, **kw: gtk.main_quit()) self.ventana.connect("destroy", lambda *a, **kw: gtk.main_quit()) self.container = gtk.VBox() self.grafica = gtk.HBox() self.container.pack_start(self.grafica) self.container.set_property("border-width", 5) self.controls = gtk.VBox() self.lower_controls = gtk.HBox() self.lower_controls.set_property("homogeneous", True) self.lower_controls.set_property("spacing", 10) self.b_salir = gtk.Button(stock = gtk.STOCK_QUIT) self.b_salir.connect("clicked", self.__salir) self.lower_controls.add(self.b_salir) # El valor más alto que se puede obtener es upper - page_size self.zoom = gtk.Adjustment(62.0, 1.0, 365.0 + 31.0, 1.0, 31.0, 31.0) self.zoom_level = 62 self.slider = gtk.HScale(self.zoom) self.slider.set_digits(0) self.slider.get_layout().set_font_description( pango.FontDescription("monospace 8")) for i in range(31, 365, 31): try: self.slider.add_mark(i, gtk.POS_TOP, None) except AttributeError: pass # Versión de pygtk sin add_mark self.lower_controls.add(self.slider) self.slider.connect("value-changed", self._update_zoom) if not tareas: days = 0 else: days = (max(tareas, key = lambda t: t.fin).fin - min(tareas, key = lambda t: t.ini).ini).days self.scrollbar = gtk.HScrollbar() self.adj_scroll = gtk.Adjustment(0, 0, days + 10, 1, 10, 10) self.scrollbar.set_adjustment(self.adj_scroll) self.controls.pack_start(self.scrollbar, expand = False) self.first_day = 0 self.adj_scroll.connect("value-changed", self._update_first_day) self.b_vista = gtk.ToggleButton("Ver por línea") self.b_vista.connect("toggled", self._cambiar_vista) self.lower_controls.pack_end(self.b_vista, expand = False) self.controls.pack_start(self.lower_controls, expand = False) self.container.pack_start(self.controls, expand = False) self.ventana.add(self.container) self.ventana.set_title("Vista por empleado") self.vista_por_empleado = True #tareas.sort(key = lambda t: t.fecha) self.tareas = tareas self.load_escena() self.grafica.add(self.escena) self.ventana.show_all()
def setup(self): try: self.contentTable.set_homogeneous(False) catListlenght = len(self.config.categories) if catListlenght <= 0: return False row = ((catListlenght + (catListlenght % 2)) / 2) - catListlenght % 2 frames = {} frameContent = {} catCntr = 0 contentCntr = 0 self.contentTable.resize(row + 3, 2) self.contentTable.attach(self.ctrl, 0, 2, 1, 2, gtk.FILL, gtk.FILL) self.contentTable.attach(self.selector, 0, 2, 0, 1, gtk.FILL, gtk.FILL) cur = self.profileview.configFileCombo.get_model() for val in cur: if val[0] == self.config.cacheFileName: try: self.configFileCombo.handler_block_by_func( self.on_profileSelector_changed) except TypeError as e: pass self.configFileCombo.set_active(val.path[0]) try: self.configFileCombo.handler_unblock_by_func( self.on_profileSelector_changed) except TypeError as e: pass while catCntr < catListlenght: frames[catCntr] = gtk.Frame() tLabel = gtk.Label('<b>' + self.config.categories[catCntr] + '</b>') tLabel.set_use_markup(True) frames[catCntr].set_label_widget(tLabel) frameContent[catCntr] = {} frameContent[catCntr]['labels'] = {} frameContent[catCntr]['texts'] = {} frameContent[catCntr]['tooltips'] = {} currentCol = catCntr % 2 currentRow = (catCntr / 2) + 2 if len(self.config.ctlParams[catCntr]) > 0: frameContent[catCntr]['table'] = gtk.Table( len(self.config.ctlParams[catCntr]), 2, False) else: frameContent[catCntr]['table'] = gtk.Table(1, 2, False) contentCntr = 0 for val in sorted(self.config.ctlParams[catCntr], key=str.lower): if self.config.getSystemValue( val) != self.config.ctlParams[catCntr][val]: star = "*" else: star = "" frameContent[catCntr]['labels'][contentCntr] = gtk.Label( self.config.originalToAlias(val) + star) frameContent[catCntr]['labels'][contentCntr].set_alignment( 0, 0.5) frameContent[catCntr]['tooltips'][ contentCntr] = tuna.proc_sys_help(val) if len(frameContent[catCntr]['tooltips'][contentCntr]): frameContent[catCntr]['labels'][ contentCntr].set_tooltip_text( frameContent[catCntr]['tooltips'][contentCntr]) if val in self.config.ctlGuiParams[catCntr]: # scale control frameContent[catCntr]['texts'][ contentCntr] = gtk.HScale() frameContent[catCntr]['texts'][contentCntr].set_range( self.config.ctlGuiParams[catCntr][val][0], self.config.ctlGuiParams[catCntr][val][1]) frameContent[catCntr]['texts'][ contentCntr].set_update_policy( gtk.UPDATE_CONTINUOUS) frameContent[catCntr]['texts'][contentCntr].set_value( int(self.config.ctlParams[catCntr][val])) frameContent[catCntr]['texts'][contentCntr].set_digits( 0) else: # input field frameContent[catCntr]['texts'][ contentCntr] = gtk.Entry(256) frameContent[catCntr]['texts'][ contentCntr].set_alignment(0) frameContent[catCntr]['texts'][contentCntr].set_text( self.config.ctlParams[catCntr][val]) frameContent[catCntr]['texts'][contentCntr].connect( "button-release-event", self.checkStar, catCntr, contentCntr, val, frameContent[catCntr]['labels'][contentCntr]) frameContent[catCntr]['texts'][contentCntr].connect( "focus-out-event", self.checkStar, catCntr, contentCntr, val, frameContent[catCntr]['labels'][contentCntr]) frameContent[catCntr]['table'].attach( frameContent[catCntr]['labels'][contentCntr], 0, 1, contentCntr, contentCntr + 1, gtk.FILL, xpadding=5) frameContent[catCntr]['table'].attach( frameContent[catCntr]['texts'][contentCntr], 1, 2, contentCntr, contentCntr + 1, xpadding=10) contentCntr = contentCntr + 1 frames[catCntr].add(frameContent[catCntr]['table']) self.contentTable.attach(frames[catCntr], currentCol, currentCol + 1, currentRow, currentRow + 1, gtk.FILL | gtk.EXPAND, gtk.FILL, 1, 1) catCntr = catCntr + 1 self.ctrl.set_padding(5, 5, 0, 5) self.contentTable.set_border_width(5) self.contentTable.show_all() except AttributeError as e: return False
def __init__(self): self.saved_views = {} self.gtk = gtk.Window(gtk.WINDOW_TOPLEVEL) self.gtk.set_title('Demo of a Mockup of OOF3D Interface') self.gtk.set_default_size(initial_width, initial_height) self.gtk.connect("destroy", self.destroy) self.gtk.connect("delete_event", self.destroy) self.cubeActor = None # set up areas self.panes = gtk.HPaned() self.gtk.add(self.panes) self.canvas = Canvas3D(self) self.panes.add2(self.canvas) self.toolboxframe = gtk.Frame() self.toolboxframe.set_shadow_type(gtk.SHADOW_IN) self.panes.add1(self.toolboxframe) self.scroll = gtk.ScrolledWindow() self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.toolboxframe.add(self.scroll) self.mainbox = gtk.VBox() self.scroll.add_with_viewport(self.mainbox) # viewer widgets viewerframe = gtk.Frame("Viewer Widgets") viewerframe.set_shadow_type(gtk.SHADOW_IN) self.mainbox.pack_start(viewerframe) viewerbox = gtk.VBox() viewerframe.add(viewerbox) self.tooltips = gtk.Tooltips() # camera position infoframe = gtk.Frame("Camera Info") infoframe.set_shadow_type(gtk.SHADOW_IN) viewerbox.pack_start(infoframe, fill=0, expand=0) infobox = gtk.VBox() infoframe.add(infobox) positionlabel = gtk.Label("Camera Position:") #self.tooltips.set_tip(positionlabel, "The position of the camera in world coordinates (pixel units)") infobox.pack_start(positionlabel,fill=0, expand=0) positiontable = gtk.Table(columns=3, rows=1) infobox.pack_start(positiontable,fill=0, expand=0) self.camera_x = gtk.Entry() self.camera_x.set_size_request(90,-1) self.camera_x.set_editable(0) positiontable.attach(self.camera_x,0,1,0,1) self.camera_y = gtk.Entry() self.camera_y.set_size_request(90,-1) self.camera_y.set_editable(0) positiontable.attach(self.camera_y,1,2,0,1) self.camera_z = gtk.Entry() self.camera_z.set_size_request(90,-1) self.camera_z.set_editable(0) positiontable.attach(self.camera_z,2,3,0,1) focalpointlabel = gtk.Label("Focal Point:") #self.tooltips.set_tip(focalpointlabel, "The position of the focal point in world coordinates (pixel units)") infobox.pack_start(focalpointlabel,fill=0, expand=0) focalpointtable = gtk.Table(columns=3, rows=1) infobox.pack_start(focalpointtable,fill=0, expand=0) self.fp_x = gtk.Entry() self.fp_x.set_size_request(90,-1) self.fp_x.set_editable(0) focalpointtable.attach(self.fp_x,0,1,0,1) self.fp_y = gtk.Entry() self.fp_y.set_size_request(90,-1) self.fp_y.set_editable(0) focalpointtable.attach(self.fp_y,1,2,0,1) self.fp_z = gtk.Entry() self.fp_z.set_size_request(90,-1) self.fp_z.set_editable(0) focalpointtable.attach(self.fp_z,2,3,0,1) viewuplabel = gtk.Label("View Up Vector:") #self.tooltips.set_tip(viewuplabel, "The vector that points up in the viewport") infobox.pack_start(viewuplabel,fill=0, expand=0) viewuptable = gtk.Table(columns=3, rows=1) infobox.pack_start(viewuptable,fill=0, expand=0) self.viewup_x = gtk.Entry() self.viewup_x.set_size_request(90,-1) self.viewup_x.set_editable(0) viewuptable.attach(self.viewup_x,0,1,0,1) self.viewup_y = gtk.Entry() self.viewup_y.set_size_request(90,-1) self.viewup_y.set_editable(0) viewuptable.attach(self.viewup_y,1,2,0,1) self.viewup_z = gtk.Entry() self.viewup_z.set_size_request(90,-1) self.viewup_z.set_editable(0) viewuptable.attach(self.viewup_z,2,3,0,1) distancetable = gtk.Table(columns=2, rows=1) infobox.pack_start(distancetable,fill=0, expand=0) distancelabel = gtk.Label("Distance:") #self.tooltips.set_tip(distancelabel, "The distance from the camera to the focal point") distancetable.attach(distancelabel,0,1,0,1) self.distance = gtk.Entry() self.distance.set_size_request(90,-1) self.distance.set_editable(0) distancetable.attach(self.distance,1,2,0,1) angletable = gtk.Table(columns=2, rows=1) infobox.pack_start(angletable,fill=0, expand=0) anglelabel = gtk.Label("View Angle:") #self.tooltips.set_tip(anglelabel, "The angle between the vectors from the camera to the focal point and from the camera to the top of the microstructure") angletable.attach(anglelabel,0,1,0,1) self.viewangle = gtk.Entry() self.viewangle.set_size_request(90,-1) self.viewangle.set_editable(0) angletable.attach(self.viewangle,1,2,0,1) printinfo = gtk.Button("Print Camera Info") gtklogger.connect(printinfo, 'clicked', self.printcam) self.tooltips.set_tip(printinfo, "Print the camera information in the console") infobox.pack_start(printinfo,fill=0, expand=0) # zoom - as in changing the viewing angle zoomframe = gtk.Frame("Zoom") zoomframe.set_shadow_type(gtk.SHADOW_IN) viewerbox.pack_start(zoomframe, fill=0, expand=0) zoombox = gtk.VBox() zoomframe.add(zoombox) buttonrow = gtk.HBox(homogeneous=1, spacing=2) zoombox.pack_start(buttonrow, expand=0, fill=1, padding=2) zinbutton = gtk.Button('Zoom In') self.tooltips.set_tip(zinbutton,"Decrease view angle to by given factor") buttonrow.pack_start(zinbutton, expand=0, fill=1) gtklogger.connect(zinbutton, 'clicked', self.zoomin) zoutbutton = gtk.Button('Zoom Out') self.tooltips.set_tip(zoutbutton, "Increase view angle by given factor") buttonrow.pack_start(zoutbutton, expand=0, fill=1) gtklogger.connect(zoutbutton, 'clicked', self.zoomout) zfillbutton = gtk.Button('Fill') self.tooltips.set_tip(zfillbutton, "Set view angle such that microstructure approximately fills viewport") buttonrow.pack_start(zfillbutton, expand=0, fill=1) gtklogger.connect(zfillbutton, 'clicked', self.zoomfill) factorrow = gtk.HBox() zoombox.pack_start(factorrow, expand=0, fill=0, padding=2) factorrow.pack_start(gtk.Label("Factor: "), expand=0, fill=0) self.zoomfactor = gtk.Entry() self.zoomfactor.set_editable(1) self.zoomfactor.set_size_request(80, -1) self.zoomfactor.set_text("1.5") self.tooltips.set_tip(self.zoomfactor, "Factor by which to shrink or magnify image") factorrow.pack_start(self.zoomfactor, expand=1, fill=1) # Translation # dolly transframe = gtk.Frame("Translation") transframe.set_shadow_type(gtk.SHADOW_IN) viewerbox.pack_start(transframe, fill=0, expand=0) transbox = gtk.VBox() transframe.add(transbox) dollyrow = gtk.HBox(homogeneous=1, spacing=2) transbox.pack_start(dollyrow, expand=0, fill=1, padding=2) inbutton = gtk.Button('Dolly In') self.tooltips.set_tip(inbutton,"Translate camera towards focal point by given factor") dollyrow.pack_start(inbutton, expand=0, fill=1) gtklogger.connect(inbutton, 'clicked', self.dollyin) outbutton = gtk.Button('Dolly Out') self.tooltips.set_tip(outbutton, "Translate camera away from focal point by given factor") dollyrow.pack_start(outbutton, expand=0, fill=1) gtklogger.connect(outbutton, 'clicked', self.dollyout) fillbutton = gtk.Button('Fill') self.tooltips.set_tip(fillbutton, "Set camera position such that microstructure approximately fills viewport") dollyrow.pack_start(fillbutton, expand=0, fill=1) gtklogger.connect(fillbutton, 'clicked', self.dollyfill) factorrow = gtk.HBox() transbox.pack_start(factorrow, expand=0, fill=0, padding=2) factorrow.pack_start(gtk.Label("Factor: "), expand=0, fill=0) self.dollyfactor = gtk.Entry() self.dollyfactor.set_editable(1) self.dollyfactor.set_size_request(80, -1) self.dollyfactor.set_text("1.5") self.tooltips.set_tip(self.dollyfactor, "Factor by which to multiply distance from camera to focal point") factorrow.pack_start(self.dollyfactor, expand=1, fill=1) # track trackrow = gtk.HBox(homogeneous=1, spacing=2) transbox.pack_start(trackrow, expand=0, fill=1, padding=2) horizbutton = gtk.Button('Horizontal') self.tooltips.set_tip(horizbutton,"Shift camera and focal point horizontally") trackrow.pack_start(horizbutton, expand=0, fill=1) gtklogger.connect(horizbutton, 'clicked', self.trackh) vertbutton = gtk.Button('Vertical') self.tooltips.set_tip(vertbutton, "Shift camera and focal point vertically") trackrow.pack_start(vertbutton, expand=0, fill=1) gtklogger.connect(vertbutton, 'clicked', self.trackv) recenterbutton = gtk.Button('Recenter') self.tooltips.set_tip(recenterbutton, "Recenter the microstructure in the viewport") trackrow.pack_start(recenterbutton, expand=0, fill=1) gtklogger.connect(recenterbutton, 'clicked', self.recenter) distrow = gtk.HBox() transbox.pack_start(distrow, expand=0, fill=0, padding=2) distrow.pack_start(gtk.Label("Distance: "), expand=0, fill=0) self.trackdist = gtk.Entry() self.trackdist.set_editable(1) self.trackdist.set_size_request(80, -1) self.trackdist.set_text("10.0") self.tooltips.set_tip(self.trackdist, "Distance by which to track camera in units of pixels") distrow.pack_start(self.trackdist, expand=1, fill=1) label = gtk.Label("Dolly: Right Mouse Button\nTrack: Middle Mouse Button") transbox.pack_start(label) #rotate rotateframe = gtk.Frame("Rotation") rotateframe.set_shadow_type(gtk.SHADOW_IN) viewerbox.pack_start(rotateframe, fill=0, expand=0) rotatebox = gtk.VBox() rotateframe.add(rotatebox) rotobjrow = gtk.HBox(homogeneous=1, spacing=2) rotatebox.pack_start(rotobjrow, expand=0, fill=1, padding=2) rollbutton = gtk.Button('Roll') self.tooltips.set_tip(rollbutton,"Rotate about direction of projection") rotobjrow.pack_start(rollbutton, expand=0, fill=1) gtklogger.connect(rollbutton, 'clicked', self.roll) azbutton = gtk.Button('Azimuth') self.tooltips.set_tip(azbutton, "Rotate about view up vector centered at focal point") rotobjrow.pack_start(azbutton, expand=0, fill=1) gtklogger.connect(azbutton, 'clicked', self.azimuth) elbutton = gtk.Button('Elevation') self.tooltips.set_tip(elbutton, "Rotate about cross product of direction of projection and view up vector centered at focal point") rotobjrow.pack_start(elbutton, expand=0, fill=1) gtklogger.connect(elbutton, 'clicked', self.elevation) rotcamrow = gtk.HBox(homogeneous=1, spacing=2) rotatebox.pack_start(rotcamrow, expand=0, fill=1, padding=2) yawbutton = gtk.Button('Yaw') self.tooltips.set_tip(yawbutton,"Rotate about view up vector centered at camera position") rotcamrow.pack_start(yawbutton, expand=0, fill=1) gtklogger.connect(yawbutton, 'clicked', self.yaw) pitchbutton = gtk.Button('Pitch') self.tooltips.set_tip(pitchbutton,"Rotate about cross product of direction of projection and view up vector centered at camera position") rotcamrow.pack_start(pitchbutton, expand=0, fill=1) gtklogger.connect(pitchbutton, 'clicked', self.pitch) anglerow = gtk.HBox() rotatebox.pack_start(anglerow, expand=0, fill=0, padding=2) anglerow.pack_start(gtk.Label("Angle: "), expand=0, fill=0) self.angle = gtk.Entry() self.angle.set_editable(1) self.angle.set_size_request(80, -1) self.angle.set_text("10.0") self.tooltips.set_tip(self.angle,"Angle in degrees by which to rotate by") anglerow.pack_start(self.angle, expand=1, fill=1) #clipping planes clippingframe = gtk.Frame("Clipping Range") clippingframe.set_shadow_type(gtk.SHADOW_IN) viewerbox.pack_start(clippingframe, fill=0, expand=0) clippingbox = gtk.VBox() clippingframe.add(clippingbox) self.clippingadj = gtk.Adjustment(value=100, lower=0, upper=100, step_incr=-1, page_incr=-5, page_size=0) gtklogger.connect(self.clippingadj, 'value_changed', self.setclipping) clippingscale = gtk.HScale(self.clippingadj) clippingscale.set_update_policy(gtk.UPDATE_DELAYED) self.tooltips.set_tip(clippingscale,"Adjust the near clipping plane to view cross section") clippingbox.pack_start(clippingscale) #opacity opacityframe = gtk.Frame("Opacity") opacityframe.set_shadow_type(gtk.SHADOW_IN) viewerbox.pack_start(opacityframe, fill=0, expand=0) opacitybox = gtk.VBox() opacityframe.add(opacitybox) self.opacityadj = gtk.Adjustment(value=100, lower=0, upper=100, step_incr=-1, page_incr=-5, page_size=0) gtklogger.connect(self.opacityadj, 'value_changed', self.setopacity) opacityscale = gtk.HScale(self.opacityadj) opacityscale.set_update_policy(gtk.UPDATE_DELAYED) self.tooltips.set_tip(opacityscale,"Adjust the opacity of the microstructure") opacitybox.pack_start(opacityscale) # save and restore saverestoreframe = gtk.Frame("Save and Restore Views") saverestoreframe.set_shadow_type(gtk.SHADOW_IN) viewerbox.pack_start(saverestoreframe, fill=0, expand=0) saverestorebox = gtk.VBox() saverestoreframe.add(saverestorebox) viewtable = gtk.Table(columns=2, rows=2) saverestorebox.pack_start(viewtable, fill=0, expand=0) saveviewbutton = gtk.Button("Save View:") self.tooltips.set_tip(saveviewbutton,"Save the current view settings") gtklogger.connect(saveviewbutton, 'clicked', self.saveview) viewtable.attach(saveviewbutton, 0,1,0,1) self.viewname = gtk.Entry() self.viewname.set_editable(1) self.viewname.set_size_request(80,-1) self.tooltips.set_tip(self.viewname,"Enter a name for the current view") viewtable.attach(self.viewname,1,2,0,1) setviewlabel = gtk.Label("Set View:") viewtable.attach(setviewlabel, 0,1,1,2) liststore = gtk.ListStore(gobject.TYPE_STRING) self.viewmenu = gtk.ComboBox(liststore) cell = gtk.CellRendererText() self.viewmenu.pack_start(cell, True) self.viewmenu.add_attribute(cell, 'text', 0) #self.tooltips.set_tip(self.viewmenu,"Restore a saved view") # menu items filled in later when saved_views is initialized self.signal = gtklogger.connect(self.viewmenu, 'changed', self.setview) viewtable.attach(self.viewmenu, 1,2,1,2) # end viewer widgets # voxel info widgets voxelinfoframe = gtk.Frame("Voxel Info Widgets") voxelinfoframe.set_shadow_type(gtk.SHADOW_IN) self.mainbox.pack_start(voxelinfoframe) voxelinfobox = gtk.VBox() voxelinfoframe.add(voxelinfobox) voxelinfotable = gtk.Table(rows=7,columns=2) voxelinfobox.pack_start(voxelinfotable) label = gtk.Label('x=') label.set_alignment(1.0, 0.5) voxelinfotable.attach(label, 0,1, 0,1, xpadding=5, xoptions=gtk.FILL) self.xtext = gtk.Entry() self.xtext.set_size_request(80, -1) voxelinfotable.attach(self.xtext, 1,2, 0,1, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) label = gtk.Label('y=') label.set_alignment(1.0, 0.5) voxelinfotable.attach(label, 0,1, 1,2, xpadding=5, xoptions=gtk.FILL) self.ytext = gtk.Entry() self.ytext.set_size_request(80, -1) voxelinfotable.attach(self.ytext, 1,2, 1,2, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) label = gtk.Label('z=') label.set_alignment(1.0, 0.5) voxelinfotable.attach(label, 0,1, 2,3, xpadding=5, xoptions=gtk.FILL) self.ztext = gtk.Entry() self.ztext.set_size_request(80, -1) voxelinfotable.attach(self.ztext, 1,2, 2,3, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) self.xtsignal = gtklogger.connect(self.xtext, 'changed', self.voxinfoChanged) self.ytsignal = gtklogger.connect(self.ytext, 'changed', self.voxinfoChanged) self.ztsignal = gtklogger.connect(self.ztext, 'changed', self.voxinfoChanged) box = gtk.HBox(homogeneous=True, spacing=2) self.updatebutton = gtk.Button(gtk.STOCK_REFRESH) #gtkutils.stockButton(gtk.STOCK_REFRESH, 'Update') box.pack_start(self.updatebutton, expand=1, fill=1) gtklogger.connect(self.updatebutton, 'clicked', self.updateVoxButtonCB) self.clearbutton = gtk.Button(gtk.STOCK_CLEAR) #gtkutils.stockButton(gtk.STOCK_CLEAR, 'Clear') box.pack_start(self.clearbutton, expand=1, fill=1) gtklogger.setWidgetName(self.clearbutton, "Clear") gtklogger.connect(self.clearbutton, 'clicked', self.clearVoxButtonCB) voxelinfotable.attach(box, 0,2,3,4, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL, yoptions=0) label = gtk.Label('red=') label.set_alignment(1.0, 0.5) voxelinfotable.attach(label, 0,1, 4,5, xpadding=5, xoptions=gtk.FILL) self.redtext = gtk.Entry() self.redtext.set_size_request(80, -1) voxelinfotable.attach(self.redtext, 1,2, 4,5, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) label = gtk.Label('green=') label.set_alignment(1.0, 0.5) voxelinfotable.attach(label, 0,1, 5,6, xpadding=5, xoptions=gtk.FILL) self.greentext = gtk.Entry() self.greentext.set_size_request(80, -1) voxelinfotable.attach(self.greentext, 1,2, 5,6, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) label = gtk.Label('blue=') label.set_alignment(1.0, 0.5) voxelinfotable.attach(label, 0,1, 6,7, xpadding=5, xoptions=gtk.FILL) self.bluetext = gtk.Entry() self.bluetext.set_size_request(80, -1) voxelinfotable.attach(self.bluetext, 1,2, 6,7, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) currentVoxel = None # voxel select widgets ## voxelselectframe = gtk.Frame("Voxel Select Widgets") ## voxelselectframe.set_shadow_type(gtk.SHADOW_IN) ## self.mainbox.pack_start(voxelselectframe) ## voxelselectbox = gtk.VBox() ## voxelselectframe.add(voxelselectbox) ## button = gtk.Button("Hello World") ## voxelselectbox.pack_start(button) self.saveimage = gtk.Button("save image") gtklogger.connect(self.saveimage, 'clicked', self.saveimageCB) self.mainbox.pack_start(self.saveimage)