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)
