def init_combo(self):
self.combobox = gtk.combo_box_new_text()
cb = gtk.combo_box_new_text()
self.layout.put(self.combobox, 5, 295)
for item in self.notreverseble_encryptions + self.reverseble_encryptions:
self.combobox.append_text(item)
self.combobox.show()
def _createCalendarPanel(self, sources):
"""
Creates one side in the notebook - the one for setting up calendar synchronization
"""
box = gtk.VBox(False, 5)
label = gtk.Label("Source A")
label.set_alignment(0, 0)
box.pack_start(label, False, False, 0)
label.show()
self.calendar_combobox1 = gtk.combo_box_new_text()
for sourceDesc in sources:
self.calendar_combobox1.append_text(sourceDesc)
self.calendar_combobox1.set_active(0)
box.pack_start(self.calendar_combobox1, False, False, 0)
self.calendar_combobox1.show()
label = gtk.Label("Source B")
label.set_alignment(0, 0)
box.pack_start(label, False, False, 0)
label.show()
self.calendar_combobox2 = gtk.combo_box_new_text()
for sourceDesc in sources:
self.calendar_combobox2.append_text(sourceDesc)
self.calendar_combobox2.set_active(1)
box.pack_start(self.calendar_combobox2, False, False, 0)
self.calendar_combobox2.show()
box.show()
return box
def __init__(self, current):
PreferencesTab.__init__(self, u'Selecciona los servicios que deseas \
usar para cortar URLs y subir imágenes a Twitter', current)
i = 0
default = -1
url_lbl = gtk.Label('Cortar URL')
self.shorten = gtk.combo_box_new_text()
for key,v in URL_SERVICES.iteritems():
self.shorten.append_text(key)
if key == self.current['shorten-url']: default = i
i += 1
self.shorten.set_active(default)
url_box = gtk.HBox(False)
url_box.pack_start(url_lbl, False, False, 3)
url_box.pack_start(self.shorten, False, False, 3)
pic_lbl = gtk.Label(u'Subir imágenes')
self.upload = gtk.combo_box_new_text()
i = 0
for key in PHOTO_SERVICES:
self.upload.append_text(key)
if key == self.current['upload-pic']: default = i
i += 1
self.upload.set_active(default)
pic_box = gtk.HBox(False)
pic_box.pack_start(pic_lbl, False, False, 3)
pic_box.pack_start(self.upload, False, False, 3)
self.pack_start(url_box, False, False, 2)
self.pack_start(pic_box, False, False, 2)
self.show_all()
def initComponents(self, wTree):
self.banksWindow = wTree.get_object('banksWindow')
if (self.banksWindow):
self.banksWindow.connect('destroy', self.closeWindow)
# Set favicon and logo
pixbuf = gtk.gdk.pixbuf_new_from_file('assets/logo.svg')
pixbuf = pixbuf.scale_simple(16, 16, gtk.gdk.INTERP_BILINEAR)
self.banksWindow.set_icon(pixbuf)
self.saveButton = wTree.get_object('buttonSaveDefault')
if (self.saveButton):
self.saveButton.connect('clicked', self.saveDefault)
self.startButton = wTree.get_object('buttonStart')
if (self.startButton):
self.startButton.connect('clicked', self.startServer)
vbox2 = wTree.get_object('vbox2')
self.comboBox1 = gtk.combo_box_new_text()
self.comboBox2 = gtk.combo_box_new_text()
comboBoxes = [self.comboBox1, self.comboBox2]
vbox2.get_children()[0].add(self.comboBox1)
vbox2.get_children()[1].add(self.comboBox2)
# Fill the boxes accordingly to the existing presets.
for box in comboBoxes:
box.append_text("0 - None")
for p in self.presetsList[1:]:
box.append_text(str(self.presetsList.index(p))
+ " - " + p.get_small_str())
box.set_active(0)
# Sets a defaultly selected bank.
if self.banksList != []:
bank.set_all(self.banksList)
listlen = len(self.presetsList)
index = 1
for preset in self.presetsList[1:]:
if self.banksList[0].get_preset(0) != None \
and preset.name == self.banksList[0].get_preset(0).name:
break
index += 1
if index >= listlen:
index = 0
self.comboBox1.set_active(index)
index = 1
for preset in self.presetsList[1:]:
if self.banksList[0].get_preset(1) != None \
and preset.name == self.banksList[0].get_preset(1).name:
break
index += 1
if index >= listlen:
print "Not able to find preset in bank. None set as default."
index = 0
self.comboBox2.set_active(index)
self.comboBox1.connect('changed', self.storePreset1)
self.comboBox2.connect('changed', self.storePreset2)
def __init__(self, geditwindow, path, active):
gtk.VBox.__init__(self)
if active:
targets=["html","html-single","pdf","test", "all"]
langs = ["en-US","as-IN", "bn-IN", "de-DE", "es-ES", "fr-FR", "gu-IN", "hi-IN", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "or-IN", "pa-IN", "pt-BR", "ru-RU", "si-LK", "ta-IN", "te-IN", "zh-CN", "zh-TW"]
#self.output_text = gtk.TextBuffer()
#self.output_area = gtk.TextView(self.output_text)
#self.output_area.set_editable(False)
#self.output_area.modify_font(pango.FontDescription("Monospace 10"))
self.terminal = vte.Terminal()
self.terminal.fork_command(directory=path)
#terminal.connect("show", show_callback)
scrolled_window = gtk.ScrolledWindow()
#scrolled_window.add(self.output_area)
scrolled_window.add(self.terminal)
self.pack_start(scrolled_window)
buttonbox = gtk.HButtonBox()
buttonbox.set_layout(gtk.BUTTONBOX_END)
targets_combo = gtk.combo_box_new_text()
for t in targets:
targets_combo.append_text(t)
targets_combo.set_active(0)
buttonbox.pack_start(targets_combo, False, False, 1)
lang_combo = gtk.combo_box_new_text()
for l in langs:
lang_combo.append_text(l)
lang_combo.set_active(0)
buttonbox.pack_start(lang_combo, False, False, 1)
okbutton = gtk.Button("Build", None, False)
buttonbox.pack_start(okbutton, False, False, 3)
self.pack_start(buttonbox, False, False, 3)
self.show_all()
okbutton.connect("clicked", self.build, path, targets_combo, lang_combo)
def add_query_widget(container, field_names, sel_qf='title', sel_comm='contains', text=''):
hbox = gtk.HBox()
cb = gtk.combo_box_new_text()
select = 0
for i, field in enumerate(QUERY_FIELDS):
if sel_qf == field:
select = i
cb.append_text(field_names[field])
cb.set_active(select)
action_cb = gtk.combo_box_new_text()
select = 0
for i, command in enumerate(QUERY_COMMANDS):
if sel_comm == command:
select = i
action_cb.append_text(QUERY_COMMAND_NAMES[command])
action_cb.set_active(select)
entry = gtk.Entry()
entry.set_text(text)
button = gtk.Button(stock=gtk.STOCK_DELETE)
button.connect("clicked", lambda w: hbox.destroy())
hbox.pack_start(cb, expand=False)
hbox.pack_start(action_cb, expand=False)
hbox.pack_start(entry, expand=True, padding=8)
hbox.pack_start(button, expand=False, fill=False)
hbox.show_all()
container.pack_start(hbox)
def _create_dialog(self, config):
enabled, curhz = config.get_sound()
self.enabled = gtk.CheckButton("Sound enabled")
self.enabled.set_active(enabled)
hz = gtk.combo_box_new_text()
for text in config.get_sound_values():
hz.append_text(text)
hz.set_active(curhz)
self.hz = hz
ymmixer = gtk.combo_box_new_text()
for text in config.get_ymmixer_types():
ymmixer.append_text(text)
ymmixer.set_active(config.get_ymmixer())
self.ymmixer = ymmixer
self.mic = gtk.CheckButton("Enable (Falcon) microphone")
self.mic.set_active(config.get_mic())
dialog = gtk.Dialog("Sound settings", self.parent,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_APPLY, gtk.RESPONSE_APPLY,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
dialog.vbox.add(self.enabled)
dialog.vbox.add(gtk.Label("Sound frequency::"))
dialog.vbox.add(hz)
dialog.vbox.add(gtk.Label("YM voices mixing method:"))
dialog.vbox.add(ymmixer)
dialog.vbox.add(self.mic)
dialog.vbox.show_all()
self.dialog = dialog
def construct_window(self):
self.window = gtk.Window()
self.window.set_title("Feed Reader")
self.window.resize(1000, 700)
self.edit_add_feader = gtk.Entry()
self.button_add = gtk.Button("Add")
self.button_refresh = gtk.Button(stock = gtk.STOCK_REFRESH)
self.combo_feaders = gtk.combo_box_new_text()
self.combo_feeds = gtk.combo_box_new_text()
self.webview = webkit.WebView()
hbox = gtk.HBox()
hbox.pack_start(self.edit_add_feader)
hbox.pack_start(self.button_add)
hbox.pack_start(self.button_refresh)
scrollframe = gtk.ScrolledWindow()
scrollframe.add(self.webview)
# solution for now:
# textview = gtk.TextView()
# self.buffer = textview.get_buffer()
# scrollframe.add(textview)
# -----------------
vbox = gtk.VBox()
vbox.pack_start(hbox, False)
vbox.pack_start(self.combo_feaders, False)
vbox.pack_start(self.combo_feeds, False)
vbox.pack_start(scrollframe)
self.window.add(vbox)
def populate_settings_widgets(self):
self.theme_selector = gtk.combo_box_new_text()
for theme in sorted(resources.get_themes()):
self.theme_selector.append_text(theme)
self.ui.get_object("theme_container").pack_start(self.theme_selector, True, True)
self.theme_selector.set_active_iter(
dict([(x[0].strip(), x.iter) for x in self.theme_selector.get_model()]).get(
self.settings["theme"], self.theme_selector.get_model().get_iter_root()
)
)
self.theme_selector.show_all()
self.urlshorter_selector = gtk.combo_box_new_text()
for urlshorter in urlshorters.keys():
self.urlshorter_selector.append_text(urlshorter)
self.ui.get_object("urlshorter_container").pack_start(self.urlshorter_selector, True, True)
self.urlshorter_selector.set_active_iter(
dict([(x[0].strip(), x.iter) for x in self.urlshorter_selector.get_model()]).get(
self.settings["urlshorter"], self.urlshorter_selector.get_model().get_iter_root()
)
)
self.urlshorter_selector.show_all()
self.retweet_style_selector = gtk.combo_box_new_text()
for format in RETWEET_FORMATS:
self.retweet_style_selector.append_text(format)
self.ui.get_object("retweet_style_container").pack_start(self.retweet_style_selector, True, True)
self.retweet_style_selector.set_active_iter(
dict([(x[0].strip(), x.iter) for x in self.retweet_style_selector.get_model()]).get(
self.settings["retweet_style"], self.retweet_style_selector.get_model().get_iter_root()
)
)
self.retweet_style_selector.show_all()
def __init__(self, master):
gtk.Frame.__init__(self)
self.master = master
self.set_border_width(20)
vb = gtk.VBox(spacing = 10)
hb = gtk.HBox(spacing=5)
hb.set_border_width(5)
vb.pack_start(hb, False)
self.drive = gtk.combo_box_new_text()
hb.pack_end(self.drive, False)
hb.pack_end(gtk.Label(_("Boot Device: ")), False)
for d in install.listDevices():
self.drive.append_text(d[0])
self.drive.set_active(0)
mlcombobox = gtk.HBox(spacing=5)
mlcombobox.set_border_width(5)
l = gtk.Label(_("Select menu.lst to import: "))
mlcombobox.pack_start(l, False)
self.mlcombo = gtk.combo_box_new_text()
self.mlcombo.connect("changed", mainWindow.sigprocess, self.newimport)
self.mlcombo.append_text(_("None"))
for d, p in install.menulst:
self.mlcombo.append_text("%s:%s" % (d, p))
mlcombobox.pack_start(self.mlcombo, False)
eb = gtk.Button(_("Edit menu.lst"))
eb.connect("clicked", self.editmbr)
mlcombobox.pack_end(eb, False)
vb.pack_start(mlcombobox, False)
self.add(vb)
self.show_all()
def __init__(self, current):
PreferencesTab.__init__(self, _('Select your preferred services for \
shorten URLs and upload images'), current)
i = 0
default = -1
url_lbl = gtk.Label(_('Shorten URL'))
self.shorten = gtk.combo_box_new_text()
for key, v in URL_SERVICES.iteritems():
self.shorten.append_text(key)
if key == self.current['shorten-url']:
default = i
i += 1
self.shorten.set_active(default)
url_box = gtk.HBox(False)
url_box.pack_start(url_lbl, False, False, 3)
url_box.pack_start(self.shorten, False, False, 3)
pic_lbl = gtk.Label(_('Upload images'))
self.upload = gtk.combo_box_new_text()
i = 0
for key in PHOTO_SERVICES:
self.upload.append_text(key)
if key == self.current['upload-pic']:
default = i
i += 1
self.upload.set_active(default)
pic_box = gtk.HBox(False)
pic_box.pack_start(pic_lbl, False, False, 3)
pic_box.pack_start(self.upload, False, False, 3)
self.pack_start(url_box, False, False, 2)
self.pack_start(pic_box, False, False, 2)
self.show_all()
def init_text_view(self):
#self.notebook = gtk.Notebook()
view = gtk.TextView()
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.text_view = view
self.text_view.set_left_margin(8)
self.text_view.set_right_margin(8)
self.text_view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
sw.add(view)
#self.font_label = gtk.Label(_("Preview"))
self.style_combo = gtk.combo_box_new_text()
self.size_combo = gtk.combo_box_new_text()
vb = gtk.VBox()
hb = gtk.HBox()
vb.pack_start(hb, False)
vb.pack_start(sw)
#hb.pack_start(self.font_label, False)
hb.pack_end(self.style_combo, False)
hb.pack_end(self.size_combo, False)
self.set_scalable_sizes()
self.style_combo.connect("changed", self.style_changed)
self.size_combo.connect("changed", self.size_changed)
return vb
def __init__(self, selection, _log):
self.clipboard = gtk.Clipboard(selection=selection)
self.selection = selection
self._log = _log
self.owned_label = label()
self.get_targets = gtk.combo_box_new_text()
self.get_targets.set_sensitive(False)
self.get_targets.connect("changed", self.get_target_changed)
self.set_targets = gtk.combo_box_new_text()
self.set_targets.append_text("STRING")
self.set_targets.append_text("UTF8_STRING")
self.set_targets.set_active(0)
self.set_targets.connect("changed", self.set_target_changed)
self.value_label = label()
self.value_entry = gtk.Entry(max=100)
self.value_entry.set_width_chars(32)
self.clear_label_btn = gtk.Button("X")
self.clear_label_btn.connect("clicked", self.clear_label)
self.clear_entry_btn = gtk.Button("X")
self.clear_entry_btn.connect("clicked", self.clear_entry)
self.get_get_targets_btn = gtk.Button("Get Targets")
self.get_get_targets_btn.connect("clicked", self.do_get_targets)
self.get_target_btn = gtk.Button("Get Target")
self.get_target_btn.connect("clicked", self.do_get_target)
self.get_target_btn.set_sensitive(False)
self.set_target_btn = gtk.Button("Set Target")
self.set_target_btn.connect("clicked", self.do_set_target)
self.get_string_btn = gtk.Button("Get String")
self.get_string_btn.connect("clicked", self.do_get_string)
self.set_string_btn = gtk.Button("Set String")
self.set_string_btn.connect("clicked", self.do_set_string)
self.clipboard.connect("owner-change", self.owner_changed)
self.log("ready")
def createInfo(self, line):
# Turns a line into a gtk hbox of parameters
hbox = gtk.HBox()
entry = gtk.Entry()
entry.set_text(line.get_label())
hbox.pack_start(entry, expand=False, fill=False, padding=5)
label = gtk.Label("marker:")
hbox.pack_start(label, expand=False, fill=False)
combo = gtk.combo_box_new_text()
for i in PlotStyles.nmar:
combo.append_text(i)
combo.set_active(self.getMarkerIndex(line))
hbox.pack_start(combo, expand=False, fill=False, padding=5)
label = gtk.Label("linestyle:")
hbox.pack_start(label, expand=False, fill=False)
combo = gtk.combo_box_new_text()
for i in PlotStyles.nsty:
combo.append_text(i)
combo.set_active(self.getStyleIndex(line))
hbox.pack_start(combo, expand=False, fill=False, padding=5)
label = gtk.Label("colour:")
hbox.pack_start(label, expand=False, fill=False)
combo = gtk.combo_box_new_text()
for i in PlotStyles.colours:
combo.append_text(i)
combo.set_active(self.getColourIndex(line))
hbox.pack_start(combo, expand=False, fill=False, padding=5)
return hbox
def __init__(self):
self.box = gtk.HBox()
self.funz = gtk.Entry()
self.funz.set_tooltip_text("The function")
self.ab = gtk.combo_box_new_text()
self.ab.set_tooltip_text("Where the funtion should be")
self.preset = gtk.combo_box_new_text()
self.preset.set_tooltip_text("Arrow type")
self.inarc = gtk.SpinButton(digits = 0)
self.inarc.set_tooltip_text("Arrow curve, in degrees")
self.canc = gtk.Button("Delete")
self.canc.set_tooltip_text("Delete the arrow")
self.add = gtk.Button("Add arrow")
self.canc.set_tooltip_text("Add another arrow")
self.inarc.set_increments(5, 30)
self.inarc.set_range(-180, 180)
for x in SCRITTA:
self.ab.append_text(x)
for x in PRESET:
self.preset.append_text(x)
self.ab.set_active(0)
self.preset.set_active(0)
self.box.pack_start(self.funz, False, False)
self.box.pack_start(self.ab, False, False)
self.box.pack_start(self.preset, False, False)
self.box.pack_start(self.inarc, False, False)
self.box.pack_start(self.canc, False, False)
self.box.pack_start(self.add, False, False)
self.set()
def __init__(self):
gtk.Window.__init__(self)
self.set_border_width(10)
self.set_title("atop-plot")
self.grid = gtk.Table()
self.grid.set_col_spacings(5)
self.grid.set_row_spacings(5)
self.add(self.grid)
self.file_label = gtk.Label("File")
self.grid.attach(self.file_label, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
self.load_button = gtk.FileChooserButton("Select A File", None)
self.load_button.connect("file-set", self.file_selected)
self.grid.attach(self.load_button, 1, 2, 0, 1, gtk.FILL, gtk.FILL)
self.label_label = gtk.Label("Label")
self.grid.attach(self.label_label, 2, 3, 0, 1, gtk.FILL, gtk.FILL)
self.label_combo = gtk.combo_box_new_text()
self.label_combo.set_sensitive(False)
self.label_combo.connect("changed", self.on_label_combo_changed)
self.grid.attach(self.label_combo, 3, 4, 0, 1, gtk.FILL, gtk.FILL)
self.pid_label = gtk.Label("PID")
self.grid.attach(self.pid_label, 4, 5, 0, 1, gtk.FILL, gtk.FILL)
self.pid_combo = gtk.combo_box_new_text()
self.pid_combo.set_sensitive(False)
self.pid_combo.connect("changed", self.on_pid_combo_changed)
self.grid.attach(self.pid_combo, 5, 6, 0, 1, gtk.FILL, gtk.FILL)
def _create_dialog(self, config):
table, self.dialog = create_table_dialog(self.parent, "Hard disks", 4, 4, "Set and reboot")
factory = FselAndEjectFactory()
row = 0
label = "ASCI HD image:"
path = config.get_acsi_image()
fsel, box = factory.get(label, None, path, gtk.FILE_CHOOSER_ACTION_OPEN)
table_add_widget_row(table, row, label, box, True)
self.acsi = fsel
row += 1
label = "IDE HD master image:"
path = config.get_idemaster_image()
fsel, box = factory.get(label, None, path, gtk.FILE_CHOOSER_ACTION_OPEN)
table_add_widget_row(table, row, label, box, True)
self.idemaster = fsel
row += 1
label = "IDE HD slave image:"
path = config.get_ideslave_image()
fsel, box = factory.get(label, None, path, gtk.FILE_CHOOSER_ACTION_OPEN)
table_add_widget_row(table, row, label, box, True)
self.ideslave = fsel
row += 1
table_add_widget_row(table, row, " ", gtk.HSeparator(), True)
row += 1
label = "GEMDOS drive directory:"
path = config.get_hd_dir()
fsel, box = factory.get(label, None, path, gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
table_add_widget_row(table, row, label, box, True)
self.hddir = fsel
row += 1
hddrive = gtk.combo_box_new_text()
for text in config.get_hd_drives():
hddrive.append_text(text)
hddrive.set_tooltip_text("Whether GEMDOS HD emulation uses fixed drive letter, or first free drive letter after ASCI & IDE drives (detection unreliable)")
table_add_widget_row(table, row, "GEMDOS HD drive:", hddrive)
self.hddrive = hddrive
row += 1
protect = gtk.combo_box_new_text()
for text in config.get_protection_types():
protect.append_text(text)
protect.set_tooltip_text("Whether/how to write protect (GEMDOS HD) emulation files, 'auto' means using host files' own properties")
table_add_widget_row(table, row, "Write protection:", protect)
self.protect = protect
row += 1
lower = gtk.combo_box_new_text()
for text in config.get_hd_cases():
lower.append_text(text)
lower.set_tooltip_text("What to do with names of files created by Atari programs through GEMDOS HD emulation")
table_add_widget_row(table, row, "File names:", lower)
self.lower = lower
table.show_all()
def render(self):
label = gtk.Label(self.name)
label.show()
self.widget['label']=label
day = gtk.combo_box_new_text()
day.show()
day.append_text('')
for idx in range(1,32):
day.append_text(str(idx))
month_list = ['Januari','Februari','Maret','April','Mei','Juni','Juli','Agustus','September','Oktober','November','Desember']
month = gtk.combo_box_new_text()
month.show()
month.append_text('')
for item in month_list:
month.append_text(item)
year = gtk.combo_box_new_text()
year.show()
year.append_text('')
for idx in range(1900,2015):
year.append_text(str(idx))
self.widget['content'] = [day,month,year]
return self.widget
def _create_types_tab(self, tab):
tab.set_border_width(6)
tab.set_spacing(6)
text = _('Create model from widget')
self.create_from_widget_btn = gtk.RadioButton(None, text)
self.create_from_widget_btn.connect('toggled',
self._on_creation_type_toggled)
hbox = gtk.HBox()
hbox.set_spacing(6)
hbox.pack_start(self.create_from_widget_btn, False, False)
self.widget_combo = gtk.combo_box_new_text()
hbox.pack_start(self.widget_combo)
tab.pack_start(hbox, False, False)
self.custom_model_btn = gtk.RadioButton(self.create_from_widget_btn,
_('Custom model'))
self.custom_model_btn.connect('toggled',
self._on_creation_type_toggled)
tab.pack_start(self.custom_model_btn, False, False)
self.custom_model_align = gtk.Alignment(0, 0, 1, 1)
self.custom_model_align.set_padding(0, 0, 48, 0)
hbox = gtk.HBox()
hbox.set_spacing(6)
self.custom_model_store = gtk.ListStore(object, int, str)
self.custom_model_view = gtk.TreeView(self.custom_model_store)
renderer1 = gtk.CellRendererText()
renderer1.set_property('xalign', 1) # right alignment
col1 = gtk.TreeViewColumn(_('Index'), renderer1,
text=CUSTOM_MODEL_INDEX)
self.custom_model_view.append_column(col1)
renderer2 = gtk.CellRendererText()
col2 = gtk.TreeViewColumn(_('Type'), renderer2,
text=CUSTOM_MODEL_TYPE_NAME)
self.custom_model_view.append_column(col2)
scrolled_window = create_scrolled_window(self.custom_model_view,
hpolicy=gtk.POLICY_NEVER)
hbox.pack_start(scrolled_window, True, True)
table = gtk.Table(2, 2)
self.types_combo = gtk.combo_box_new_text()
for t in renderer_expert.get_type_names():
self.types_combo.append_text(t)
self.types_combo.set_active(0)
self.add_type_btn = create_image_only_button(gtk.STOCK_ADD)
self.del_type_btn = create_image_only_button(gtk.STOCK_REMOVE)
table.attach(self.types_combo, 0, 1, 0, 1, yoptions=0)
table.attach(self.add_type_btn, 1, 2, 0, 1, yoptions=0)
table.attach(self.del_type_btn, 1, 2, 1, 2, yoptions=0)
hbox.pack_start(table, False, False)
self.custom_model_align.add(hbox)
self.custom_model_align.set_sensitive(False)
tab.pack_start(self.custom_model_align, True, True)
def __init__(self):
self.mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.mainwindow.set_title("Tesseract Trainer")
self.mainwindow.connect("destroy", lambda w: gtk.main_quit())
self.mainwindow.set_icon_from_file("/usr/share/tesseract-gui/tesseract-gui-logo.png")
self.mainwindow.set_size_request(700, 200)
self.vboxtw = gtk.VBox(False, 1)
self.mainwindow.add(self.vboxtw)
self.vboxtw.show()
################
self.hboxlang = gtk.HBox(False, 3)
self.vboxtw.pack_start(self.hboxlang, True, True, 1)
self.hboxlang.show()
self.langlabel = gtk.Label("Language")
self.hboxlang.pack_start(self.langlabel, True, True, 1)
self.langlabel.show()
self.combolang = gtk.combo_box_new_text()
self.hboxlang.pack_start(self.combolang, True, True, 1)
langfile = open("lang_list.txt", "r")
flines = langfile.readlines()
langfile.close()
for line in flines:
lang = line.rsplit(":", 2)[0]
# print lang
self.combolang.append_text(lang)
self.combolang.show()
self.combolang.connect("changed", self.changed_combo_lang)
####################
self.hboxfont = gtk.HBox(False, 3)
self.vboxtw.pack_start(self.hboxfont, True, True, 1)
self.hboxfont.show()
self.fontlabel = gtk.Label("Font")
self.hboxfont.pack_start(self.fontlabel, True, True, 1)
self.fontlabel.show()
self.combofont = gtk.combo_box_new_text()
self.hboxfont.pack_start(self.combofont, True, True, 1)
self.combofont.show()
#####################
self.hboxstyle = gtk.HBox(False, 3)
self.vboxtw.pack_start(self.hboxstyle, True, True, 1)
self.hboxstyle.show()
self.stylelabel = gtk.Label("Style")
self.hboxstyle.pack_start(self.stylelabel, True, True, 1)
self.stylelabel.show()
self.combostyle = gtk.combo_box_new_text()
self.hboxstyle.pack_start(self.combostyle, True, True, 1)
self.combostyle.show()
self.mainwindow.show()
def _add_manual_combos(self):
# It is hell trying to work with Glade's combo boxes
# so I just added GTK ones manually. Sue me.
self.convertBox = gtk.combo_box_new_text()
self.processingTable.attach(self.convertBox, 5,9,1,2)
self.convertBox.connect("changed", self.cBox_cb)
self.qualityBox = gtk.combo_box_new_text()
self.processingTable.attach(self.qualityBox, 5,9,2,3)
def define_elements(self, form_data=None):
"""Declare all required elements - Config, Argument, Check elements."""
# Define data
self.data_types = ['i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64']
self.compare_types = ['I', 'G', 'E']
self.other_data_types = ['Futhur', 'Check']
# Define Argument elements
self.arg_elements = (
('a1', gtk.Label('Val name *'), gtk.Entry()),
('a2', gtk.Label('Abs address *'), gtk.Entry()),
('a3', gtk.Label('Data type *'), gtk.combo_box_new_text()),
('a4', gtk.Label('Check'), gtk.CheckButton()),
('a5', gtk.Label('Watch'), gtk.CheckButton()),
)
self.check_elements = (
('c1', gtk.Label('Check'), gtk.CheckButton()),
('c2', gtk.Label('Abs address *'), gtk.Entry()),
('c3', gtk.Label('Data type *'), gtk.combo_box_new_text()),
('c4', gtk.Label('*'), gtk.combo_box_new_text()),
('c5', gtk.Label('Check value'), gtk.CheckButton()),
('c6', gtk.Label('*'), gtk.combo_box_new_text()),
)
for i in self.data_types:
self.arg_elements[2][2].append_text(i)
self.check_elements[2][2].append_text(i)
for i in self.compare_types:
self.check_elements[3][2].append_text(i)
for i in self.other_data_types:
self.check_elements[5][2].append_text(i)
if form_data:
self.arg_elements[0][2].set_text(form_data[0])
self.arg_elements[1][2].set_text(form_data[1])
if form_data[2] != None:
self.arg_elements[2][2].set_active(self.data_types.index(form_data[2]))
if form_data[3] == 'True':
self.arg_elements[3][2].set_active(1)
if form_data[4] == 'True':
self.arg_elements[4][2].set_active(1)
if form_data[5] == 'True':
self.check_elements[0][2].set_active(1);
self.check_elements[1][2].set_text(form_data[6])
if form_data[7] != None:
self.check_elements[2][2].set_active(self.data_types.index(form_data[7]))
if form_data[8] != None:
self.check_elements[3][2].set_active(self.compare_types.index(form_data[8]))
if form_data[9] == 'True':
self.check_elements[4][2].set_active(1)
if form_data[10] != None:
self.check_elements[5][2].set_active(self.other_data_types.index(form_data[10]))
def test_update_node_combo(self): nodeList=["N1","N2","N3"] combobox = gtk.combo_box_new_text() self.ed._update_node_combo(combobox, nodeList, "N3") assert combobox.get_active() == 2 self.ed.nodeList=[] combobox = gtk.combo_box_new_text() self.ed._update_node_combo(combobox, nodeList, "XXX") assert combobox.get_active() == -1
def __init__(self, image):
vbox = gtk.VBox()
# want 5 small labels, 1 larger label and a sub-frame
dimlabel = gtk.Label("Dimensions: "+self.getdims(image))
dtypelabel = gtk.Label("Datatype: "+image[:].dtype.name)
scalelabel = gtk.Label("Intensity: %1.8f X"%image.scaling)
voxlabel = gtk.Label("Vox size: "+self.getvox(image))
originlabel = gtk.Label("Origin: "+self.getorigin(image))
# make 4 lines worth of space for this label
xform = image.orientation_xform.tomatrix()
xformlabel = gtk.Label("Dir Cos: \n" + \
str(xform))
xformlabel.set_size_request(300,80)
buttons = gtk.Frame()
buttons.set_size_request(300,70)
buttons.set_shadow_type(gtk.SHADOW_ETCHED_IN)
frametable = gtk.Table(2,2)
frametable.set_row_spacings(5)
frametable.set_col_spacings(10)
self.imgframe = gtk.combo_box_new_text()
for size in ["Full Volume", "160x160x160mm", "80x80x80mm",
"40x40x40mm", "20x20x20mm", "10x10x10mm"]:
self.imgframe.append_text(size)
self.imgframe.set_active(0)
self.imspace = gtk.combo_box_new_text()
for space in ["World Space", "Voxel Space"]:
self.imspace.append_text(space)
self.imspace.set_active(0)
self.imginterp = gtk.combo_box_new_text()
for interp in interp_types:
self.imginterp.append_text(interp)
self.imginterp.set_active(1)
self.hidecrosshairs = gtk.ToggleButton(label="Hide Crosshairs")
frametable.attach(self.imgframe, 0, 1, 0, 1)
frametable.attach(self.imspace, 0, 1, 1, 2)
frametable.attach(self.imginterp, 1, 2, 0, 1)
frametable.attach(self.hidecrosshairs, 1, 2, 1, 2)
buttons.add(frametable)
vbox.pack_start(dimlabel)
vbox.pack_start(dtypelabel)
vbox.pack_start(scalelabel)
vbox.pack_start(voxlabel)
vbox.pack_start(originlabel)
vbox.pack_start(xformlabel)
vbox.pack_start(buttons)
gtk.Frame.__init__(self)
self.set_border_width(5)
self.add(vbox)
def construct(self):
vbox = gtk.VBox()
entry = gtk.Entry()
#entry.set_text(UML.format(self.subject, visibility=True, is_derived=Truemultiplicity=True) or '')
# monitor subject attribute (all, cause it contains many children)
changed_id = entry.connect('changed', self._on_end_name_change)
def handler(event):
if not entry.props.has_focus:
entry.handler_block(changed_id)
entry.set_text(UML.format(self.subject,
visibility=True, is_derived=True,
multiplicity=True) or '')
#entry.set_text(UML.format(self.subject, multiplicity=True) or '')
entry.handler_unblock(changed_id)
handler(None)
self.watcher.watch('name', handler) \
.watch('aggregation', handler)\
.watch('visibility', handler)\
.watch('lowerValue<LiteralSpecification>.value', handler)\
.watch('upperValue<LiteralSpecification>.value', handler)\
.register_handlers()
entry.connect("destroy", self.watcher.unregister_handlers)
vbox.pack_start(entry)
entry.set_tooltip_text("""\
Enter attribute name and multiplicity, for example
- name
+ name [1]
- name [1..2]
~ 1..2
- [1..2]\
""")
combo = gtk.combo_box_new_text()
for t in ('Unknown navigation', 'Not navigable', 'Navigable'):
combo.append_text(t)
nav = self.subject.navigability
combo.set_active(self.NAVIGABILITY.index(nav))
combo.connect('changed', self._on_navigability_change)
vbox.pack_start(combo, expand=False)
combo = gtk.combo_box_new_text()
for t in ('No aggregation', 'Shared', 'Composite'):
combo.append_text(t)
combo.set_active(['none', 'shared', 'composite'].index(self.subject.aggregation))
combo.connect('changed', self._on_aggregation_change)
vbox.pack_start(combo, expand=False)
return vbox
def init_settings(self):
#ustawienia startowe oraz defincjie niektórych widgetów
self.dev_dvd = self.obj['dev_dvd']
#layer_break
adj = gtk.Adjustment(lower=0, upper=99999999, step_incr=1, page_incr=10, page_size=10)
self.layer_break = gtk.SpinButton()
self.obj['table1'].attach(self.layer_break, left_attach=1, right_attach=2, top_attach=1, bottom_attach=2)
self.layer_break.set_adjustment(adj)
self.layer_break.show()
#layer_break XGD3 bez LT-MAX
adj = gtk.Adjustment(lower=0, upper=99999999, step_incr=1, page_incr=10, page_size=10)
self.xgd3_layer_break = gtk.SpinButton()
self.obj['table1'].attach(self.xgd3_layer_break, left_attach=1, right_attach=2, top_attach=2, bottom_attach=3)
self.xgd3_layer_break.set_adjustment(adj)
self.xgd3_layer_break.show()
#layer_break XGD3 z LT-MAX
adj = gtk.Adjustment(lower=0, upper=99999999, step_incr=1, page_incr=10, page_size=10)
self.xgd3_layer_break_lt_max = gtk.SpinButton()
self.obj['table1'].attach(self.xgd3_layer_break_lt_max, left_attach=1, right_attach=2, top_attach=3, bottom_attach=4)
self.xgd3_layer_break_lt_max.set_adjustment(adj)
self.xgd3_layer_break_lt_max.show()
#rozmiar dla truncate dla XGD3 bez LT-MAX - przycięcie obrazu przed nagrywaniem
adj = gtk.Adjustment(lower=0, upper=9999999999, step_incr=1, page_incr=10, page_size=10)
self.truncate_size = gtk.SpinButton()
self.obj['table1'].attach(self.truncate_size, left_attach=1, right_attach=2, top_attach=4, bottom_attach=5)
self.truncate_size.set_adjustment(adj)
self.truncate_size.show()
#prędkość nagrywania
self.burn_speeds = ['x1', 'x2', 'x4', 'x8']
self._burn_speeds = ['1', '2', '4', '8']
self.burn_speed = gtk.combo_box_new_text()
self.burn_speed.show()
self.obj['table1'].attach(self.burn_speed, left_attach=1, right_attach=2, top_attach=5, bottom_attach=6)
for ele in self.burn_speeds:
self.burn_speed.append_text(ele)
#bufor dla growisofs
adj = gtk.Adjustment(lower=0, upper=9999, step_incr=1, page_incr=10, page_size=10)
self.buffer = gtk.SpinButton()
self.obj['table1'].attach(self.buffer, left_attach=1, right_attach=2, top_attach=6, bottom_attach=7)
self.buffer.set_adjustment(adj)
self.buffer.show()
#terminal
self.terminals = ['xterm', 'gnome-terminal', 'terminator']
self.terminal = gtk.combo_box_new_text()
self.terminal.show()
self.obj['table1'].attach(self.terminal, left_attach=1, right_attach=2, top_attach=7, bottom_attach=8)
for ele in self.terminals:
self.terminal.append_text(ele)
def __init__(self):
super(MainWindow, self).__init__()
self.checked = False
self.connect("destroy", self.do_exit)
self.set_size_request(400, 150)
self.set_position(gtk.WIN_POS_CENTER)
self.set_title('MangaFox Grabber')
try:
self.set_icon_from_file('logo.png')
except:
pass
halign = {}
vbox = gtk.VBox(False, 2)
hbox = {}
self.progress = gtk.ProgressBar()
self.progress.set_text("Press Check, when ready.")
self.button = gtk.Button('Check')
self.button.connect('clicked', self.on_continue)
self.help = gtk.Button('How to use this application?')
self.help.connect('clicked', self.on_help)
self.entry = gtk.Entry()
self.entrylabel = gtk.Label('Manga')
self.threads = gtk.combo_box_new_text()
for sel in ['5 threads(slowest, most stable)',
'10 threads(recommended)',
'20 threads',
'50 threads (fastest, least stable)']:
self.threads.append_text(sel)
self.threads.set_active(1)
self.selection = gtk.combo_box_new_text()
for sel in ['A5 page size',
'A4 page size',
'A3 page size']:
self.selection.append_text(sel)
self.selection.set_active(0)
widgs = [[self.progress],
[self.threads],
[self.selection],
[self.entrylabel, self.entry],
[self.button, self.help], ]
for key, widgets in enumerate(widgs):
halign[key] = gtk.Alignment(1, 0, 1, 0)
hbox[key] = gtk.HBox(False, 2)
for widget in widgets:
hbox[key].add(widget)
halign[key].add(hbox[key])
vbox.pack_start(halign[key], False, False, 1)
self.add(vbox)
self.show_all()
def __init__(self):
gtk.Frame.__init__(self)
self.set_border_width(4)
self.modify_bg(0, COLORES["window"])
self.set_label(" Datos de Usuario ")
self.get_property("label-widget").modify_bg(0, COLORES["window"])
self.set_label_align(0.5, 1.0)
tabla = gtk.Table(rows=5, columns=2, homogeneous=True)
tabla.set_property("column-spacing", 5)
tabla.set_property("row-spacing", 5)
label = gtk.Label("Nombre:")
tabla.attach(label, 0, 1, 0, 1)
self.nombre = gtk.Entry()
self.nombre.connect("changed", self.__update_data)
tabla.attach(self.nombre, 1, 2, 0, 1)
label = gtk.Label("Apellido:")
tabla.attach(label, 0, 1, 1, 2)
self.apellido = gtk.Entry()
self.apellido.connect("changed", self.__update_data)
tabla.attach(self.apellido, 1, 2, 1, 2)
label = gtk.Label("Escuela:")
tabla.attach(label, 0, 1, 2, 3)
self.escuela = gtk.Entry()
self.escuela.connect("changed", self.__update_data)
tabla.attach(self.escuela, 1, 2, 2, 3)
label = gtk.Label("Grado:")
tabla.attach(label, 0, 1, 3, 4)
self.grado = gtk.combo_box_new_text()
self.grado.connect("changed", self.__update_data)
for g in GRADOS:
self.grado.append_text(g)
tabla.attach(self.grado, 1, 2, 3, 4)
label = gtk.Label("Edad:")
tabla.attach(label, 0, 1, 4, 5)
self.edad = gtk.combo_box_new_text()
self.edad.connect("changed", self.__update_data)
for e in EDADES:
self.edad.append_text(str(e))
tabla.attach(self.edad, 1, 2, 4, 5)
event = gtk.EventBox()
event.modify_bg(0, COLORES["window"])
event.set_border_width(4)
event.add(tabla)
self.add(event)
self.show_all()
def __init__(self, query_builder, remove_callback, row_number=None):
self.mapper = weakref.proxy(query_builder.mapper)
self.table = weakref.proxy(query_builder.expressions_table)
self.dialog = weakref.proxy(query_builder)
self.menu_item_selected = False
if row_number is None:
# assume we want the row appended to the end of the table
row_number = self.table.props.n_rows
self.and_or_combo = None
if row_number != 1:
self.and_or_combo = gtk.combo_box_new_text()
self.and_or_combo.append_text("and")
self.and_or_combo.append_text("or")
self.and_or_combo.set_active(0)
self.table.attach(self.and_or_combo, 0, 1,
row_number, row_number + 1)
self.prop_button = gtk.Button(_('Choose a property...'))
self.prop_button.props.use_underline = False
def on_prop_button_clicked(button, event, menu):
menu.popup(None, None, None, event.button, event.time)
self.schema_menu = SchemaMenu(self.mapper,
self.on_schema_menu_activated,
self.relation_filter)
self.prop_button.connect('button-press-event', on_prop_button_clicked,
self.schema_menu)
self.table.attach(self.prop_button, 1, 2, row_number, row_number+1)
self.cond_combo = gtk.combo_box_new_text()
conditions = ['=', '!=', '<', '<=', '>', '>=', 'is', 'is not', 'like',
'ilike']
map(self.cond_combo.append_text, conditions)
self.cond_combo.set_active(0)
self.table.attach(self.cond_combo, 2, 3, row_number, row_number+1)
# by default we start with an entry but value_widget can
# change depending on the type of the property chosen in the
# schema menu, see self.on_schema_menu_activated
self.value_widget = gtk.Entry()
self.value_widget.connect('changed', self.on_value_changed)
self.table.attach(self.value_widget, 3, 4, row_number, row_number+1)
if row_number != 1:
image = gtk.image_new_from_stock(gtk.STOCK_REMOVE,
gtk.ICON_SIZE_BUTTON)
self.remove_button = gtk.Button()
self.remove_button.props.image = image
self.remove_button.connect('clicked',
lambda b: remove_callback(self))
self.table.attach(self.remove_button, 4, 5,
row_number, row_number + 1)
def __init__(self, ch_num):
self.chan_val = np.zeros((24), dtype=int)
self.channel_box = gtk.HBox(homogeneous=False,spacing=0)
if ch_num < 9:
self.glabel = gtk.Label( " " + str(ch_num + 1) )
else:
self.glabel = gtk.Label( str(ch_num + 1) )
self.button_SP = gtk.ToggleButton( label="n" )
self.button_SC = gtk.CheckButton()
self.button_SL = gtk.CheckButton()
self.button_ST = gtk.CheckButton()
self.button_SM = gtk.CheckButton()
self.combo_SD = gtk.combo_box_new_text()
self.button_SMX = gtk.CheckButton()
self.combo_SZ10b = gtk.combo_box_new_text()
self.combo_SZ8b = gtk.combo_box_new_text()
self.combo_SZ6b = gtk.combo_box_new_text()
for i in range(16):
self.combo_SD.append_text(str(i) + " mv")
self.combo_SD.set_active(0)
for i in range(32):
self.combo_SZ10b.append_text(str(i) + " ns")
self.combo_SZ10b.set_active(0)
for i in range(16):
self.combo_SZ8b.append_text(str(i) + " ns")
self.combo_SZ8b.set_active(0)
for i in range(8):
self.combo_SZ6b.append_text(str(i) + " ns")
self.combo_SZ6b.set_active(0)
self.button_SP.connect("toggled",self.SP_callback,ch_num)
self.button_SC.connect("toggled",self.SC_callback,ch_num)
self.button_SL.connect("toggled",self.SL_callback,ch_num)
self.button_ST.connect("toggled",self.ST_callback,ch_num)
self.button_SM.connect("toggled",self.SM_callback,ch_num)
if ch_num < 64:
self.button_SM.set_active(True)
self.combo_SD.connect("changed",self.get_SD_value,ch_num)
self.button_SMX.connect("toggled",self.SMX_callback,ch_num)
self.combo_SZ10b.connect("changed",self.get_SZ10b_value,ch_num)
self.combo_SZ8b.connect("changed",self.get_SZ8b_value,ch_num)
self.combo_SZ6b.connect("changed",self.get_SZ6b_value,ch_num)
self.channel_box.pack_start(self.glabel,expand=False)
self.channel_box.pack_start(self.button_SP,expand=False)
self.channel_box.pack_start(self.button_SC,expand=False)
self.channel_box.pack_start(self.button_SL,expand=False)
self.channel_box.pack_start(self.button_ST,expand=False)
self.channel_box.pack_start(self.button_SM,expand=False)
self.channel_box.pack_start(self.combo_SD,expand=False)
self.channel_box.pack_start(self.button_SMX,expand=False)
self.channel_box.pack_start(self.combo_SZ10b,expand=False)
self.channel_box.pack_start(self.combo_SZ8b,expand=False)
self.channel_box.pack_start(self.combo_SZ6b,expand=False)
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", self.destroy)
self.window.set_default_size(400, 300)
self.window.set_border_width(20)
# Title
vbox = gtk.VBox(False, 0)
vbox.set_spacing(15)
label = gtk.Label("Connect to xpra server")
label.modify_font(pango.FontDescription("sans 13"))
vbox.pack_start(label)
# Mode:
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
hbox.pack_start(gtk.Label("Mode: "))
self.mode_combo = gtk.combo_box_new_text()
self.mode_combo.get_model().clear()
for option in ["tcp", "ssh"]:
self.mode_combo.append_text(option)
self.mode_combo.set_active(0)
hbox.pack_start(self.mode_combo)
vbox.pack_start(hbox)
# JPEG:
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
hbox.pack_start(gtk.Label("JPEG Compression: "))
self.jpeg_combo = gtk.combo_box_new_text()
self.jpeg_combo.get_model().clear()
for option in XPRA_COMPRESSION_OPTIONS:
self.jpeg_combo.append_text(option)
self.jpeg_combo.set_active(0)
hbox.pack_start(self.jpeg_combo)
vbox.pack_start(hbox)
# Host:Port
hbox = gtk.HBox(False, 0)
hbox.set_spacing(5)
self.host_entry = gtk.Entry(max=128)
self.host_entry.set_width_chars(40)
if len(sys.argv) > 1:
self.host_entry.set_text(sys.argv[1])
else:
self.host_entry.set_text("127.0.0.1")
self.port_entry = gtk.Entry(max=5)
self.port_entry.set_width_chars(5)
if len(sys.argv) > 2:
self.port_entry.set_text(sys.argv[2])
else:
self.port_entry.set_text("16010")
hbox.pack_start(self.host_entry)
hbox.pack_start(gtk.Label(":"))
hbox.pack_start(self.port_entry)
vbox.pack_start(hbox)
# Info Label
self.info = gtk.Label()
self.info.set_line_wrap(True)
self.info.set_size_request(360, -1)
vbox.pack_start(self.info)
# Connect button:
self.button = gtk.Button("Connect")
self.button.connect("clicked", self.connect_clicked, None)
vbox.pack_start(self.button)
self.window.add(vbox)
self.window.show_all()
def __init__(self):
global IMG_PATH
IMG_PATH = respaths.IMAGE_PATH
# Read cursors
global INSERTMOVE_CURSOR, OVERWRITE_CURSOR, TWOROLL_CURSOR, ONEROLL_CURSOR, \
ONEROLL_NO_EDIT_CURSOR, TWOROLL_NO_EDIT_CURSOR, SLIDE_CURSOR, SLIDE_NO_EDIT_CURSOR, \
MULTIMOVE_CURSOR, MULTIMOVE_NO_EDIT_CURSOR
INSERTMOVE_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "insertmove_cursor.png")
OVERWRITE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"overwrite_cursor.png")
TWOROLL_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"tworoll_cursor.png")
ONEROLL_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"oneroll_cursor.png")
SLIDE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"slide_cursor.png")
ONEROLL_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "oneroll_noedit_cursor.png")
TWOROLL_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "tworoll_noedit_cursor.png")
SLIDE_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "slide_noedit_cursor.png")
MULTIMOVE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"multimove_cursor.png")
MULTIMOVE_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "multimove_cursor.png")
# Window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_icon_from_file(respaths.IMAGE_PATH +
"flowbladeappicon.png")
self.window.set_border_width(5)
# To ask confirmation for shutdown
self.window.connect("delete-event", lambda w, e: app.shutdown())
# Player consumer has to be stopped and started when window resized
self.window.connect("window-state-event",
lambda w, e: updater.refresh_player())
# Build menubar
# Menubar build resources
menu_actions = [
('FileMenu', None, _('_File')),
('New', None, _('_New...'), '<control>N', None,
lambda a: projectaction.new_project()),
('Open', None, _('_Open...'), '<control>O', None,
lambda a: projectaction.load_project()),
('OpenRecent', None, _('Open Recent')),
('Save', None, _('_Save'), '<control>S', None,
lambda a: projectaction.save_project()),
('Save As', None, _('_Save As...'), None, None,
lambda a: projectaction.save_project_as()),
('SaveSnapshot', None, _('Save Backup Snapshot...'), None, None,
lambda a: projectaction.save_backup_snapshot()),
('ExportMenu', None, _('Export')),
('ExportMeltXML', None, _('MLT XML'), None, None,
lambda a: exporting.MELT_XML_export()),
('ExportEDL', None, _('EDL CMX 3600'), None, None,
lambda a: exporting.EDL_export()),
('ExportScreenshot', None, _('Current Frame'), None, None,
lambda a: exporting.screenshot_export()),
('Close', None, _('_Close'), None, None,
lambda a: projectaction.close_project()),
('Quit', None, _('_Quit'), '<control>Q', None,
lambda a: app.shutdown()), ('EditMenu', None, _('_Edit')),
('Undo', None, _('_Undo'), '<control>Z', None,
undo.do_undo_and_repaint),
('Redo', None, _('_Redo'), '<control>Y', None,
undo.do_redo_and_repaint),
('AddFromMonitor', None, _('Add Monitor Clip')),
('AppendClip', None, _('Append'), None, None,
lambda a: tlineaction.append_button_pressed()),
('InsertClip', None, _('Insert'), None, None,
lambda a: tlineaction.insert_button_pressed()),
('ThreepointOverWriteClip', None, _('Three Point Overwrite'), None,
None, lambda a: tlineaction.three_point_overwrite_pressed()),
('RangeOverWriteClip', None, _('Range Overwrite'), None, None,
lambda a: tlineaction.range_overwrite_pressed()),
('CutClip', None, _('Cut Clip'), None, None,
lambda a: tlineaction.cut_pressed()),
('DeleteClip', None, _('Lift'), None, None,
lambda a: tlineaction.lift_button_pressed()),
('SpliceOutClip', None, _('Splice Out'), None, None,
lambda a: tlineaction.splice_out_button_pressed()),
('ResyncSelected', None, _('Resync'), None, None,
lambda a: tlineaction.resync_button_pressed()),
('SetSyncParent', None, _('Set Sync Parent'), None, None,
lambda a: _this_is_not_used()),
('AddTransition', None, _('Add Single Track Transition'), None,
None, lambda a: tlineaction.add_transition_menu_item_selected()),
('AddFade', None, _('Add Single Track Fade'), None, None,
lambda a: tlineaction.add_fade_menu_item_selected()),
('ClearFilters', None, _('Clear Filters'), None, None,
lambda a: clipmenuaction.clear_filters()),
('ChangeSequenceTracks', None,
_('Change Sequence Tracks Count...'), None, None,
lambda a: projectaction.change_sequence_track_count()),
('Watermark', None, _('Watermark...'), None, None,
lambda a: menuactions.edit_watermark()),
('ProfilesManager', None, _('Profiles Manager'), None, None,
lambda a: menuactions.profiles_manager()),
('Preferences', None, _('Preferences'), None, None,
lambda a: preferenceswindow.preferences_dialog()),
('ViewMenu', None, _('View')), ('ProjectMenu', None, _('Project')),
('AddMediaClip', None, _('Add Media Clip...'), None, None,
lambda a: projectaction.add_media_files()),
('AddImageSequence', None, _('Add Image Sequence...'), None, None,
lambda a: projectaction.add_image_sequence()),
('CreateColorClip', None, _('Create Color Clip...'), None, None,
lambda a: patternproducer.create_color_clip()),
('PatternProducersMenu', None, _('Create Pattern Producer')),
('CreateNoiseClip', None, _('Noise'), None, None,
lambda a: patternproducer.create_noise_clip()),
('CreateBarsClip', None, _('EBU Bars'), None, None,
lambda a: patternproducer.create_bars_clip()),
('CreateIsingClip', None, _('Ising'), None, None,
lambda a: patternproducer.create_icing_clip()),
('CreateColorPulseClip', None, _('Color Pulse'), None, None,
lambda a: patternproducer.create_color_pulse_clip()),
('LogClipRange', None, _('Log Marked Clip Range'), '<control>L',
None, lambda a: medialog.log_range_clicked()),
('RecreateMediaIcons', None, _('Recreate Media Icons...'), None,
None, lambda a: menuactions.recreate_media_file_icons()),
('RemoveUnusedMedia', None, _('Remove Unused Media...'), None,
None, lambda a: projectaction.remove_unused_media()),
('JackAudio', None, _("JACK Audio..."), None, None,
lambda a: menuactions.jack_output_managing()),
('ProxyManager', None, _('Proxy Manager'), None, None,
lambda a: proxyediting.show_proxy_manager_dialog()),
('ProjectType', None, _("Change Project Type..."), None, None,
lambda a: projectaction.change_project_type()),
('ProjectInfo', None, _('Project Info'), None, None,
lambda a: menuactions.show_project_info()),
('RenderMenu', None, _('Render')),
('AddToQueue', None, _('Add To Batch Render Queue...'), None, None,
lambda a: projectaction.add_to_render_queue()),
('BatchRender', None, _('Batch Render Queue'), None, None,
lambda a: batchrendering.launch_batch_rendering()),
('Render', None, _('Render Timeline'), None, None,
lambda a: projectaction.do_rendering()),
('ToolsMenu', None, _('Tools')),
('Titler', None, _('Titler'), None, None,
lambda a: titler.show_titler()),
('AudioMix', None, _('Audio Mixer'), None, None,
lambda a: audiomonitoring.show_audio_monitor()),
('MediaLink', None, _('Media Relinker'), None, None,
lambda a: medialinker.display_linker()),
('HelpMenu', None, _('_Help')),
('QuickReference', None, _('Contents'), None, None,
lambda a: menuactions.quick_reference()),
('Environment', None, _('Runtime Environment'), None, None,
lambda a: menuactions.environment()),
('KeyboardShortcuts', None, _('Keyboard Shortcuts'), None, None,
lambda a: dialogs.keyboard_shortcuts_dialog(self.window)),
('About', None, _('About'), None, None,
lambda a: menuactions.about()),
('InsertMode', None, None, '1', None,
lambda a: _this_is_not_used()),
('OverMode', None, None, '2', None, lambda a: _this_is_not_used()),
('OneRollMode', None, None, '3', None,
lambda a: _this_is_not_used()),
('TwoRollMode', None, None, '4', None,
lambda a: _this_is_not_used()),
('SlideMode', None, None, '5', None,
lambda a: _this_is_not_used()),
('MultiMode', None, None, '6', None, lambda a: _this_is_not_used())
]
menu_string = """<ui>
<menubar name='MenuBar'>
<menu action='FileMenu'>
<menuitem action='New'/>
<menuitem action='Open'/>
<menu action='OpenRecent'/>
<menuitem action='Save'/>
<menuitem action='Save As'/>
<menuitem action='SaveSnapshot'/>
<separator/>
<menu action='ExportMenu'>
<menuitem action='ExportMeltXML'/>
<menuitem action='ExportEDL'/>
<menuitem action='ExportScreenshot'/>
</menu>
<separator/>
<menuitem action='Close'/>
<menuitem action='Quit'/>
</menu>
<menu action='EditMenu'>
<menuitem action='Undo'/>
<menuitem action='Redo'/>
<separator/>
<menu action='AddFromMonitor'>
<menuitem action='AppendClip'/>
<menuitem action='InsertClip'/>
<menuitem action='ThreepointOverWriteClip'/>
<menuitem action='RangeOverWriteClip'/>
</menu>
<separator/>
<menuitem action='CutClip'/>
<separator/>
<menuitem action='SpliceOutClip'/>
<menuitem action='DeleteClip'/>
<menuitem action='ResyncSelected'/>
<menuitem action='ClearFilters'/>
<separator/>
<menuitem action='AddTransition'/>
<menuitem action='AddFade'/>
<separator/>
<menuitem action='ChangeSequenceTracks'/>
<menuitem action='Watermark'/>
<separator/>
<menuitem action='ProfilesManager'/>
<menuitem action='Preferences'/>
</menu>
<menu action='ViewMenu'>
</menu>
<menu action='ProjectMenu'>
<menuitem action='AddMediaClip'/>
<menuitem action='AddImageSequence'/>
<separator/>
<menuitem action='CreateColorClip'/>
<menu action='PatternProducersMenu'>
<menuitem action='CreateNoiseClip'/>
<menuitem action='CreateColorPulseClip'/>
<menuitem action='CreateIsingClip'/>
<menuitem action='CreateBarsClip'/>
</menu>
<separator/>
<menuitem action='LogClipRange'/>
<separator/>
<menuitem action='RecreateMediaIcons'/>
<menuitem action='RemoveUnusedMedia'/>
<separator/>
<menuitem action='ProxyManager'/>
</menu>
<menu action='RenderMenu'>
<menuitem action='AddToQueue'/>
<menuitem action='BatchRender'/>
<separator/>
<menuitem action='Render'/>
</menu>
<menu action='ToolsMenu'>
<menuitem action='Titler'/>
<menuitem action='AudioMix'/>
<separator/>
<menuitem action='MediaLink'/>
</menu>
<menu action='HelpMenu'>
<menuitem action='QuickReference'/>
<menuitem action='KeyboardShortcuts'/>
<menuitem action='Environment'/>
<separator/>
<menuitem action='About'/>
</menu>
</menubar>
</ui>"""
# Create global action group
action_group = gtk.ActionGroup('WindowActions')
action_group.add_actions(menu_actions, user_data=None)
# Create UIManager and add accelators to window
ui = gtk.UIManager()
ui.insert_action_group(action_group, 0)
ui.add_ui_from_string(menu_string)
accel_group = ui.get_accel_group()
self.window.add_accel_group(accel_group)
# Get menu bar
self.menubar = ui.get_widget('/MenuBar')
# Set reference to UI manager and acclegroup
self.uimanager = ui
self.accel_group = accel_group
# Add recent projects to menu
editorpersistance.fill_recents_menu_widget(
ui.get_widget('/MenuBar/FileMenu/OpenRecent'),
projectaction.open_recent_project)
# Disable audio mixer if not available
if editorstate.audio_monitoring_available == False:
ui.get_widget('/MenuBar/ToolsMenu/AudioMix').set_sensitive(False)
# Menu box
menu_vbox = gtk.VBox(False, 0)
menu_vbox.pack_start(self.menubar, False, True, 0)
# Media manager
self.bin_list_view = guicomponents.BinListView(
projectaction.bin_selection_changed, projectaction.bin_name_edited)
dnd.connect_bin_tree_view(self.bin_list_view.treeview,
projectaction.move_files_to_bin)
self.bin_list_view.set_property("can-focus", True)
bins_panel = panels.get_bins_panel(
self.bin_list_view, lambda w, e: projectaction.add_new_bin(),
lambda w, e: projectaction.delete_selected_bin())
bins_panel.set_size_request(MEDIA_MANAGER_WIDTH, BINS_HEIGHT)
self.media_list_view = guicomponents.MediaPanel(
projectaction.media_file_menu_item_selected,
updater.set_and_display_monitor_media_file)
self.media_scroll_window = gtk.ScrolledWindow()
self.media_scroll_window.add_with_viewport(self.media_list_view.widget)
self.media_scroll_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.media_scroll_window.set_size_request(
guicomponents.MEDIA_OBJECT_WIDGET_WIDTH * 2 + 70,
guicomponents.MEDIA_OBJECT_WIDGET_HEIGHT)
self.media_scroll_window.show_all()
media_panel = panels.get_media_files_panel(
self.media_scroll_window,
lambda w, e: projectaction.add_media_files(),
lambda w, e: projectaction.delete_media_files(),
lambda a: self.media_list_view.columns_changed(a),
lambda w, e: proxyediting.create_proxy_files_pressed(),
projectaction.media_filtering_select_pressed)
self.mm_paned = gtk.HPaned()
self.mm_paned.pack1(bins_panel, resize=True, shrink=True)
self.mm_paned.pack2(media_panel, resize=True, shrink=False)
mm_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
mm_panel.set_padding(2, 2, 6, 2)
mm_panel.add(self.mm_paned)
# Effects
self.effect_select_list_view = guicomponents.FilterListView()
self.effect_select_combo_box = gtk.combo_box_new_text()
self.effect_select_list_view.treeview.connect(
"row-activated",
clipeffectseditor.effect_select_row_double_clicked)
dnd.connect_effects_select_tree_view(
self.effect_select_list_view.treeview)
clip_editor_panel = clipeffectseditor.get_clip_effects_editor_panel(
self.effect_select_combo_box, self.effect_select_list_view)
clipeffectseditor.widgets.effect_stack_view.treeview.connect(
"button-press-event", clipeffectseditor.filter_stack_button_press)
effects_editor_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
effects_editor_panel.set_padding(0, 0, 4, 0)
effects_editor_panel.add(clipeffectseditor.widgets.value_edit_frame)
effects_hbox = gtk.HBox()
effects_hbox.set_border_width(5)
effects_hbox.pack_start(clip_editor_panel, False, False, 0)
effects_hbox.pack_start(effects_editor_panel, True, True, 0)
self.effects_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
self.effects_panel.set_padding(2, 2, 2, 2)
self.effects_panel.add(effects_hbox)
# Compositors
compositor_clip_panel = compositeeditor.get_compositor_clip_panel()
compositor_editor_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
compositor_editor_panel.set_padding(0, 0, 4, 0)
compositor_editor_panel.add(compositeeditor.widgets.value_edit_frame)
compositors_hbox = gtk.HBox()
compositors_hbox.set_border_width(5)
compositors_hbox.pack_start(compositor_clip_panel, False, False, 0)
compositors_hbox.pack_start(compositor_editor_panel, True, True, 0)
self.compositors_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
self.compositors_panel.set_padding(0, 0, 0, 0)
self.compositors_panel.add(compositors_hbox)
# Render
normal_height = True
if appconsts.TOP_ROW_HEIGHT < 500: # small screens have no space to display this
normal_height = False
add_audio_desc = True
if editorstate.SCREEN_HEIGHT < 863:
add_audio_desc = False
try:
render.create_widgets(normal_height)
render_panel_left = rendergui.get_render_panel_left(
render.widgets, add_audio_desc, normal_height)
except IndexError:
print "No rendering options found"
render_panel_left = None
# 'None' here means that no possible rendering options were available
# and creating panel failed. Inform user of this and hide render GUI
if render_panel_left == None:
render_hbox = gtk.VBox(False, 5)
render_hbox.pack_start(gtk.Label("Rendering disabled."), False,
False, 0)
render_hbox.pack_start(
gtk.Label("No available rendering options found."), False,
False, 0)
render_hbox.pack_start(
gtk.Label(
"See Help->Environment->Render Options for details."),
False, False, 0)
render_hbox.pack_start(
gtk.Label("Install codecs to make rendering available."),
False, False, 0)
render_hbox.pack_start(gtk.Label(" "), True, True, 0)
else: # all is good
render_panel_right = rendergui.get_render_panel_right(
render.widgets, lambda w, e: projectaction.do_rendering(),
lambda w, e: projectaction.add_to_render_queue())
render_hbox = gtk.HBox(True, 5)
render_hbox.pack_start(render_panel_left, True, True, 0)
render_hbox.pack_start(render_panel_right, True, True, 0)
render_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
render_panel.set_padding(2, 6, 8, 6)
render_panel.add(render_hbox)
# Media log events List
media_log_events_list_view = medialog.get_media_log_list_view()
events_panel = medialog.get_media_log_events_panel(
media_log_events_list_view)
media_log_vbox = gtk.HBox()
media_log_vbox.pack_start(events_panel, True, True, 0)
media_log_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
media_log_panel.set_padding(6, 6, 6, 6)
media_log_panel.add(media_log_vbox)
self.media_log_events_list_view = media_log_events_list_view
# Sequence list
self.sequence_list_view = guicomponents.SequenceListView(
projectaction.sequence_name_edited)
seq_panel = panels.get_sequences_panel(
self.sequence_list_view,
lambda w, e: projectaction.change_edit_sequence(),
lambda w, e: projectaction.add_new_sequence(),
lambda w, e: projectaction.delete_selected_sequence())
# Project info
project_info_panel = projectinfogui.get_project_info_panel()
# Project vbox and panel
project_vbox = gtk.HBox()
project_vbox.pack_start(project_info_panel, False, True, 0)
project_vbox.pack_start(seq_panel, True, True, 0)
project_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
project_panel.set_padding(0, 2, 6, 2)
project_panel.add(project_vbox)
# Notebook
self.notebook = gtk.Notebook()
self.notebook.set_size_request(appconsts.NOTEBOOK_WIDTH,
appconsts.TOP_ROW_HEIGHT)
self.notebook.append_page(mm_panel, gtk.Label(_("Media")))
self.notebook.append_page(media_log_panel, gtk.Label(_("Range Log")))
self.notebook.append_page(self.effects_panel, gtk.Label(_("Filters")))
self.notebook.append_page(self.compositors_panel,
gtk.Label(_("Compositors")))
self.notebook.append_page(project_panel, gtk.Label(_("Project")))
self.notebook.append_page(render_panel, gtk.Label(_("Render")))
self.notebook.set_tab_pos(gtk.POS_BOTTOM)
# Right notebook, used for Widescreen and Two row layouts
self.right_notebook = gtk.Notebook()
self.right_notebook.set_tab_pos(gtk.POS_BOTTOM)
# Position bar and decorative frame for it
self.pos_bar = PositionBar()
pos_bar_frame = gtk.Frame()
pos_bar_frame.add(self.pos_bar.widget)
pos_bar_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# Positionbar vbox
pos_bar_vbox = gtk.VBox(False, 1)
pos_bar_vbox.pack_start(guiutils.get_pad_label(5, 2), False, True, 0)
pos_bar_vbox.pack_start(pos_bar_frame, False, True, 0)
# Play buttons row
self._create_monitor_row_widgets()
self.player_buttons = glassbuttons.PlayerButtons()
self.player_buttons.widget.set_tooltip_text(
_("Prev Frame - Arrow Left\nNext Frame - Arrow Right\nPlay - Space\nStop - Space\nMark In - I\nMark Out - O\nClear Marks\nTo Mark In\nTo Mark Out"
))
self.monitor_source.modify_font(pango.FontDescription("sans bold 8"))
player_buttons_row = gtk.HBox(False, 0)
player_buttons_row.pack_start(self.player_buttons.widget, False, True,
0)
player_buttons_row.pack_start(self.monitor_source, True, True, 0)
# Creates monitor switch buttons
self._create_monitor_buttons()
# Switch button box
switch_hbox = gtk.HBox(True, 1)
switch_hbox.pack_start(self.sequence_editor_b, False, False, 0)
switch_hbox.pack_start(self.clip_editor_b, False, False, 0)
# Switch button box V, for centered buttons
switch_vbox = gtk.VBox(False, 1)
switch_vbox.pack_start(guiutils.get_pad_label(5, 2), False, True, 0)
switch_vbox.pack_start(switch_hbox, False, True, 0)
# Switch / pos bar row
self.view_mode_select = guicomponents.get_monitor_view_select_combo(
lambda w, e: tlineaction.view_mode_menu_lauched(w, e))
sw_pos_hbox = gtk.HBox(False, 1)
sw_pos_hbox.pack_start(switch_vbox, False, True, 0)
sw_pos_hbox.pack_start(pos_bar_vbox, True, True, 0)
sw_pos_hbox.pack_start(self.view_mode_select.widget, False, False, 0)
# Video display
black_box = gtk.EventBox()
black_box.add(gtk.Label())
bg_color = gtk.gdk.Color(red=0.0, green=0.0, blue=0.0)
black_box.modify_bg(gtk.STATE_NORMAL, bg_color)
self.tline_display = black_box # This can be any GTK+ widget (that is not "windowless"), only its XWindow draw rect
# is used to position and scale SDL overlay that actually displays video.
dnd.connect_video_monitor(self.tline_display)
# Monitor
monitor_vbox = gtk.VBox(False, 1)
monitor_vbox.pack_start(self.tline_display, True, True, 0)
monitor_vbox.pack_start(sw_pos_hbox, False, True, 0)
monitor_vbox.pack_start(player_buttons_row, False, True, 0)
monitor_align = gtk.Alignment(xalign=0.0,
yalign=0.0,
xscale=1.0,
yscale=1.0)
monitor_align.add(monitor_vbox)
monitor_align.set_padding(3, 0, 3, 3)
monitor_frame = gtk.Frame()
monitor_frame.add(monitor_align)
monitor_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
monitor_frame.set_size_request(MONITOR_AREA_WIDTH,
appconsts.TOP_ROW_HEIGHT)
# Notebook panel
notebook_vbox = gtk.VBox(False, 1)
notebook_vbox.pack_start(self.notebook, True, True)
# Top row paned
self.top_paned = gtk.HPaned()
self.top_paned.pack1(notebook_vbox, resize=False, shrink=False)
self.top_paned.pack2(monitor_frame, resize=True, shrink=False)
# Top row
self.top_row_hbox = gtk.HBox(False, 0)
self.top_row_hbox.pack_start(self.top_paned, True, True, 0)
self._update_top_row()
# Edit buttons rows
self.edit_buttons_row = self._get_edit_buttons_row()
self.edit_buttons_frame = gtk.Frame()
self.edit_buttons_frame.add(self.edit_buttons_row)
self.edit_buttons_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# Timeline scale
self.tline_scale = tlinewidgets.TimeLineFrameScale(
editevent.insert_move_mode_pressed, updater.mouse_scroll_zoom)
# Timecode display
self.tline_info = gtk.HBox()
info_contents = gtk.Label()
self.tline_info.add(info_contents)
self.tline_info.info_contents = info_contents # this switched and sacved as member of its container
info_h = gtk.HBox()
info_h.pack_start(self.tline_info, False, False, 0)
info_h.pack_start(gtk.Label(), True, True, 0)
info_h.set_size_request(
tlinewidgets.COLUMN_WIDTH - 22 -
22, # - 22, # room for 2 menu launch buttons
tlinewidgets.SCALE_HEIGHT)
marker_pixbuf = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"marker.png")
markers_launcher = guicomponents.get_markers_menu_launcher(
tlineaction.marker_menu_lauch_pressed, marker_pixbuf)
tracks_launcher_pixbuf = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "track_menu_launch.png")
tracks_launcher = guicomponents.PressLaunch(
trackaction.all_tracks_menu_launch_pressed, tracks_launcher_pixbuf)
# Timeline top row
tline_hbox_1 = gtk.HBox()
tline_hbox_1.pack_start(info_h, False, False, 0)
tline_hbox_1.pack_start(tracks_launcher.widget, False, False, 0)
tline_hbox_1.pack_start(markers_launcher.widget, False, False, 0)
tline_hbox_1.pack_start(self.tline_scale.widget, True, True, 0)
# Timeline column
self.tline_column = tlinewidgets.TimeLineColumn(
trackaction.track_active_switch_pressed,
trackaction.track_center_pressed)
# Timeline editpanel
self.tline_canvas = tlinewidgets.TimeLineCanvas(
editevent.tline_canvas_mouse_pressed,
editevent.tline_canvas_mouse_moved,
editevent.tline_canvas_mouse_released,
editevent.tline_canvas_double_click, updater.mouse_scroll_zoom,
self.tline_cursor_leave, self.tline_cursor_enter)
dnd.connect_tline(self.tline_canvas.widget,
editevent.tline_effect_drop,
editevent.tline_media_drop)
# Timeline middle row
tline_hbox_2 = gtk.HBox()
tline_hbox_2.pack_start(self.tline_column.widget, False, False, 0)
tline_hbox_2.pack_start(self.tline_canvas.widget, True, True, 0)
# Bottom row filler
self.left_corner = guicomponents.TimeLineLeftBottom()
self.left_corner.widget.set_size_request(tlinewidgets.COLUMN_WIDTH, 20)
# Timeline scroller
self.tline_scroller = tlinewidgets.TimeLineScroller(
updater.tline_scrolled)
# Timeline bottom row
tline_hbox_3 = gtk.HBox()
tline_hbox_3.pack_start(self.left_corner.widget, False, False, 0)
tline_hbox_3.pack_start(self.tline_scroller, True, True, 0)
# Timeline hbox
tline_vbox = gtk.VBox()
tline_vbox.pack_start(tline_hbox_1, False, False, 0)
tline_vbox.pack_start(tline_hbox_2, True, True, 0)
tline_vbox.pack_start(tline_hbox_3, False, False, 0)
# Timeline box
self.tline_box = gtk.HBox()
self.tline_box.pack_start(tline_vbox, True, True, 0)
# Timeline pane
tline_pane = gtk.VBox(False, 1)
tline_pane.pack_start(self.edit_buttons_frame, False, True, 0)
tline_pane.pack_start(self.tline_box, True, True, 0)
# VPaned top row / timeline
self.app_v_paned = gtk.VPaned()
self.app_v_paned.pack1(self.top_row_hbox, resize=False, shrink=False)
self.app_v_paned.pack2(tline_pane, resize=True, shrink=False)
# Pane
pane = gtk.VBox(False, 1)
pane.pack_start(menu_vbox, False, True, 0)
pane.pack_start(self.app_v_paned, True, True, 0)
# Tooltips
self._add_tool_tips()
# GUI preferences
self._init_gui_to_prefs()
# Viewmenu initial state
self._init_view_menu(ui.get_widget('/MenuBar/ViewMenu'))
# Set pane and show window
self.window.add(pane)
self.window.set_title("Flowblade")
# Maximize if it seems that we exited maximized, else set size
w, h = editorpersistance.prefs.exit_allocation
if w != 0: # non-existing prefs file causes w and h to be 0
if (float(w) / editorstate.SCREEN_WIDTH >
0.95) and (float(h) / editorstate.SCREEN_HEIGHT > 0.95):
self.window.maximize()
print "maximize"
else:
self.window.resize(w, h)
self.window.set_position(gtk.WIN_POS_CENTER)
else:
self.window.set_position(gtk.WIN_POS_CENTER)
# Show window and all of its components
self.window.show_all()
# Set paned positions
self.mm_paned.set_position(editorpersistance.prefs.mm_paned_position)
self.top_paned.set_position(editorpersistance.prefs.top_paned_position)
self.app_v_paned.set_position(
editorpersistance.prefs.app_v_paned_position)
def create_list_box(self, str1, str2, int1, int2):
'''Returns a ComboBox object'''
return gtk.combo_box_new_text()
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 _build_interface(self):
self.vbox = gtk.VBox()
self.vbox.set_spacing(6)
self.vbox_top = gtk.VBox()
self.vbox_top.set_spacing(0)
self.list = common.list_view_new_icon_and_text(
headers=['', _('Drive'), _('Mapping')],
number_of_text_columns=2,
select_multiple=False)
self.vbox_top.pack_start(self.list, True, True)
self.hbox_buttons = gtk.HBox()
self.hbox_buttons.set_spacing(6)
self.button_add = gtk.Button(stock=gtk.STOCK_ADD)
self.button_add.set_sensitive(True)
self.hbox_buttons.pack_start(self.button_add, False, False)
self.button_remove = gtk.Button(stock=gtk.STOCK_REMOVE)
self.button_remove.set_sensitive(False)
self.hbox_buttons.pack_start(self.button_remove, False, False)
self.button_auto = common.button_new_with_image('gtk-refresh',
label=_("Autodetect"),
use_underline=False)
self.hbox_buttons.pack_end(self.button_auto, False, False)
self.vbox_top.pack_start(self.hbox_buttons, False, False)
self.vbox.pack_start(self.vbox_top, True, True)
self.vbox_bottom = gtk.VBox()
self.vbox_bottom.set_spacing(6)
self.path_entry = gtk.Entry()
self.path_button = gtk.Button(_('Browse...'))
self.path_box = common.new_label_with_widget(
'%s: ' % _('Path'), [self.path_entry, self.path_button])
self.vbox_bottom.pack_start(self.path_box, False, True)
#self.expander = gtk.Expander(_('Advanced'))
#self.vbox_bottom.pack_start(self.expander, False, True)
self.vbox_expander = gtk.VBox()
self.vbox_expander.set_spacing(6)
#self.expander.add(self.vbox_expander)
self.vbox_bottom.pack_start(self.vbox_expander, False, True)
self.device_entry = gtk.Entry()
self.device_button = gtk.Button(_('Browse...'))
self.device_box = common.new_label_with_widget(
'%s: ' % _('Device'), [self.device_entry, self.device_button])
self.vbox_expander.pack_start(self.device_box, False, True)
self.hbox_toggle = gtk.HBox()
self.device_toggle = gtk.CheckButton(_('Use device file for path'))
self.hbox_toggle.pack_end(self.device_toggle, False, True)
self.vbox_expander.pack_start(self.hbox_toggle, False, True)
self.type = gtk.combo_box_new_text()
for d_type, d_name in self.DRIVE_TYPES:
self.type.append_text(d_name)
self.type_box = common.new_label_with_widget('%s: ' % _('Type'),
self.type)
self.vbox_bottom.pack_start(self.type_box, False, True)
self.vbox.pack_start(self.vbox_bottom, False, True)
self.list.connect('changed', self.list_changed)
self.button_add.connect('clicked', self.button_add_clicked)
self.button_remove.connect('clicked', self.button_remove_clicked)
self.button_auto.connect('clicked', self.button_auto_clicked)
self.path_entry.connect('changed', self.path_changed)
self.path_button.connect('clicked', self.button_path_clicked)
self.type.connect('changed', self.type_changed)
self.device_entry.connect('changed', self.device_changed)
self.device_button.connect('clicked', self.button_device_clicked)
self.device_toggle.connect_after('toggled', self.device_toggled)
self.list.renderers[1].connect('edited', self.drive_letter_edit)
self.list.renderers[1].set_property('editable', True)
self.list.renderers[2].connect('edited', self.drive_mapping_edit)
self.list.renderers[2].set_property('editable', True)
self.frame = common.frame_wrap(self.vbox, self.title)
self.pack_start(self.frame, True, True)
self.sizable = [self.path_box.widget, self.type]
self.show_all()
self.hbox_toggle.hide()
self.filechooserdialog_path = common.filechooserdialog_new_with_filters(
title=_('Select which folder the drive should be mapped to'),
parent=common.widget_get_top_parent(self),
action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
on_response_func=self.path_dialog_response)
self.filechooserdialog_device = common.filechooserdialog_new_with_filters(
title=_('Select which device file the drive use'),
parent=common.widget_get_top_parent(self),
action=gtk.FILE_CHOOSER_ACTION_OPEN,
on_response_func=self.device_dialog_response)
def __init__(self, *args, **kwargs):
super(WinCSV, self).__init__(*args, **kwargs)
self.dialog = gtk.Dialog(parent=self.parent,
flags=gtk.DIALOG_DESTROY_WITH_PARENT)
Main().add_window(self.dialog)
self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.dialog.set_icon(TRYTON_ICON)
self.dialog.connect('response', self.response)
dialog_vbox = gtk.VBox()
hbox_mapping = gtk.HBox(True)
dialog_vbox.pack_start(hbox_mapping, True, True, 0)
frame_fields = gtk.Frame()
frame_fields.set_shadow_type(gtk.SHADOW_NONE)
viewport_fields = gtk.Viewport()
scrolledwindow_fields = gtk.ScrolledWindow()
scrolledwindow_fields.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
viewport_fields.add(scrolledwindow_fields)
frame_fields.add(viewport_fields)
label_all_fields = gtk.Label(_('<b>All fields</b>'))
label_all_fields.set_use_markup(True)
frame_fields.set_label_widget(label_all_fields)
hbox_mapping.pack_start(frame_fields, True, True, 0)
vbox_buttons = gtk.VBox(False, 10)
vbox_buttons.set_border_width(5)
hbox_mapping.pack_start(vbox_buttons, False, True, 0)
button_add = gtk.Button(_('_Add'), stock=None, use_underline=True)
button_add.set_image(
IconFactory.get_image('tryton-add', gtk.ICON_SIZE_BUTTON))
button_add.set_always_show_image(True)
button_add.connect_after('clicked', self.sig_sel)
vbox_buttons.pack_start(button_add, False, False, 0)
button_remove = gtk.Button(_('_Remove'),
stock=None,
use_underline=True)
button_remove.set_image(
IconFactory.get_image('tryton-remove', gtk.ICON_SIZE_BUTTON))
button_remove.set_always_show_image(True)
button_remove.connect_after('clicked', self.sig_unsel)
vbox_buttons.pack_start(button_remove, False, False, 0)
button_remove_all = gtk.Button(_('_Clear'),
stock=None,
use_underline=True)
button_remove_all.set_image(
IconFactory.get_image('tryton-clear', gtk.ICON_SIZE_BUTTON))
button_remove_all.set_always_show_image(True)
button_remove_all.connect_after('clicked', self.sig_unsel_all)
vbox_buttons.pack_start(button_remove_all, False, False, 0)
hseparator_buttons = gtk.HSeparator()
vbox_buttons.pack_start(hseparator_buttons, False, False, 3)
self.add_buttons(vbox_buttons)
frame_fields_selected = gtk.Frame()
frame_fields_selected.set_shadow_type(gtk.SHADOW_NONE)
viewport_fields_selected = gtk.Viewport()
scrolledwindow_fields_selected = gtk.ScrolledWindow()
scrolledwindow_fields_selected.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
viewport_fields_selected.add(scrolledwindow_fields_selected)
frame_fields_selected.add(viewport_fields_selected)
label_fields_selected = gtk.Label(_('<b>Fields selected</b>'))
label_fields_selected.set_use_markup(True)
frame_fields_selected.set_label_widget(label_fields_selected)
hbox_mapping.pack_start(frame_fields_selected, True, True, 0)
frame_csv_param = gtk.Frame()
frame_csv_param.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
dialog_vbox.pack_start(frame_csv_param, False, True, 0)
alignment_csv_param = gtk.Alignment(0.5, 0.5, 1, 1)
alignment_csv_param.set_padding(7, 7, 7, 7)
frame_csv_param.add(alignment_csv_param)
vbox_csv_param = gtk.VBox()
alignment_csv_param.add(vbox_csv_param)
self.add_chooser(vbox_csv_param)
expander_csv = gtk.Expander()
vbox_csv_param.pack_start(expander_csv, False, True, 0)
label_csv_param = gtk.Label(_('CSV Parameters'))
expander_csv.set_label_widget(label_csv_param)
table = gtk.Table(2, 4, False)
table.set_border_width(8)
table.set_row_spacings(9)
table.set_col_spacings(8)
expander_csv.add(table)
label_csv_delimiter = gtk.Label(_('Delimiter:'))
label_csv_delimiter.set_alignment(1, 0.5)
table.attach(label_csv_delimiter, 0, 1, 0, 1)
self.csv_delimiter = gtk.Entry()
self.csv_delimiter.set_max_length(1)
if os.name == 'nt' and ',' == locale.localeconv()['decimal_point']:
delimiter = ';'
else:
delimiter = ','
self.csv_delimiter.set_text(delimiter)
self.csv_delimiter.set_width_chars(1)
label_csv_delimiter.set_mnemonic_widget(self.csv_delimiter)
table.attach(self.csv_delimiter, 1, 2, 0, 1)
label_csv_quotechar = gtk.Label(_("Quote char:"))
label_csv_quotechar.set_alignment(1, 0.5)
table.attach(label_csv_quotechar, 2, 3, 0, 1)
self.csv_quotechar = gtk.Entry()
self.csv_quotechar.set_text("\"")
self.csv_quotechar.set_width_chars(1)
label_csv_quotechar.set_mnemonic_widget(self.csv_quotechar)
table.attach(self.csv_quotechar, 3, 4, 0, 1)
label_csv_enc = gtk.Label(_("Encoding:"))
label_csv_enc.set_alignment(1, 0.5)
table.attach(label_csv_enc, 0, 1, 1, 2)
if hasattr(gtk, 'ComboBoxText'):
self.csv_enc = gtk.ComboBoxText()
else:
self.csv_enc = gtk.combo_box_new_text()
for i, encoding in enumerate(encodings):
self.csv_enc.append_text(encoding)
if ((os.name == 'nt' and encoding == 'cp1252')
or (os.name != 'nt' and encoding == 'utf_8')):
self.csv_enc.set_active(i)
label_csv_enc.set_mnemonic_widget(self.csv_enc)
table.attach(self.csv_enc, 1, 2, 1, 2)
self.add_csv_header_param(table)
button_cancel = self.dialog.add_button(set_underline(_("Cancel")),
gtk.RESPONSE_CANCEL)
button_cancel.set_image(
IconFactory.get_image('tryton-cancel', gtk.ICON_SIZE_BUTTON))
button_ok = self.dialog.add_button(set_underline(_("OK")),
gtk.RESPONSE_OK)
button_ok.set_image(
IconFactory.get_image('tryton-ok', gtk.ICON_SIZE_BUTTON))
self.dialog.vbox.pack_start(dialog_vbox)
self.view1 = gtk.TreeView()
self.view1.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.view1.connect('row-expanded', self.on_row_expanded)
scrolledwindow_fields.add(self.view1)
self.view2 = gtk.TreeView()
self.view2.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
scrolledwindow_fields_selected.add(self.view2)
self.view1.set_headers_visible(False)
self.view2.set_headers_visible(False)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Field name'), cell, text=0)
self.view1.append_column(column)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Field name'), cell, text=0)
self.view2.append_column(column)
self.model1 = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
self.model2 = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
self.model_populate(self._get_fields(self.model))
self.view1.set_model(self.model1)
self.view1.connect('row-activated', self.sig_sel)
self.view2.set_model(self.model2)
self.view2.connect('row-activated', self.sig_unsel)
self.dialog.show_all()
self.show()
self.register()
if sys.platform != 'darwin':
self.view2.drag_source_set(
gtk.gdk.BUTTON1_MASK | gtk.gdk.BUTTON3_MASK, [
gtk.TargetEntry.new('EXPORT_TREE', gtk.TARGET_SAME_WIDGET,
0)
], gtk.gdk.ACTION_MOVE)
self.view2.drag_dest_set(gtk.DEST_DEFAULT_ALL, [
gtk.TargetEntry.new('EXPORT_TREE', gtk.TARGET_SAME_WIDGET, 0)
], gtk.gdk.ACTION_MOVE)
self.view2.connect('drag-begin', self.drag_begin)
self.view2.connect('drag-motion', self.drag_motion)
self.view2.connect('drag-drop', self.drag_drop)
self.view2.connect("drag-data-get", self.drag_data_get)
self.view2.connect('drag-data-received', self.drag_data_received)
self.view2.connect('drag-data-delete', self.drag_data_delete)
def __init__(self, gmtPlotterWidget, gmtWrapper, width=200):
self.tooltips = gtk.Tooltips()
self.width = width
self.gmtPlotterWidget = gmtPlotterWidget
self.eb = gtk.EventBox()
self.eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("gray"))
self.eb.set_size_request(self.width, 200)
self.vBox = gtk.VBox(homogeneous=True, spacing=1)
self.row1 = gtk.HBox(homogeneous=False, spacing=1)
# Colormap Type
self.colormapCombo = gtk.combo_box_new_text()
self.colormapCombo.append_text("haxby")
self.colormapCombo.append_text("gray")
self.colormapCombo.append_text("wysiwyg")
self.colormapCombo.append_text("polar")
self.colormapCombo.append_text("seis")
self.colormapCombo.append_text("spectral")
self.colormapCombo.append_text("other...")
self.colormapCombo.set_active(0)
self.colormapCombo.connect("changed", self.checkColormap)
self.tooltips.set_tip(
self.colormapCombo,
'select some of the GMT colormaps, or type your preferred colormap in the text field',
tip_private=None)
self.colormapEntry = gtk.Entry()
self.colormapEntry.set_width_chars(5)
self.colormapEntry.set_sensitive(False)
self.colormapLabel = gtk.Label("Colormap Type:")
self.colormapBox = gtk.HBox(homogeneous=False, spacing=5)
self.colormapBox.pack_start(self.colormapLabel)
self.invertCheck = gtk.CheckButton(label="Invert")
self.tooltips.set_tip(
self.invertCheck,
'flip the colormap around, e.g. from red->blue to blue->red',
tip_private=None)
self.invertCheckBox = gtk.HBox(homogeneous=False, spacing=0)
self.invertCheckBox.pack_start(self.invertCheck)
self.adjustCheck = gtk.CheckButton(label="Auto scale")
self.tooltips.set_tip(
self.adjustCheck,
'adjust the colormap automatically to range of scalars plotted in background, else will used fixed range',
tip_private=None)
self.adjustCheck.set_active(True)
self.adjustCheckBox = gtk.HBox(homogeneous=False, spacing=0)
self.adjustCheckBox.pack_start(self.adjustCheck)
self.labelCheck = gtk.CheckButton(label="Labels")
self.labelCheck.set_active(True)
self.tooltips.set_tip(self.labelCheck,
'Add a colorbar and labels to the maps.',
tip_private=None)
self.labelCheckBox = gtk.HBox(homogeneous=False, spacing=0)
self.labelCheckBox.pack_start(self.labelCheck)
self.plateBoundaryCheck = gtk.CheckButton(label="Pbound")
self.tooltips.set_tip(self.plateBoundaryCheck,
'plot NUVEL1 major tectonic plate boundaries',
tip_private=None)
self.plateBoundaryCheckBox = gtk.HBox(homogeneous=False, spacing=0)
self.plateBoundaryCheckBox.pack_start(self.plateBoundaryCheck)
self.coastCheck = gtk.CheckButton(label="Coastlines")
self.tooltips.set_tip(self.coastCheck,
'Plot coastlines',
tip_private=None)
self.coastCheckBox = gtk.HBox(homogeneous=False, spacing=0)
self.coastCheckBox.pack_start(self.coastCheck)
self.coastMaskCombo = gtk.combo_box_new_text()
self.coastMaskCombo.append_text("No Mask")
self.coastMaskCombo.append_text("Mask Sea")
self.coastMaskCombo.append_text("Mask Land")
self.coastMaskCombo.set_active(0)
self.plotGridLines = gtk.CheckButton(label="Grid lines")
self.tooltips.set_tip(self.plotGridLines,
'plot grid lines on top of map',
tip_private=None)
self.plotGridLinesBox = gtk.HBox(homogeneous=False, spacing=0)
self.plotGridLinesBox.pack_start(self.plotGridLines)
self.colorSymLabel = gtk.Label("Colors:")
self.coastColorButton = gtk.Button("Coast")
self.coastColorButton.connect("clicked", self.setCoastColor)
self.tooltips.set_tip(self.coastColorButton,
'change color for coast lines',
tip_private=None)
self.coastMaskColorButton = gtk.Button("Mask")
self.coastMaskColorButton.connect("clicked", self.setCoastMaskColor)
self.tooltips.set_tip(self.coastMaskColorButton,
'change color for coast mask',
tip_private=None)
self.pbcolButton = gtk.Button("Pbound")
self.pbcolButton.connect("clicked", self.setPbcol)
self.tooltips.set_tip(self.pbcolButton,
'change color for plate boundaries',
tip_private=None)
self.vecColButton = gtk.Button("Vectors")
self.vecColButton.connect("clicked", self.setVectColor)
self.tooltips.set_tip(self.vecColButton,
'change color for vectors',
tip_private=None)
# grid resolution
self.gridres = gtk.Entry()
self.gridres.set_width_chars(4)
self.gridres.set_max_length(4)
self.gridres.set_text("1.0")
self.gridresLabel = gtk.Label("resolution")
self.tooltips.set_tip(
self.gridres,
'set the resolution (in degrees) of the background grid (if applicable). 0.25...2 are useful for global plots',
tip_private=None)
#Range Settings
# self.rangeLabel = gtk.Label("Lat/Lon Range:")
# self.range1Box = gtk.HBox(homogeneous = False, spacing = 0)
# self.range1Box.pack_start(self.rangeLabel)
self.rangeButton = gtk.Button("Update Lat/Lon Range")
self.tooltips.set_tip(
self.rangeButton,
'change the geographic region to be mapped (not that useful for global plots)',
tip_private=None)
self.rangeButton.connect("clicked", self.openRangeWindow)
self.row1.pack_start(self.colormapBox, expand=False)
self.row1.pack_start(self.colormapCombo, expand=False)
self.row1.pack_start(self.colormapEntry, expand=False)
self.row1.pack_start(self.invertCheckBox, expand=False)
self.row1.pack_start(self.adjustCheckBox, expand=False)
self.row1.pack_start(self.labelCheckBox, expand=False)
self.row1.pack_start(self.rangeButton, expand=False)
self.row2 = gtk.HBox(homogeneous=False, spacing=5)
self.applyChangesButton = gtk.Button("Apply Changes")
self.applyChangesButton.connect("clicked", self.applyChanges)
# self.row2.pack_start(self.range1Box, expand = False)
self.row2.pack_start(self.plotGridLinesBox, expand=False)
self.row2.pack_start(self.coastCheckBox, expand=False)
self.row2.pack_start(self.coastMaskCombo, expand=False)
self.row2.pack_start(self.plateBoundaryCheckBox, expand=False)
self.row2.pack_start(self.colorSymLabel, expand=False)
self.row2.pack_start(self.pbcolButton, expand=False)
self.row2.pack_start(self.coastColorButton, expand=False)
# self.row2.pack_start(self.coastMaskColorButton,expand=False)
self.row2.pack_start(self.vecColButton, expand=False)
self.row2.pack_start(self.gridres, expand=False)
self.row2.pack_start(self.gridresLabel, expand=False)
self.row3 = gtk.HBox(homogeneous=True, spacing=5)
# Projection
self.projectionLabel = gtk.Label("Projection:")
self.projectionEntry = guiUtils.RangeSelectionBox(initial=170,
min=0,
max=359,
digits=0,
buttons=True)
# width of projection
self.projectionEntryEnd = gtk.Entry()
self.projectionEntryEnd.set_width_chars(2)
self.projectionEntryEnd.set_max_length(2)
self.projectionEntryEnd.set_text("7")
self.projectionLabel2 = gtk.Label("PS width (inches)")
self.projectionBox = gtk.HBox(homogeneous=False, spacing=50)
# projection type
self.projectCombo = gtk.combo_box_new_text()
self.projections = [ 'W Mollweide', 'H Hammer', 'N Robinson' ,\
'Q Equi-Cyl' , 'J Miller', 'M Mercator', 'Kf Eckert-IV', 'X Linear' ]
for pt in self.projections:
self.projectCombo.append_text(pt)
self.projectCombo.set_active(0)
self.projectionBox.pack_start(self.projectionLabel, expand=False)
self.projectionBox.pack_start(self.projectCombo, expand=False)
self.projectionBox.pack_start(self.projectionEntry, expand=True)
self.projectionBox.pack_start(self.projectionEntryEnd, expand=False)
self.projectionBox.pack_start(self.projectionLabel2, expand=False)
self.row3.pack_start(self.projectionBox, expand=False)
self.row4 = gtk.HBox(homogeneous=False, spacing=5)
self.applyChangesButton = gtk.Button("Apply Changes")
self.applyChangesButton.connect("clicked", self.applyChanges)
self.defaultsButton = gtk.Button("Reset")
self.defaultsButton.connect("clicked", self.resetToDefault)
self.row4.pack_start(self.applyChangesButton, expand=False)
self.row4.pack_start(self.defaultsButton, expand=False)
self.vBox.pack_start(self.row1, expand=False, fill=False)
self.vBox.pack_start(self.row2, expand=False, fill=False)
self.vBox.pack_start(self.row3, expand=True, fill=False)
self.vBox.pack_start(self.row4, expand=False, fill=False)
self.eb.add(self.vBox)
#
# init with none, gets set in gmt plotter widget
self.gmtPlotter = gmtWrapper
self.loadDefaults()
def create_combo_box(self, strings):
combobox = gtk.combo_box_new_text()
for label in strings:
combobox.append_text(label)
combobox.set_active(0)
return combobox
gtk.gdk.threads_init()
gtk.gdk.threads_enter()
window = gtk.Window()
window.set_position(gtk.WIN_POS_CENTER)
window.set_title("ZBar GUI")
window.set_icon_from_file(
"/home/initbrain/Bureau/fktb_0.2.3/images/logo_zbar.png")
window.set_border_width(8)
window.connect("destroy", gtk.main_quit)
zbar = zbarpygtk.Gtk()
zbar.connect("decoded-text", decoded)
# video device list combo box
video_list = gtk.combo_box_new_text()
video_list.connect("changed", video_changed)
# enable/disable status button
status_button = gtk.ToggleButton("closed")
status_image = gtk.image_new_from_stock(gtk.STOCK_NO, gtk.ICON_SIZE_BUTTON)
status_button.set_image(status_image)
status_button.set_sensitive(False)
# bind status button state and video state
status_button.connect("toggled", status_button_toggled)
zbar.connect("notify::video-enabled", video_enabled)
zbar.connect("notify::video-opened", video_opened)
# open image file button
open_button = gtk.Button(stock=gtk.STOCK_OPEN)
def __init__(self, folder):
'''
Конструктор
:param folder: Папка, в которой будет осуществляться поиск
:type folder: string
'''
gtk.gdk.threads_init()
if os.path.exists(folder):
self.folder = folder
gtk.Window.__init__(self)
self.set_title(_('File search'))
self.set_position(gtk.WIN_POS_CENTER)
self.set_default_size(800,500)
vbox = gtk.VBox(False, 10)
#main params
mainParamsVBox = gtk.VBox(False,10)
hbox1 = gtk.HBox(False,0)
self.label1 = gtk.Label(_('File name'))
self.label1.set_alignment(0,0.5)
self.fileNameEntry = gtk.Entry()
self.exactCB = gtk.CheckButton(_('Exact'))
self.caseCB = gtk.CheckButton(_('Case sensitive'))
self.regexCB = gtk.CheckButton(_('Regex'))
self.fileTypeCombo = gtk.combo_box_new_text()
self.fileTypeCombo.append_text(_('Files and folders'))
self.fileTypeCombo.append_text(_('Files only'))
self.fileTypeCombo.append_text(_('Folders only'))
self.fileTypeCombo.set_active(0)
hbox1.pack_start(self.label1, False, False, 10)
hbox1.pack_start(self.fileNameEntry, True, True)
hbox1.pack_start(self.fileTypeCombo, False, False,10)
hbox1.pack_start(self.exactCB, False, False,10)
hbox1.pack_start(self.caseCB, False, False,10)
hbox1.pack_start(self.regexCB, False, False,10)
self.regexCB.connect('clicked',self.regexCBClick)
hbox2 = gtk.HBox(False,0)
self.label2 = gtk.Label(_('Search in folder'))
self.label2.set_alignment(0,0.5)
self.fileChooser = gtk.FileChooserButton(_('Select folder'))
self.fileChooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
if self.folder:
self.fileChooser.set_current_folder(self.folder)
self.folderRecursiveCB = gtk.CheckButton(_('Recursive'))
self.folderRecursiveCB.set_active(True)
hbox2.pack_start(self.label2, False, False, 10)
hbox2.pack_start(self.fileChooser, True, True)
hbox2.pack_start(self.folderRecursiveCB, False, False, 10)
hbox3 = gtk.HBox(False,0)
self.label3 = gtk.Label(_('Search for text'))
self.label3.set_alignment(0,0.5)
self.textEntry = gtk.Entry()
self.textCaseCB = gtk.CheckButton(_('Case sensitive'))
self.textRegexCB = gtk.CheckButton(_('Regex'))
hbox3.pack_start(self.label3, False, False, 10)
hbox3.pack_start(self.textEntry, True, True)
hbox3.pack_start(self.textCaseCB, False, False, 10)
hbox3.pack_start(self.textRegexCB, False, False, 10)
mainParamsVBox.pack_start(hbox1)
mainParamsVBox.pack_start(hbox2)
mainParamsVBox.pack_start(hbox3)
#additional params
addParamsExpander = gtk.Expander(_('Additional parameters'))
addParamsHBox = gtk.HBox()
addParamsVBox1 = gtk.VBox()
self.useLocateCB = gtk.CheckButton(_('Use UNIX \'locate\' command'))
self.useLocateCB.set_active(True)
self.useLocateCB.set_tooltip_text('Possibly slow for text search')
self.hiddenCB = gtk.CheckButton(_('Process hidden files and folders'))
self.linksCB = gtk.CheckButton(_('Follow simlinks'))
self.linksCB.set_tooltip_text('Attention! Dead locks possible! ')
self.linksCB.set_active(True)
addParamsVBox1.pack_start(self.useLocateCB, False, False)
addParamsVBox1.pack_start(self.hiddenCB, False, False)
addParamsVBox1.pack_start(self.linksCB, False, False)
addParamsHBox.pack_start(addParamsVBox1,False, False, 10)
addParamsExpander.add(addParamsHBox)
#treeview
self.treeview = gtk.TreeView()
r = gtk.CellRendererText()
self.treeview.insert_column_with_attributes(-1, "File name", r, text=0)
#status box
self.statusBox = gtk.HBox(False,10)
self.spinner = gtk.Spinner()
#self.spinner.set_sensitive(0)
self.statusLabel = gtk.Label('')
# statusLabel.set_justify(gtk.JUSTIFY_LEFT)
self.statusLabel.set_alignment(0,0)
self.statusLabel.set_width_chars(120)
self.statusBox.pack_start(self.spinner,False,False,10)
self.statusBox.pack_start(self.statusLabel, False, False,10)
#button box
buttonBox = gtk.HButtonBox()
buttonBox.set_layout(gtk.BUTTONBOX_END)
buttonBox.set_spacing(10)
buttonBox.set_border_width(10)
self.buttonStart = gtk.Button(_('Start search'),gtk.STOCK_FIND)
self.buttonStop = gtk.Button(_('Stop search'), gtk.STOCK_STOP)
self.imagePause = gtk.Image()
self.imagePause.set_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_BUTTON)
self.imageContinue = gtk.Image()
self.imageContinue.set_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_BUTTON)
self.buttonPause = gtk.ToggleButton(_('Pause search'))
self.buttonPause.set_image(self.imagePause)
self.buttonPause.set_mode(True)
self.buttonClose = gtk.Button(_('Close'), gtk.STOCK_CLOSE)
buttonBox.add(self.buttonStart)
buttonBox.add(self.buttonStop)
buttonBox.add(self.buttonPause)
buttonBox.add(self.buttonClose)
self.buttonClose.connect('clicked', self.closeSearch)
self.buttonStart.connect('clicked', self.startSearch)
self.buttonStop.connect('clicked', self.stopSearch)
self.buttonPause.connect('clicked',self.pauseSearch)
self.buttonStop.set_sensitive(0)
self.buttonPause.set_sensitive(0)
vbox.pack_start(mainParamsVBox, False, True, 10)
vbox.pack_start(addParamsExpander, False, True, 0)
scrolled = gtk.ScrolledWindow()
scrolled.add(self.treeview)
vbox.pack_start(scrolled, True, True, 0)
vbox.pack_start(self.statusBox, False, True, 0)
vbox.pack_start(buttonBox, False, True, 0)
self.add(vbox)
#self.connect('destroy', self.closeSearch)
self.connect('delete-event', self.closeSearch)
def _build_widget(self):
#######################################################################
# Type
if self._vbox_type == None:
self._vbox_type = gtk.VBox(homogeneous=False, spacing=0)
label = gtk.Label("Type")
label.justify = gtk.JUSTIFY_LEFT
label.xalign = 0.5
label.yalign = 0.5
label.xpad = 0
label.ypad = 0
self._vbox_type.add(label)
button = gtk.combo_box_new_text()
button.connect("changed", self._type_callback)
for i in range(OscType.END):
button.insert_text(i, OscType.STRINGS[i])
button.set_active(self._type)
self._vbox_type.add(button)
self._buttons["type"] = button
self._hbox.pack_start(self._vbox_type, expand=False, fill=False)
#######################################################################
# Mute
if self._vbox_mute == None:
self._vbox_mute = gtk.VBox(homogeneous=False, spacing=0)
label = gtk.Label("Mute")
label.justify = gtk.JUSTIFY_LEFT
label.xalign = 0.5
label.yalign = 0.5
label.xpad = 0
label.ypad = 0
label.set_width_chars(6)
self._vbox_mute.add(label)
if self._mute_is_on:
button = gtk.ToggleButton("ON")
button.set_active(True)
else:
button = gtk.ToggleButton("OFF")
button.set_active(False)
button.connect("toggled", self._mute_callback)
self._vbox_mute.add(button)
self._buttons["mute"] = button
self._hbox.pack_start(self._vbox_mute, expand=False, fill=False)
#######################################################################
# Volume
if self._vbox_volume == None:
self._vbox_volume = gtk.VBox(homogeneous=False, spacing=0)
label = gtk.Label("Volume")
label.justify = gtk.JUSTIFY_LEFT
label.xalign = 0.5
label.yalign = 0.5
label.xpad = 0
label.ypad = 0
self._vbox_volume.add(label)
button = gtk.SpinButton(gtk.Adjustment(value=self._volume,
lower=0.0,
upper=1.0,
step_incr=0.01,
page_incr=0.10,
page_size=0.0),
climb_rate=0.0,
digits=2)
button.set_width_chars(6)
button.connect("value-changed", self._volume_callback)
self._vbox_volume.add(button)
self._buttons["volume"] = button
self._hbox.pack_start(self._vbox_volume, expand=False, fill=False)
#######################################################################
# Pitch
if self._vbox_pitch == None:
self._vbox_pitch = gtk.VBox(homogeneous=False, spacing=0)
label = gtk.Label("Pitch (Hz)")
label.justify = gtk.JUSTIFY_LEFT
label.xalign = 0.5
label.yalign = 0.5
label.xpad = 0
label.ypad = 0
self._vbox_pitch.add(label)
button = gtk.SpinButton(gtk.Adjustment(value=self._pitch,
lower=0.001,
upper=20000.0,
step_incr=5.0,
page_incr=10.0,
page_size=0.0),
climb_rate=0.0,
digits=4)
button.set_width_chars(10)
button.connect("value-changed", self._pitch_callback, None)
self._vbox_pitch.add(button)
self._buttons["pitch"] = button
if self._type != OscType.NOISE:
self._hbox.pack_start(self._vbox_pitch, expand=False, fill=False)
#######################################################################
# Sync
if self._vbox_sync == None:
self._vbox_sync = gtk.VBox(homogeneous=False, spacing=0)
label = gtk.Label("Sync")
label.justify = gtk.JUSTIFY_LEFT
label.xalign = 0.5
label.yalign = 0.5
label.xpad = 0
label.ypad = 0
label.set_width_chars(6)
self._vbox_sync.add(label)
button = gtk.ToggleButton("OFF")
button.connect("toggled", self._sync_callback)
self._vbox_sync.add(button)
self._buttons["sync"] = button
if self._can_sync and self._type != OscType.NOISE:
self._hbox.pack_start(self._vbox_sync, expand=False, fill=False)
#######################################################################
# Harmonics
if self._vbox_harmonics == None:
self._vbox_harmonics = gtk.VBox(homogeneous=False, spacing=0)
label = gtk.Label("Harmonics")
label.justify = gtk.JUSTIFY_LEFT
label.xalign = 0.5
label.yalign = 0.5
label.xpad = 10
label.ypad = 0
label.set_max_width_chars(10)
self._vbox_harmonics.add(label)
button = gtk.SpinButton(gtk.Adjustment(value=3,
lower=2,
upper=256,
step_incr=1,
page_incr=5,
page_size=0),
climb_rate=0,
digits=0)
button.connect("value-changed", self._harmonics_callback)
self._vbox_harmonics.add(button)
self._buttons["harmonics"] = button
if self._type in [OscType.SAWTOOTH, OscType.SQUARE]:
self._hbox.pack_start(self._vbox_harmonics,
expand=False,
fill=False)
#######################################################################
# Pulse Width
if self._vbox_pulse_width == None:
self._vbox_pulse_width = gtk.VBox(homogeneous=False, spacing=0)
label = gtk.Label("Pulse Width")
label.justify = gtk.JUSTIFY_LEFT
label.xalign = 0.5
label.yalign = 0.5
label.xpad = 10
label.ypad = 0
label.set_max_width_chars(13)
self._vbox_pulse_width.add(label)
button = gtk.SpinButton(gtk.Adjustment(value=self._pulse_width,
lower=0.000001,
upper=200000.0,
step_incr=0.0005,
page_incr=0.0010,
page_size=0),
climb_rate=0,
digits=8)
button.connect("value-changed", self._pulse_width_callback)
self._vbox_pulse_width.add(button)
self._buttons["pulse_width"] = button
if self._type == OscType.PULSE:
self._hbox.pack_start(self._vbox_pulse_width,
expand=False,
fill=False)
#######################################################################
# Pulse Units
if self._vbox_pulse_units == None:
self._vbox_pulse_units = gtk.VBox(homogeneous=False, spacing=0)
label = gtk.Label("Pulse Units")
label.justify = gtk.JUSTIFY_LEFT
label.xalign = 0.5
label.yalign = 0.5
label.xpad = 10
label.ypad = 0
label.set_max_width_chars(10)
self._vbox_pulse_units.add(label)
button = gtk.combo_box_new_text()
button.insert_text(0, "msec")
button.insert_text(0, "% lambda")
button.set_active(0)
button.connect("changed", self._pulse_units_callback)
self._vbox_pulse_units.add(button)
self._buttons["pulse_units"] = button
if self._type == OscType.PULSE:
self._hbox.pack_start(self._vbox_pulse_units,
expand=False,
fill=False)
self._hbox.show_all()
def SJLiveSetting(self, widget):
okno = gtk.Window()
okno.move(100,100)
okno.resize(350,500)
okno.set_title("Setting")
adjV = gtk.Adjustment(1, 1, 120, 1, 1, 5)
adjH = gtk.Adjustment(1, 1, 120, 1, 1, 5)
scrollSet = gtk.ScrolledWindow(adjH, adjV)
okno.add(scrollSet)
kostra = gtk.VBox()
self.HboxSetting = gtk.HBox(False,2)
frKamera = gtk.Frame("Nastavení kamery")
# Vytvoreni a vyplneni tabulky
tabGeneral = gtk.Table(5, 2, True) # 2 radky, 2 sloupce a stejna velikost policek
tabGeneral.set_row_spacings(2)
tabGeneral.set_col_spacings(5)
# Nastaveni - Zdroj kamery
#hbkamera = gtk.HBox(False, 2)
labelKamera = gtk.Label("Kamera:")
self.cbKamera = gtk.combo_box_new_text()
self.cbKamera.append_text(str(0))
for x in xrange(0,10):
if cv2.VideoCapture(x).isOpened():
self.cbKamera.append_text(str(x))
self.cbKamera.set_active( int(self.cfg.get("CAMERA","cam")) )
self.cbKamera.connect("changed", self.KameraSettingChanged)
tabGeneral.attach(labelKamera,0,1,0,1)
tabGeneral.attach(self.cbKamera,1,2,0,1)
# Nastaveni - Zaverka
#hbShutter = gtk.HBox(False, 2)
labelShutter = gtk.Label("Zaverka: 1/")
adjShutter = gtk.Adjustment(100, 1, 1000, 1, 1, 0)
self.sbShutter = gtk.SpinButton(adjShutter,1,0)
self.sbShutter.set_value( float(self.cfg.get("CAMERA","shutter")) )
self.sbShutter.connect("changed", self.KameraSettingChanged)
tabGeneral.attach(labelShutter,0,1,1,2)
tabGeneral.attach(self.sbShutter,1,2,1,2)
# Nastaveni - FrameRate
#hbFPS = gtk.HBox(False, 2)
labelFPS = gtk.Label("Snimkovaci rychlost FPS: ")
adjFPS = gtk.Adjustment(1, 0.01, 120, 0.01, 0.01, 0)
self.sbFPS = gtk.SpinButton(adjFPS,0.01,2)
self.sbFPS.set_value( float(self.cfg.get("CAMERA","fps")) )
self.sbFPS.connect("changed", self.KameraSettingChanged)
tabGeneral.attach(labelFPS,0,1,2,3)
tabGeneral.attach(self.sbFPS,1,2,2,3)
frKamera.add(tabGeneral)
kostra.pack_start(frKamera, False, False, 10)
frMaska = gtk.Frame("Nastavení Masky")
# Vytvoreni a vyplneni tabulky
tabMaska = gtk.Table(5, 2, True) # 2 radky, 2 sloupce a stejna velikost policek
tabMaska.set_row_spacings(2)
tabMaska.set_col_spacings(5)
labelZobrazMasku = gtk.Label("Zobrazit masku:")
self.cbZobrazMasku = gtk.combo_box_new_text()
self.cbZobrazMasku.append_text("Vypnuto")
self.cbZobrazMasku.append_text("Obrys - silný")
self.cbZobrazMasku.append_text("Obrys - slabý")
self.cbZobrazMasku.append_text("Obsah")
self.cbZobrazMasku.append_text("Přesah")
self.cbZobrazMasku.append_text("Maska")
self.cbZobrazMasku.set_active( int(self.cfg.get("MASK","type")) )
self.cbZobrazMasku.connect("changed", self.KameraSettingChanged)
tabMaska.attach(labelZobrazMasku,0,1,0,1)
tabMaska.attach(self.cbZobrazMasku,1,2,0,1)
HboxMask = gtk.HBox()
HboxX = gtk.HBox()
HboxY = gtk.HBox()
HboxR = gtk.HBox()
labelX = gtk.Label("X")
labelY = gtk.Label("Y")
labelR = gtk.Label("R")
adjX = gtk.Adjustment(1, 1, self.cam.get(3), 1, 1, 0)
adjY = gtk.Adjustment(1, 1, self.cam.get(4), 1, 1, 0)
adjR = gtk.Adjustment(1, 1, 120, 1, 1, 0)
self.sbMaskX = gtk.SpinButton(adjX,1,0)
self.sbMaskY = gtk.SpinButton(adjY,1,0)
self.sbMaskR = gtk.SpinButton(adjR,1,0)
HboxX.pack_start(labelX)
HboxX.pack_start(self.sbMaskX)
HboxY.pack_start(labelY)
HboxY.pack_start(self.sbMaskY)
HboxR.pack_start(labelR)
HboxR.pack_start(self.sbMaskR)
self.sbMaskX.set_value( float(self.cfg.get("MASK","maskX")) )
self.sbMaskY.set_value( float(self.cfg.get("MASK","maskY")) )
self.sbMaskR.set_value( float(self.cfg.get("MASK","maskR")) )
self.sbMaskX.connect("changed", self.KameraSettingChanged)
self.sbMaskY.connect("changed", self.KameraSettingChanged)
self.sbMaskR.connect("changed", self.KameraSettingChanged)
HboxMask.pack_start(HboxX)
HboxMask.pack_start(HboxY)
HboxMask.pack_start(HboxR)
tabMaska.attach(HboxMask,0,2,1,2)
frMaska.add(tabMaska)
kostra.pack_start(frMaska, False, False, 10)
labelHist = gtk.Label("Zobrazit Histogram:")
self.cbHist = gtk.combo_box_new_text()
self.cbHist.append_text("Vypnuto")
self.cbHist.append_text("In SJ - I")
self.cbHist.append_text("In SJ - II")
self.cbHist.append_text("In SJ - III")
self.cbHist.append_text("In SJ - IV")
self.cbHist.append_text("Vlastní okno")
self.cbHist.set_active( int(self.cfg.get("MASK","hist")) )
self.cbHist.connect("changed", self.KameraSettingChanged)
tabMaska.attach(labelHist,0,1,2,3)
tabMaska.attach(self.cbHist,1,2,2,3)
labelPlotFlare = gtk.Label("Vykreslení erupcí:")
self.cbPlotFlare = gtk.combo_box_new_text()
self.cbPlotFlare.append_text("Vypnuto")
self.cbPlotFlare.append_text("Red")
self.cbPlotFlare.append_text("Blue")
self.cbPlotFlare.append_text("In JS - III")
self.cbPlotFlare.append_text("In JS - IV")
self.cbPlotFlare.append_text("Vlastní okno")
self.cbPlotFlare.set_active( int(self.cfg.get("MASK","type")) )
self.cbHist.connect("changed", self.KameraSettingChanged)
tabMaska.attach(labelPlotFlare,0,1,4,5)
tabMaska.attach(self.cbPlotFlare,1,2,4,5)
scrollSet.add_with_viewport(kostra)
okno.show_all()
def __init__(self):
# paparazzi process
self.pp = None
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Paparazzi Configuration Chooser")
self.my_vbox = gtk.VBox()
# if PAPARAZZI_HOME not set, then assume the tree containing this
# file is a reasonable substitute
self.paparazzi_home = os.getenv(
"PAPARAZZI_HOME", os.path.dirname(os.path.abspath(__file__)))
self.conf_dir = os.path.join(self.paparazzi_home, "conf")
self.conf_xml = os.path.join(self.conf_dir, "conf.xml")
self.conf_personal_name = "conf_personal.xml"
self.conf_personal = os.path.join(self.conf_dir,
self.conf_personal_name)
self.controlpanel_xml = os.path.join(self.conf_dir,
"control_panel.xml")
self.controlpanel_personal_name = "control_panel_personal.xml"
self.controlpanel_personal = os.path.join(
self.conf_dir, self.controlpanel_personal_name)
self.exclude_backups = True
self.verbose = False
# MenuBar
mb = gtk.MenuBar()
# File
filemenu = gtk.Menu()
# File Title
filem = gtk.MenuItem("File")
filem.set_submenu(filemenu)
exitm = gtk.MenuItem("Exit")
exitm.connect("activate", gtk.main_quit)
filemenu.append(exitm)
mb.append(filem)
# Help
helpmenu = gtk.Menu()
# Help Title
helpm = gtk.MenuItem("Help")
helpm.set_submenu(helpmenu)
aboutm = gtk.MenuItem("About")
aboutm.connect("activate", self.about)
helpmenu.append(aboutm)
mb.append(helpm)
self.my_vbox.pack_start(mb, False)
# Combo Bar
self.conf_label = gtk.Label("Conf:")
self.conf_label.set_size_request(100, 30)
self.conf_file_combo = gtk.combo_box_new_text()
self.find_conf_files()
# self.firmwares_combo.connect("changed", self.parse_list_of_airframes)
self.conf_file_combo.set_size_request(550, 30)
self.btnDeleteConf = gtk.Button(None, gtk.STOCK_DELETE)
self.btnDeleteConf.connect("clicked", self.delete_conf)
self.btnDeleteConf.set_tooltip_text("Permanently Delete Conf")
self.btnPersonalConf = gtk.Button(None, gtk.STOCK_COPY)
self.btnPersonalConf.connect("clicked", self.personal_conf)
self.btnPersonalConf.set_tooltip_text(
"Create Personal Conf Based on Selected and Activate")
self.confbar = gtk.HBox()
self.confbar.pack_start(self.conf_label)
self.confbar.pack_start(self.conf_file_combo)
self.confbar.pack_start(self.btnDeleteConf)
self.confbar.pack_start(self.btnPersonalConf)
self.my_vbox.pack_start(self.confbar, False)
# Explain current conf config
self.conf_explain = gtk.Label("")
self.update_conf_label()
self.conf_explain.set_size_request(0, 45)
self.cfexbar = gtk.HBox()
self.cfexbar.pack_start(self.conf_explain)
self.my_vbox.pack_start(self.cfexbar, False)
# Controlpanel
self.controlpanel_label = gtk.Label("Controlpanel:")
self.controlpanel_label.set_size_request(100, 30)
self.controlpanel_file_combo = gtk.combo_box_new_text()
self.find_controlpanel_files()
self.controlpanel_file_combo.set_size_request(550, 30)
# window
self.btnDeleteControl = gtk.Button(None, gtk.STOCK_DELETE)
self.btnDeleteControl.connect("clicked", self.delete_controlpanel)
self.btnDeleteControl.set_tooltip_text("Permanently Delete")
self.btnPersonalControl = gtk.Button(None, gtk.STOCK_COPY)
self.btnPersonalControl.connect("clicked", self.personal_controlpanel)
self.btnPersonalControl.set_tooltip_text(
"Create Personal Controlpanel Based on Selected and Activate")
self.controlpanelbar = gtk.HBox(False)
self.controlpanelbar.pack_start(self.controlpanel_label)
self.controlpanelbar.pack_start(self.controlpanel_file_combo)
self.controlpanelbar.pack_start(self.btnDeleteControl)
self.controlpanelbar.pack_start(self.btnPersonalControl)
self.my_vbox.pack_start(self.controlpanelbar, False)
# Explain current controlpanel config
self.controlpanel_explain = gtk.Label("")
self.update_controlpanel_label()
self.controlpanel_explain.set_size_request(0, 45)
self.ctexbar = gtk.HBox()
self.ctexbar.pack_start(self.controlpanel_explain)
self.my_vbox.pack_start(self.ctexbar, False)
# show backups button
self.btnBackups = gtk.CheckButton("show backups")
self.btnBackups.connect("toggled", self.set_backups)
self.my_vbox.pack_start(self.btnBackups, False)
# show gui button
self.btnPythonGUI = gtk.CheckButton("new python center (beta)")
self.my_vbox.pack_start(self.btnPythonGUI, False)
# Buttons
self.btnAccept = gtk.Button("Set Active")
self.btnAccept.connect("clicked", self.accept)
self.btnAccept.set_tooltip_text(
"Set selected Conf/Control_Panel as Active")
self.btnLaunch = gtk.Button(
"Launch Paparazzi with selected configuration")
self.btnLaunch.connect("clicked", self.launch)
self.btnLaunch.set_tooltip_text(
"Launch Paparazzi with current conf.xml and control_panel.xml")
self.btnExit = gtk.Button("Exit")
self.btnExit.connect("clicked", gtk.main_quit)
self.btnExit.set_tooltip_text("Close application")
self.toolbar = gtk.HBox()
self.toolbar.set_size_request(0, 60)
self.toolbar.pack_start(self.btnLaunch)
self.toolbar.pack_start(self.btnAccept)
self.toolbar.pack_start(self.btnExit)
self.my_vbox.pack_start(self.toolbar, False)
# status bar
self.statusbar = gtk.Statusbar()
self.context_id = self.statusbar.get_context_id("info")
#self.statusbar.push(self.context_id, "Waiting for you to do something...")
self.my_vbox.pack_end(self.statusbar, False)
# Bottom
self.window.add(self.my_vbox)
self.window.show_all()
self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.window.connect("destroy", gtk.main_quit)
def build_handset(self):
self.arrow_stepval = 1.0
widgets = {}
# Place arrow buttons
off_xv = 220
off_yh = 150
btns = widgets.setdefault('buttons', {})
for x, y, name, axis, mult in (
(off_xv, off_yh - 140, 'up3', 0, 10),
(off_xv, off_yh - 100, 'up2', 0, 3),
(off_xv, off_yh - 60, 'up1', 0, 1),
(off_xv - 170, off_yh, 'left3', 1, 10),
(off_xv - 130, off_yh, 'left2', 1, 3),
(off_xv - 90, off_yh, 'left1', 1, 1),
(off_xv + 80, off_yh, 'right1', 1, -1),
(off_xv + 120, off_yh, 'right2', 1, -3),
(off_xv + 160, off_yh, 'right3', 1, -10),
(off_xv, off_yh + 60, 'down1', 0, -1),
(off_xv, off_yh + 100, 'down2', 0, -3),
(off_xv, off_yh + 140, 'down3', 0, -10),
):
btn = self._make_button(name)
btn.connect("clicked", self.arrowMove, axis, mult)
btns[name] = btn
self.lw.put(btn, x, y)
# Place entries
ents = widgets.setdefault('entries', {})
for x, y, width, name in ((off_xv - 35, off_yh + 5, 10, 'mainstep'), ):
ent = gtk.Entry()
ent.set_alignment(1.0)
ent.set_text("0")
ent.set_width_chars(width)
ent.show()
ents[name] = ent
self.lw.put(ent, x, y)
# Place spin buttons
for x, y, name in ((20, 250, 'lspin'), (120, 250, 'rspin')):
ent = gtk.SpinButton()
ent.show()
ent.set_alignment(1.0)
ent.set_update_policy(gtk.UPDATE_ALWAYS)
# this seems to force size
ent.set_range(-1000, 1000)
ents[name] = ent
self.lw.put(ent, x, y)
# Place labels
lbls = widgets.setdefault('labels', {})
for x, y, txt, name in ((off_xv + 45, 210 + 5, 'x1',
'x1'), (off_xv + 45, 250 + 5, 'x3',
'x3'), (off_xv + 45, 290 + 5, 'x10',
'x10'), (off_xv, off_yh - 18,
'Step', 'mainstep'),
(off_xv - 5, off_yh + 35, 'arcsec',
'mainunit'), (20, 30, 'Mode', 'mode'),
(20, 232, '+N/-S',
'lstep'), (120, 232, '+E/-W', 'rstep'),
(20, 275, 'arcsec', 'lstepunit'),
(120, 275, 'arcsec', 'rstepunit')):
lbl = gtk.Label(txt)
lbl.show()
lbls[name] = lbl
self.lw.put(lbl, x, y)
# Compass
lbl = self._make_compass('N', 'S', 'E', 'W')
lbls['compass'] = lbl
self.lw.put(lbl, off_xv + 80, off_yh - 120)
# Place buttons
btns = widgets['buttons']
btn = gtk.Button('Move')
#btn.set_size(10, -1)
btn.connect("clicked", self.execute)
btn.show()
btns['move'] = btn
self.lw.put(btn, 20, 300)
# Mode drop-down
cbox = gtk.combo_box_new_text()
cbox.show()
cbox.connect("changed", self.changeMode)
btns['mode'] = cbox
self.lw.put(cbox, 20, 50)
self.widgets = widgets
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
def __init__(self, logger):
self.logger = logger
self.drawcolors = ['white', 'black', 'red', 'yellow', 'blue', 'green']
self.select = FileSelection.FileSelection()
root = gtk.Window(gtk.WINDOW_TOPLEVEL)
root.set_title("FitsImageCanvas Example")
root.set_border_width(2)
root.connect("delete_event", lambda w, e: quit(w))
self.root = root
vbox = gtk.VBox(spacing=2)
fi = FitsImageCanvas(logger)
fi.enable_autocuts('on')
fi.enable_zoom('on')
fi.enable_cuts(True)
fi.enable_flip(True)
fi.enable_rotate(True)
fi.enable_draw(True)
fi.set_drawtype('ruler')
fi.set_drawcolor('blue')
fi.set_callback('drag-drop', self.drop_file)
fi.set_callback('motion', self.motion)
fi.set_bg(0.2, 0.2, 0.2)
fi.ui_setActive(True)
self.fitsimage = fi
w = fi.get_widget()
w.set_size_request(512, 512)
vbox.pack_start(w, fill=True, expand=True)
self.readout = gtk.Label("")
vbox.pack_start(self.readout, fill=True, expand=False)
hbox = gtk.HBox(spacing=5)
wdrawtype = gtk.combo_box_new_text()
self.drawtypes = fi.get_drawtypes()
index = 0
for name in self.drawtypes:
wdrawtype.insert_text(index, name)
index += 1
index = self.drawtypes.index('ruler')
wdrawtype.set_active(index)
wdrawtype.connect('changed', self.set_drawparams)
self.wdrawtype = wdrawtype
wdrawcolor = gtk.combo_box_new_text()
index = 0
for name in self.drawcolors:
wdrawcolor.insert_text(index, name)
index += 1
index = self.drawcolors.index('blue')
wdrawcolor.set_active(index)
wdrawcolor.connect('changed', self.set_drawparams)
self.wdrawcolor = wdrawcolor
wclear = gtk.Button("Clear Canvas")
wclear.connect('clicked', self.clear_canvas)
wopen = gtk.Button("Open File")
wopen.connect('clicked', self.open_file)
wquit = gtk.Button("Quit")
wquit.connect('clicked', quit)
for w in (wquit, wclear, wdrawcolor, wdrawtype, wopen):
hbox.pack_end(w, fill=False, expand=False)
vbox.pack_start(hbox, fill=False, expand=False)
root.add(vbox)
def init_main(self):
""""""
vbox = gtk.VBox()
frame = gtk.Frame()
frame.set_label_widget(gtk.image_new_from_file(media.ICON_LANGUAGE))
frame.set_border_width(5)
vbox.pack_start(frame, False, False)
hbox = gtk.HBox()
vbox1 = gtk.VBox()
frame.add(vbox1)
hbox = gtk.HBox()
vbox1.pack_start(hbox, False, False, 5)
label = gtk.Label(_("Choose language: "))
hbox.pack_start(label, False, False, 10)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
self.language = gtk.combo_box_new_text()
for lang in [lang[0] for lang in LANGUAGES]:
self.language.append_text(lang)
self.language.set_active([lang[1] for lang in LANGUAGES
].index(self.config.get_languaje()))
hbox.pack_start(self.language, False, False, 10)
frame = gtk.Frame()
frame.set_label_widget(gtk.image_new_from_file(media.ICON_NETWORK))
frame.set_border_width(5)
vbox.pack_start(frame, False, False)
vbox1 = gtk.VBox()
frame.add(vbox1)
hbox = gtk.HBox()
label = gtk.Label(_("Max simultaneous downloads: "))
hbox.pack_start(label, False, False, 10)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
self.max_downloads = gtk.SpinButton(None, 1, 0)
self.max_downloads.set_range(1, 20)
self.max_downloads.set_increments(1, 0)
self.max_downloads.set_numeric(True)
self.max_downloads.set_value(self.config.get_max_downloads())
hbox.pack_start(self.max_downloads, False, False, 10)
vbox1.pack_start(hbox, False, False, 2)
hbox = gtk.HBox()
label = gtk.Label(_("Max download speed: "))
hbox.pack_start(label, False, False, 10)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
self.max_download_speed = gtk.SpinButton(None, 4, 0)
self.max_download_speed.set_range(0, 5000)
self.max_download_speed.set_increments(4, 0)
self.max_download_speed.set_numeric(True)
self.max_download_speed.set_value(self.config.get_max_download_speed())
hbox.pack_start(self.max_download_speed, False, False, 10)
vbox1.pack_start(hbox, False, False, 2)
#hbox = gtk.HBox()
#label = gtk.Label(_("Max simultaneous uploads: "))
#hbox.pack_start(label, False, False, 10)
#aspect = gtk.AspectFrame()
#aspect.set_shadow_type(gtk.SHADOW_NONE)
#hbox.pack_start(aspect)
#self.max_uploads = gtk.SpinButton(None, 1, 0)
#self.max_uploads.set_range(1,10)
#self.max_uploads.set_increments(1,0)
#self.max_uploads.set_numeric(True)
#self.max_uploads.set_value(self.config.get_max_uploads())
#hbox.pack_start(self.max_uploads, False, False, 10)
#vbox1.pack_start(hbox, False, False, 2)
frame = gtk.Frame()
frame.set_label_widget(gtk.image_new_from_file(media.ICON_FOLDER))
frame.set_border_width(5)
vbox.pack_start(frame, False, False)
vbox1 = gtk.VBox()
frame.add(vbox1)
hbox = gtk.HBox()
vbox1.pack_start(hbox, False, False, 5)
label = gtk.Label(_("Downloads Folder: "))
hbox.pack_start(label, False, False, 10)
path = self.config.get_downloads_folder()
self.downloads_folder = gtk.Label(path)
self.downloads_folder.set_width_chars(30)
self.downloads_folder.set_alignment(0, 0.5)
self.downloads_folder.set_ellipsize(pango.ELLIPSIZE_START)
hbox.pack_start(self.downloads_folder, False, False, 10)
bbox = gtk.HButtonBox()
bbox.set_layout(gtk.BUTTONBOX_END)
hbox.pack_start(bbox, True, True, 10)
button = gtk.Button(None, gtk.STOCK_OPEN)
button.connect("clicked", self.choose_path)
bbox.pack_start(button)
vbox.show_all()
return vbox
def create_visual_elements(self):
self.set_size_request(600, 400)
label = gtk.Label()
label.set_alignment(0.0, 0.5)
markup = "<span font_desc='12'>The image to be written into usb drive:</span>"
label.set_markup(markup)
self.vbox.pack_start(label, expand=False, fill=False, padding=2)
table = gtk.Table(2, 10, False)
table.set_col_spacings(5)
table.set_row_spacings(5)
self.vbox.pack_start(table, expand=True, fill=True)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroll.set_shadow_type(gtk.SHADOW_IN)
tv = gtk.TextView()
tv.set_editable(False)
tv.set_wrap_mode(gtk.WRAP_WORD)
tv.set_cursor_visible(False)
self.buf = gtk.TextBuffer()
self.buf.set_text(self.image_path)
tv.set_buffer(self.buf)
scroll.add(tv)
table.attach(scroll, 0, 10, 0, 1)
# There are 2 ways to use DeployImageDialog
# One way is that called by HOB when the 'Deploy Image' button is clicked
# The other way is that called by a standalone script.
# Following block of codes handles the latter way. It adds a 'Select Image' button and
# emit a signal when the button is clicked.
if self.standalone:
gobject.signal_new("select_image_clicked", self, gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE, ())
icon = gtk.Image()
pix_buffer = gtk.gdk.pixbuf_new_from_file(hic.ICON_IMAGES_DISPLAY_FILE)
icon.set_from_pixbuf(pix_buffer)
button = gtk.Button("Select Image")
button.set_image(icon)
#button.set_size_request(140, 50)
table.attach(button, 9, 10, 1, 2, gtk.FILL, 0, 0, 0)
button.connect("clicked", self.select_image_button_clicked_cb)
separator = gtk.HSeparator()
self.vbox.pack_start(separator, expand=False, fill=False, padding=10)
self.usb_desc = gtk.Label()
self.usb_desc.set_alignment(0.0, 0.5)
markup = "<span font_desc='12'>You haven't chosen any USB drive.</span>"
self.usb_desc.set_markup(markup)
self.usb_combo = gtk.combo_box_new_text()
self.usb_combo.connect("changed", self.usb_combo_changed_cb)
model = self.usb_combo.get_model()
model.clear()
self.usb_combo.append_text(self.__dummy_usb__)
for usb in self.find_all_usb_devices():
self.usb_combo.append_text("/dev/" + usb)
self.usb_combo.set_active(0)
self.vbox.pack_start(self.usb_combo, expand=False, fill=False)
self.vbox.pack_start(self.usb_desc, expand=False, fill=False, padding=2)
self.progress_bar = HobProgressBar()
self.vbox.pack_start(self.progress_bar, expand=False, fill=False)
separator = gtk.HSeparator()
self.vbox.pack_start(separator, expand=False, fill=True, padding=10)
self.vbox.show_all()
self.progress_bar.hide()
def __init__(self):
# Create a new window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
# Set the window title
self.window.set_title("CurrencyConverter")
# Set a handler for delete_event that immediately
# exits GTK.
self.window.connect("delete_event", self.delete_event)
slist = ["HR Kuna", "Euro", "US Dollar", "Swiss Franc"]
# Create a 2x2 table
table = gtk.Table(5, 3, True)
# Put the table in the main window
self.window.add(table)
# Create first button
button1 = gtk.Button("Convert")
#choose a currency from 2 combo box
combo1 = gtk.combo_box_new_text()
combo1.append_text(slist[0])
combo1.append_text(slist[1])
combo1.append_text(slist[2])
combo1.append_text(slist[3])
#combo1.set_active(0)
combo1.connect("changed", self.combo_selected1)
combo2 = gtk.combo_box_new_text()
combo2.append_text(slist[0])
combo2.append_text(slist[1])
combo2.append_text(slist[2])
combo2.append_text(slist[3])
#combo2.set_active(0)
combo2.connect("changed", self.combo_selected2)
label1 = gtk.Label("Currency I Have")
label2 = gtk.Label("Currency I Want")
label3 = gtk.Label("Amount")
label4 = gtk.Label("Converted")
datelabel = gtk.Label(x.date)
datelabel.modify_font(pango.FontDescription("sans 16"))
menu_bar = gtk.MenuBar()
file_menu = gtk.Menu()
help_menu = gtk.Menu()
help_item = gtk.MenuItem("Help")
about_item = gtk.MenuItem("About")
quit_item = gtk.MenuItem("Quit")
file_menu.append(quit_item)
help_menu.append(about_item)
file_item = gtk.MenuItem("File")
help_item = gtk.MenuItem("Help")
file_item.set_submenu(file_menu)
menu_bar.append(file_item)
help_item.set_submenu(help_menu)
menu_bar.append(help_item)
entry1 = gtk.Entry(max=10)
entry2 = gtk.Entry(max=10)
combo1.connect("changed", self.combo_entry, entry1)
button1.connect("clicked", self.callback, entry2)
table.attach(button1, 1, 2, 3, 4, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(combo1, 0, 1, 2, 3, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(combo2, 2, 3, 2, 3, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(label1, 0, 1, 1, 2, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(label2, 2, 3, 1, 2, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(label3, 0, 1, 3, 4, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(label4, 2, 3, 3, 4, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(datelabel, 1, 2, 1, 2, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(entry1, 0, 1, 4, 5, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(entry2, 2, 3, 4, 5, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 10, 5)
table.attach(menu_bar, 0, 3, 0, 1, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
table.set_row_spacings(15)
table.set_col_spacings(10)
quit_item.connect("activate", gtk.main_quit)
about_item.connect("activate", self.response, None)
entry1.connect("key-release-event", self.entry_data)
button1.show()
combo1.show()
combo2.show()
quit_item.show()
help_item.show()
file_item.show()
about_item.show()
menu_bar.show()
label1.show()
label2.show()
label3.show()
label4.show()
datelabel.show()
entry1.show()
entry2.show()
table.show()
self.window.show()
def __init__(self):
# color systems
self.__colorSystems = ["YIQ", "RGB", "HSV"]
self.__activeColorSystem = self.__colorSystems[0]
## main window
spacing = 5
self.window = gtk.Window()
self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.window.set_default_size(*windowSize)
self.window.set_title("colorname")
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.window.set_border_width(1)
pixbuf = self.window.render_icon(gtk.STOCK_SELECT_COLOR,
gtk.ICON_SIZE_DIALOG)
self.window.set_icon(pixbuf)
## main boxes
mainBox = gtk.VBox(spacing=spacing)
self.window.add(mainBox)
## misc
self.colorSelect = gtk.ColorSelection()
mainBox.pack_start(self.colorSelect, expand=False)
listsBox = gtk.VPaned()
listsBox.set_position(150)
mainBox.pack_start(listsBox, expand=True)
## colors
colorFrame = gtk.Frame(label="Colors")
listsBox.pack1(colorFrame, shrink=False)
colorBox = gtk.VBox(spacing=spacing)
colorFrame.add(colorBox)
self.colorModel = gtk.ListStore(gobject.TYPE_BOOLEAN,
gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
colorView = gtk.TreeView(self.colorModel)
# columns
toggleRend = gtk.CellRendererToggle()
toggleRend.set_property('activatable', True)
toggleRend.connect("toggled", self.__colorlistCheckboxHandler,
self.colorModel)
toggleCol = gtk.TreeViewColumn("", toggleRend)
toggleCol.add_attribute(toggleRend, "active", 0)
colorView.append_column(toggleCol)
colorView.append_column(
gtk.TreeViewColumn("Colorlist", gtk.CellRendererText(), text=1))
# create scrollbars around the view.
colorScrolledListView = gtk.ScrolledWindow()
colorScrolledListView.set_property("hscrollbar_policy",
gtk.POLICY_NEVER)
colorScrolledListView.add(colorView)
colorBox.pack_start(colorScrolledListView)
## results
resultFrame = gtk.Frame(label="Results")
listsBox.pack2(resultFrame, shrink=0)
self.resultModel = gtk.ListStore(gobject.TYPE_FLOAT,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_UINT)
self.__resultView = gtk.TreeView(self.resultModel)
self.__resultView.set_search_column(1)
resultRend = gtk.CellRendererText()
# color
colNr = 1
colorCell = gtk.CellRendererPixbuf()
colorNameCol = gtk.TreeViewColumn("Color")
colorNameCol.pack_start(colorCell, False)
colorNameCol.pack_start(resultRend, True)
colorNameCol.set_sort_column_id(colNr)
colorNameCol.set_cell_data_func(colorCell, self.__renderColorPixbuf)
colorNameCol.set_attributes(resultRend, text=colNr)
self.__resultView.append_column(colorNameCol)
# source
colNr = 2
sourceCol = gtk.TreeViewColumn("Source", resultRend, text=colNr)
sourceCol.set_sort_column_id(colNr)
sourceCol.set_min_width(-1)
self.__resultView.append_column(sourceCol)
# distance
colNr = 0
distCol = gtk.TreeViewColumn("Distance", resultRend, text=colNr)
distCol.set_sort_column_id(colNr)
distCol.set_sort_order(gtk.SORT_ASCENDING)
self.__resultView.append_column(distCol)
self.__resultView.connect("button_press_event", self.__resultsPopup)
# create scrollbars around the view.
resultScrolledListView = gtk.ScrolledWindow()
resultScrolledListView.set_property("hscrollbar_policy",
gtk.POLICY_NEVER)
resultScrolledListView.add(self.__resultView)
resultFrame.add(resultScrolledListView)
## button box
buttonBox = gtk.HBox(spacing=spacing)
execButton = gtk.Button(stock=gtk.STOCK_EXECUTE)
execButton.connect("clicked", self.execute)
buttonBox.pack_start(execButton, fill=False, expand=False)
selCombobox = gtk.combo_box_new_text()
map(selCombobox.append_text, self.__colorSystems)
selCombobox.set_active(0)
buttonBox.pack_start(selCombobox, fill=False, expand=False)
selCombobox.connect("changed", self.__comboboxChangedHandler)
closeButton = gtk.Button(stock=gtk.STOCK_CLOSE)
closeButton.connect_object("clicked", gtk.Widget.destroy, self.window)
buttonBox.pack_end(closeButton, fill=False, expand=False)
aboutButton = gtk.Button("A_bout")
aboutButton.connect("clicked", self.__showAbout)
buttonBox.pack_end(aboutButton, fill=False, expand=False)
mainBox.pack_start(buttonBox, fill=False, expand=False)
##
self.window.show_all()
def tab_page(self):
vvbox1 = gtk.VBox(False, 10)
vvbox1.set_border_width(3)
vvbox2 = gtk.VBox(False)
vvbox3 = gtk.VBox(False, 5) #######
vvbox2.set_border_width(3)
hhbox1 = gtk.HBox(False)
hhbox2 = gtk.HBox(False) #############
hhbox1.set_border_width(3)
tb1 = gtk.Table(2, 2, True)
###########Rc_Cell_Cell###################
button1 = gtk.Button(stock='gtk-go-up')
button2 = gtk.Button(stock='gtk-go-down')
label1 = gtk.Label(_('Columns'))
label1.modify_font(pango.FontDescription('bold'))
label1.set_justify(gtk.JUSTIFY_LEFT)
cel_sort = self.listen_cel()
cel_sort.renderer.connect('toggled', self.fixed_toggled,
cel_sort.model)
button1.connect('clicked', self.downup, cel_sort, True)
button2.connect('clicked', self.downup, cel_sort, False)
#############Rc_Cell_Appearance##########
label2 = gtk.Label(_('Appearance'))
label2.modify_font(pango.FontDescription('bold'))
#chkb1 = gtk.CheckButton()
#tb1.attach()
#########################################
vvbox2.pack_start(button1, True)
vvbox2.pack_start(button2, True)
vvbox1.pack_start(label1, False)
hhbox1.pack_start(cel_sort, True)
hhbox1.pack_start(vvbox2, False)
vvbox1.pack_start(hhbox1, False)
vvbox1.pack_start(label2, False)
tb1.attach(gtk.Label(_('Expand')), 0, 1, 0, 1)
tb1.attach(gtk.Label(_('Min size')), 1, 2, 0, 1)
tb1.attach(gtk.Label(_('Horizontal')), 2, 3, 0, 1)
tb1.attach(gtk.Label(_('Vertical')), 3, 4, 0, 1)
for i in xrange(len(edna_function.mc)):
cheak = gtk.CheckButton(None)
cheak.cl = '%s_expand' % edna_function.mc[i]
cheak.set_active(int(edna_function.rc_dict['style'][cheak.cl]))
cheak.connect('toggled', self.toggled)
sp2 = gtk.SpinButton(gtk.Adjustment(0, 0, 100, 1, -1))
sp2.cl = '%s_size' % edna_function.mc[i]
sp2.set_value(int(edna_function.rc_dict['style'][sp2.cl]))
sp2.connect('value_changed', self.spin)
chkH1 = gtk.combo_box_new_text()
for j in gfH:
chkH1.append_text(j)
chkH1.nm = '%s_alignment_h' % edna_function.mc[i]
chkH1.set_active(
gf.index(float(edna_function.rc_dict['style'][chkH1.nm])))
chkH1.connect('changed', self.chk_c)
chkV1 = gtk.combo_box_new_text()
for j in gfV:
chkV1.append_text(j)
chkV1.nm = '%s_alignment_v' % edna_function.mc[i]
chkV1.set_active(
gf.index(float(edna_function.rc_dict['style'][chkV1.nm])))
chkV1.connect('changed', self.chk_c)
tb1.attach(cheak, 0, 1, i + 1, i + 2)
tb1.attach(sp2, 1, 2, i + 1, i + 2)
tb1.attach(chkH1, 2, 3, i + 1, i + 2)
tb1.attach(chkV1, 3, 4, i + 1, i + 2)
lb = gtk.Label(_('Columns'))
vvbox3.pack_start(lb, True)
for i in xrange(len(edna_function.mc)):
lb = gtk.Label(edna_gui.Name_Colum[edna_function.mc[i]])
lb.set_alignment(0.0, 0.5)
vvbox3.pack_start(lb, True)
hhbox2.pack_start(vvbox3, True)
hhbox2.pack_start(tb1, False)
vvbox1.pack_start(hhbox2, False)
hbox2 = gtk.HBox(False, 10)
label1 = gtk.Label(_('Format of creation'))
label1.set_alignment(0.0, 0.5)
entry1 = gtk.Entry()
entry1.set_text(edna_function.rc_dict['style']['cell_datec_format'])
entry1.connect('changed', self.on_changed, 'cell_datec_format')
hbox2.pack_start(label1, True)
hbox2.pack_start(entry1, False)
hbox3 = gtk.HBox(False, 10)
label2 = gtk.Label(_('Format of change'))
label2.set_alignment(0.0, 0.5)
entry2 = gtk.Entry()
entry2.set_text(edna_function.rc_dict['style']['cell_datem_format'])
entry2.connect('changed', self.on_changed, 'cell_datem_format')
hbox3.pack_start(label2, True)
hbox3.pack_start(entry2, False)
hbox4 = gtk.HBox(False, 3)
chk1 = gtk.combo_box_new_text()
chk1.append_text(_('in the bytes'))
chk1.append_text(_('with a floating point Kb, Mb'))
chk1.append_text(_('with a floating point Kb, Mb, Gb'))
chk1.set_active(int(
edna_function.rc_dict['style']['cell_size_format']))
chk1.connect('changed', self.chk1_c)
label3 = gtk.Label(_('Size format'))
label3.set_alignment(0.0, 0.5)
hbox5 = gtk.HBox(False, 3)
chk2 = gtk.combo_box_new_text()
chk2.append_text(_('numerical'))
chk2.append_text(_('string'))
chk2.set_active(int(edna_function.rc_dict['style']['cell_atr_format']))
chk2.connect('changed', self.chk2_c)
label4 = gtk.Label(_('Attribute format'))
label4.set_alignment(0.0, 0.5)
hbox4.pack_start(label3, True)
hbox4.pack_start(chk1, False)
hbox5.pack_start(label4, True)
hbox5.pack_start(chk2, False)
vvbox1.pack_start(hbox2, False)
vvbox1.pack_start(hbox3, False)
vvbox1.pack_start(hbox4, False)
vvbox1.pack_start(hbox5, False)
self.note.append_page(vvbox1, gtk.Label(_('Table')))
def __init__(self, pkgs=[]):
self.window = gtk.Window()
self.window.set_default_size(500, 300)
self.window.show()
hbox = gtk.VPaned()
hbox.show()
self.graph = chart.LineChart()
self.graph.set_size_request(500, 200)
self.graph.connect('select', self.select)
hbox.pack1(self.graph, True)
self.graph.show()
vbox = gtk.VBox()
vbox.show()
# add distro stuff
h = gtk.HBox()
self.distro = gtk.combo_box_new_text()
self.distro.connect("changed", self.distro_changed)
h.add(self.distro)
self.branch = gtk.combo_box_new_text()
self.branch.connect("changed", self.branch_changed)
h.add(self.branch)
self.arch = gtk.combo_box_new_text()
h.add(self.arch)
self.color = gtk.ColorButton()
h.add(self.color)
self.add = gtk.Button(stock=gtk.STOCK_ADD)
self.add.connect("clicked", self.add_distro)
h.add(self.add)
h.show_all()
vbox.pack_start(h, False, False)
# package stuff
vbox2 = gtk.VBox()
vbox2.show()
self.pkg_store = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.packages = []
p_tv = gtk.TreeView(self.pkg_store)
#p_tv.set_fixed_height_mode(True)
p_tv.set_rules_hint(True)
p_tv.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
#p_tv.set_headers_visible(False)
renderer = gtk.CellRendererText()
p_tv.append_column(gtk.TreeViewColumn("Packages", renderer, markup=0))
p_tv.append_column(gtk.TreeViewColumn("Version", renderer, text=1))
p_tv.show()
sp = gtk.ScrolledWindow()
sp.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
sp.show()
sp.add(p_tv)
vbox2.pack_start(sp)
hbox2 = gtk.HBox()
hbox2.show()
hbox2.pack_start(vbox2, False, False)
self.distro_store = gtk.ListStore(str)
s = gtk.ScrolledWindow()
s.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
s.show()
s.set_vadjustment(sp.props.vadjustment)
self.distro_view = gtk.TreeView(self.distro_store)
#self.distro_view.set_fixed_height_mode(True)
self.distro_view.set_rules_hint(True)
self.distro.set_size_request(-1, -1)
self.distro_view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
#l.set_headers_visible(False)
self.distro_view.show()
s.add(self.distro_view)
hbox2.pack_start(s)
vbox.pack_start(hbox2)
# add package stuff
h = gtk.HBox()
self.pkg = gtk.Entry()
self.pkg.connect("activate", self.add_pkg_cb)
h.pack_start(self.pkg, False, False)
self.add = gtk.Button(stock=gtk.STOCK_ADD)
self.add.connect("clicked", self.add_pkg_cb)
h.pack_start(self.add, False, False)
h.show_all()
vbox.pack_start(h, False, False)
hbox.add(vbox)
self.window.add(hbox)
self.window.connect("destroy", lambda x: gtk.main_quit())
HOST, USER, PASSWORD, DB = helper.mysql_settings()
con = db.connect(host=HOST, user=USER, password=PASSWORD, database=DB)
self.distros = {}
cur = con.cursor()
cur.execute(
"SELECT DISTINCT distros.name, branches.branch, repos.architecture FROM distros, repos, branches WHERE distros.id = repos.distro_id AND repos.id = branches.repo_id;"
)
for name, branch, arch in cur:
if name not in self.distros:
self.distros[name] = {}
if branch not in self.distros[name]:
self.distros[name][branch] = []
if arch not in self.distros[name][branch]:
self.distros[name][branch].append(arch)
con.close()
for d in self.distros.keys():
self.distro.append_text(d)
self.current = datetime.now()
self._histories = []
for p in pkgs:
self.add_pkg(p)
def __init__(self, img, parent=None):
global config, exten
self.image = img.name
self.recycle = False
#print("Begin autosave_a with launching image: "+str(image))
# Create the window
win = gtk.Window.__init__(self)
#self.connect('destroy', lambda *w: gtk.main_quit())
self.connect('destroy', self.on_destroy)
self.set_title(_("Autosave_a Panel"))
# next block is for the window icon --------------------------------
icon_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), \
'autosave_a')
try:
self.set_icon_from_file(icon_dir + os.sep + 'autosave-icon.png')
except:
print("Autosave warning: did not find the icon file!")
# ------------------------------------------------------------------
self.set_focus_on_map(True)
self.set_border_width(8)
sup_vbox = gtk.VBox(False, 8)
self.add(sup_vbox)
label = gtk.Label(_(" Choose your parameters below and press 'Start';")\
+_("\nonly button active after 'Start' is 'Stop'. Then")\
+_("\nminimize (close=stop) the window until needed."))
# pack_start(child, expand=True, fill=True, padding=0)
sup_vbox.pack_start(label, False, False, 0)
##############################
## Directory ->
dir_frame = gtk.Frame(_("Directory"))
sup_vbox.pack_start(dir_frame, padding=5)
hbox = gtk.HBox(False, 4)
dir_frame.add(hbox)
# button to choose dir (to launch gtk.FileSelection)
button = gtk.Button(_("Change the"))
button.connect('clicked', self.on_choose_dir_clicked)
hbox.pack_start(button, False, False, 0)
# put the actual dir beside it
label = gtk.Label(_("backup dir.: "))
hbox.pack_start(label, False, False, 0)
self.label = gtk.Label('')
self.label.set_has_tooltip(True)
self.label.set_tooltip_text(_("The actual folder where the backup")\
+_("\nwill be"))
hbox.pack_start(self.label, False, False, 0)
##############################
## Files ->
file_frame = gtk.Frame(_("Files"))
sup_vbox.pack_start(file_frame, padding=5)
table = gtk.Table(2, 3)
table.set_row_spacings(4)
table.set_col_spacings(4)
file_frame.add(table)
# column headers
label = gtk.Label(_("image"))
label.set_has_tooltip(True)
label.set_tooltip_text(_("The source(s) of the backup file from:")\
+_("\nthe one to all"))
table.attach(label, 0, 1, 0, 1)
label = gtk.Label(_("extension"))
label.set_tooltip_text(_("To control the compression of 'xcf' file from:")\
+_("\nmore to less"))
table.attach(label, 1, 2, 0, 1)
label = gtk.Label(_("nr kept"))
label.set_has_tooltip(True)
label.set_tooltip_text(_("Number of backup kept for the same ")\
+_("\nsession and image ID"))
table.attach(label, 2, 3, 0, 1)
# autosave image source + extension: xcfbz2 or xcfgz
self.source = [_("Launching one"), _("All changed"), \
_("All open")]
self.combo1 = gtk.combo_box_new_text()
[self.combo1.append_text(x) for x in self.source]
self.combo1.connect("changed", self.on_all_changed)
table.attach(self.combo1, 0, 1, 1, 2)
exten = [".xcf.bz2", ".xcf.gz", ".xcf", ".png", ".jpg"]
self.combo = gtk.combo_box_new_text()
[self.combo.append_text(x) for x in exten]
self.combo.connect("changed", self.on_file_ext_change)
table.attach(self.combo, 1, 2, 1, 2)
# number of backup to keep of current image: 1 -> 9
self.interv = gtk.SpinButton(adjustment=None, climb_rate=1.0, digits=0)
self.interv.set_range(1, 9)
self.interv.set_increments(1, 1)
self.interv.set_numeric(True)
self.interv.connect('value-changed', self.on_nr_kept_change)
table.attach(self.interv, 2, 3, 1, 2)
##############################
## Time ->
time_frame = gtk.Frame(_("Time"))
sup_vbox.pack_start(time_frame, padding=5)
hbox = gtk.HBox(False, 4)
time_frame.add(hbox)
self.rbtn = gtk.CheckButton(_("At start? "))
self.rbtn.connect("toggled", self.on_toggled_check, None)
self.rbtn.set_has_tooltip(True)
self.rbtn.set_tooltip_text(_("If check: begins at the interval start,")\
+_("\nif not at the end."))
hbox.pack_start(self.rbtn, False, False, 0)
# put the header for time interval beside it
label = gtk.Label(_("Backup interval (min):"))
hbox.pack_start(label, False, False, 0)
# gtk.SpinButton(adjustment=None, climb_rate=0.0, digits=0)
self.interv1 = gtk.SpinButton(adjustment=None,
climb_rate=0.0,
digits=1)
self.interv1.set_range(1, 999)
self.interv1.set_increments(0.1, 5)
self.interv1.set_numeric(True)
self.interv1.connect('value-changed', self.on_time_interval_change)
hbox.pack_start(self.interv1, False, False, 0)
##############################
## Controls ->
hbox = gtk.HBox(False, 8)
sup_vbox.pack_start(hbox, False, False, 0)
# button to save current parameters now
self.choices = shelf.list_dict()
self.nr = 0 # number of save_config
for i in range(len(self.choices)):
if self.choices[i][:5] == 'recal': self.nr += 1
if self.nr == 5: self.recycle = True
self.button = gtk.Button(_("Save config ") + str(self.nr % 5))
self.button.set_has_tooltip(True)
self.button.set_tooltip_text(_("Will save all the above parameters on disk")\
+_("\nfor later usage with button 'Recall config'"))
self.button.connect('clicked', self.on_save_now_clicked)
hbox.pack_start(self.button, False, False, 0)
# place a remenber param. combobox
hbox2 = gtk.HBox()
#hbox2.set_border_width(10)
hbox.pack_start(hbox2)
self.combo_box = gtk.combo_box_new_text()
self.combo_box.set_wrap_width(1)
# new 'choices' list to unable lang. translation
self.choices_combo = [_("Default config")]
conf_act = 0
for i in range(len(self.choices)):
if i > 0:
if self.choices[i][:5] == 'lasts':
self.choices_combo.append(_("LastStop config"))
conf_act = i
else:
self.choices_combo.append(_("Recall config ")+\
self.choices[i][-1:])
self.combo_box.append_text(self.choices_combo[i])
self.combo_box.set_active(conf_act)
self.combo_box.set_has_tooltip(True)
self.combo_box.set_tooltip_text(
_("Choose from existing config presets"))
hbox2.pack_start(self.combo_box)
self.combo_box.connect("changed", self.choice_i_cb)
# icon to indicate state
self.stock_ic = gtk.Image()
self.stock_ic.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_BUTTON)
self.stock_ic.set_has_tooltip(True)
self.stock_ic.set_tooltip_text(_("Indicates if the widgets to the left")\
+_("\nand above are frozen or not"))
hbox.pack_start(self.stock_ic, False, False, 0)
hbox.pack_start(gtk.VSeparator(), expand=False)
# place a start-stop button
self.button1 = gtk.Button(_("Start"))
self.button1.connect('pressed', self.on_activate_clicked)
hbox.pack_start(self.button1, True, True, 3)
##############################
## Info during ->
info_frame = gtk.Frame(_("Info"))
sup_vbox.pack_start(info_frame, padding=5)
vbox = gtk.VBox(False, 0)
info_frame.add(vbox)
if self.recycle:
msgi = msgr
else:
msgi = msga
self.label1 = gtk.Label(msgi)
self.label1.set_alignment(0.1, 0.2)
vbox.pack_start(self.label1, False, False, 0)
self.show_all()
self.set_config()
timeout_add_seconds(1, self.timer_action)
def __init__(self, ip):
TITLE = "Nmap Scan Module"
nmap = getattr(config, 'NMAP_PATH')
self.profiles = getattr(config, 'NMAP_PROFILES')
self.ip = ip
# Dialog
self.dialog = gtk.Dialog(
title=TITLE,
parent=None,
buttons=(gtk.STOCK_HELP, gtk.RESPONSE_HELP, gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK))
self.dialog.resize(250, 75)
# Label
self.tglab = gtk.Label('Target:')
self.tglab.set_alignment(0.0, 0.5)
# A target text entry
self.tgentry = gtk.Entry(max=50)
self.tgentry.set_text(self.ip)
# Label
self.prolab = gtk.Label('Profile:')
self.prolab.set_alignment(0.0, 0.5)
# A ComboBox
self.combobox = gtk.combo_box_new_text()
for profile in self.profiles.keys():
self.combobox.append_text(profile)
self.combobox.connect('changed', self.changed_cb)
# Label
self.comlab = gtk.Label('Command:')
self.comlab.set_alignment(0.0, 0.5)
# A command text entry
self.comentry = gtk.Entry(max=200)
self.comentry.set_text('nmap -v -A ' + self.ip)
# Separator
self.sep = gtk.HSeparator()
# ProgressBar
self.progressbar = gtk.ProgressBar(adjustment=None)
#########################################################
# Table
table = gtk.Table(rows=5, columns=4, homogeneous=False)
table.set_row_spacings(2)
table.set_col_spacings(2)
# Add lements to Table
table.attach(self.tglab, 0, 1, 0, 1)
table.attach(self.tgentry, 1, 2, 0, 1)
table.attach(self.prolab, 2, 3, 0, 1)
table.attach(self.combobox, 3, 4, 0, 1)
table.attach(self.comlab, 0, 1, 1, 2)
table.attach(self.comentry, 1, 4, 1, 2)
table.attach(self.sep, 1, 3, 2, 3)
table.attach(self.progressbar, 0, 5, 3, 4)
# Add HBox to VBox
self.dialog.vbox.pack_start(table, False, False, 2)
#########################################################
# the help button
self.butt_help = self.dialog.action_area.get_children()[2]
self.butt_help.connect("clicked", lambda x: self.show_help())
# the cancel button
self.butt_cancel = self.dialog.action_area.get_children()[1]
self.butt_cancel.connect("clicked", lambda x: self.dialog.destroy())
# the save button
self.butt_save = self.dialog.action_area.get_children()[0]
self.butt_save.connect("clicked", self.validateData)
# Check nmap availability
if not os.path.exists(config.NMAP_PATH):
self.progressbar.set_text('Nmap not found on: ' + config.NMAP_PATH)
self.progressbar.set_fraction(1)
self.butt_save.set_sensitive(False)
# Finish
self.dialog.show_all()
self.dialog.show()
def __init__(self):
gtk.Window.__init__(self)
self.connect('destroy', self.destroy_cb)
self.config_window = None
self.live_hide_timeout = 0
self.light_hop_timeout = 0
self.busy = False
self.leds = ledmap.Ledmap(
os.path.join(source_dir, 'data', 'led-maps.txt'))
logging.debug('loaded %d maps', len(self.leds.get_names()))
for name in self.leds.get_names():
bytes = self.leds.get_bytes(name)
logging.debug('%s: %d lights', name, len(bytes))
# where project directories get written, see RTI cap above
self.outdir = options.outdir
self.lights = lights.Lights()
# try to reset the lights ... if this fails, disable dome controls
try:
self.dome_controls = True
name = self.leds.get_names()[0]
self.lights.set_triple(self.leds.get_bytes(name)[0])
except lights.Error as e:
logging.debug('no lights found, disabling dome controls')
self.dome_controls = False
self.vbox = gtk.VBox(False, 0)
self.add(self.vbox)
self.vbox.show()
fixed = gtk.Fixed()
self.vbox.pack_start(fixed, False)
fixed.show()
self.camera = camera.Camera()
self.preview = preview.Preview(self.camera)
fixed.put(self.preview, 0, 0)
self.preview.show()
self.preview.connect('motion_notify_event', self.preview_motion_cb)
if options.verbose:
try:
config = camera.Config(self.camera)
config.prettyprint(sys.stdout, config.get_root_widget())
except:
logging.debug("No Camera detected: unable to print config")
eb = gtk.EventBox()
fixed.put(eb, 0, 0)
eb.show()
self.progress = progress.Progress()
self.progress.set_size_request(preview_width, -1)
eb.add(self.progress)
eb = gtk.EventBox()
fixed.put(eb, 0, 0)
eb.show()
self.info = info.Info()
self.info.set_size_request(preview_width, -1)
eb.add(self.info)
eb = gtk.EventBox()
fixed.put(eb, 20, 380)
eb.show()
self.play_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY,
gtk.ICON_SIZE_SMALL_TOOLBAR)
self.pause_image = gtk.image_new_from_stock(
gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_SMALL_TOOLBAR)
self.live = gtk.Button()
self.live.set_image(self.play_image)
self.live.set_tooltip_text("Start/stop live preview")
self.live.connect('clicked', self.live_cb, None)
eb.add(self.live)
self.live.show()
self.toolbar = gtk.HBox(False, 5)
self.toolbar.set_border_width(3)
self.vbox.pack_end(self.toolbar)
self.toolbar.show()
button = gtk.Button()
quit_image = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_SMALL_TOOLBAR)
quit_image.show()
button.set_tooltip_text("Quit RTIAcquire")
button.connect('clicked', self.destroy_cb, None)
button.add(quit_image)
self.toolbar.pack_end(button, False, False)
button.show()
if self.dome_controls:
self.dome_picker = gtk.combo_box_new_text()
for name in self.leds.get_names():
self.dome_picker.append_text(name)
self.dome_picker.set_active(0)
self.dome_picker.set_tooltip_text("Select lighting system")
self.dome_picker.connect('changed', self.dome_picker_cb, None)
self.toolbar.pack_start(self.dome_picker, False, False)
self.dome_picker.show()
self.light_picker = gtk.SpinButton(climb_rate=1)
self.light_picker.set_numeric(True)
self.light_picker.set_wrap(True)
self.light_picker.set_increments(1, 1)
self.light_picker.set_tooltip_text("Pick light")
self.light_picker_refresh()
self.light_picker.connect('value_changed', self.light_picker_cb,
None)
self.toolbar.pack_start(self.light_picker, False, False)
self.light_picker.show()
button = gtk.Button()
menu_image = gtk.image_new_from_stock(gtk.STOCK_PREFERENCES,
gtk.ICON_SIZE_SMALL_TOOLBAR)
menu_image.show()
button.set_tooltip_text("Camera settings")
button.connect('clicked', self.config_cb, None)
button.add(menu_image)
self.toolbar.pack_start(button, False, False)
button.show()
button = gtk.Button('Focus')
button.set_tooltip_text("Focus camera automatically")
button.connect('clicked', self.focus_cb, None)
self.toolbar.pack_start(button, False, False)
button.show()
photo_image = gtk.image_new_from_file(
os.path.join(source_dir, 'data', 'camera_24.png'))
photo = gtk.Button()
photo.set_image(photo_image)
photo.set_tooltip_text("Take single photo")
photo.connect('clicked', self.photo_cb, None)
self.toolbar.pack_start(photo, False, False)
photo.show()
if self.dome_controls:
photo = gtk.Button('RTI Preview')
photo.set_tooltip_text("Take preview RTI image")
photo.connect('clicked', self.rti_preview_cb, None)
self.toolbar.pack_start(photo, False, False)
photo.show()
photo = gtk.Button('RTI Capture ...')
photo.set_tooltip_text("Start full RTI acquisition")
photo.connect('clicked', self.rti_capture_cb, None)
self.toolbar.pack_start(photo, False, False)
photo.show()
self.info.msg('Welcome to RTI Acquire', 'v1.3, March 2014')
self.show()
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 init(self):
# The user_id to work on
self.current_user_id = 0
self.user_list = []
# ---------------
# Log Management
# ---------------
# create tree model
self.log_model = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_INT,
gobject.TYPE_INT, gobject.TYPE_INT,
gobject.TYPE_STRING)
# Main box is vertical
top_box = gtk.VBox(False, 8)
top_box.show()
self.frame.add(top_box)
# First line label and combo
label_box = gtk.HBox(False, 8)
label_box.show()
top_box.pack_start(label_box, False, False, 0)
# Let the user select the class to work on
#
# Grab the class list and put it in a combo
class_box = gtk.HBox(False, 8)
class_box.show()
label_box.pack_start(class_box, False, False, 0)
user_label = gtk.Label(_('Select a user:'******'SELECT DISTINCT user_id FROM logs')
user_list = self.cur.fetchall()
self.combo_user = gtk.combo_box_new_text()
self.combo_user.show()
# Insert the ALL option (HACK, use the user_id -2 to indicate ALL)
self.combo_user.append_text(_("All users"))
self.user_list.append(-2)
for auser in user_list:
if (auser[0] == -1 or not auser[0]):
# This is the name of the Default user profile
self.combo_user.append_text(_("Default"))
self.user_list.append(-1)
continue
self.cur.execute(
'SELECT login, firstname, lastname FROM users WHERE user_id=?',
(auser[0], ))
oneuser = self.cur.fetchall()
self.combo_user.append_text(
(oneuser[0][0] + ' ' + oneuser[0][1] + ' ' + oneuser[0][2]))
# Save in a list the combo index => the user_id
self.user_list.append(auser[0])
self.combo_user.set_active(self.current_user_id)
label_box.pack_end(self.combo_user, True, True, 0)
# update the combobox
self.combo_user.connect('changed', self.user_changed_cb)
# Second line logs and button
log_hbox = gtk.HBox(False, 8)
log_hbox.show()
top_box.add(log_hbox)
loglist_box = gtk.VBox(False, 8)
loglist_box.show()
log_hbox.add(loglist_box)
vbox_button = gtk.VBox(False, 8)
vbox_button.show()
log_hbox.add(vbox_button)
# Create the table
sw = gtk.ScrolledWindow()
sw.show()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
# create tree view
treeview_log = gtk.TreeView(self.log_model)
treeview_log.show()
treeview_log.set_rules_hint(True)
treeview_log.set_search_column(COLUMN_DATE)
sw.add(treeview_log)
loglist_box.pack_start(sw, True, True, 0)
# add columns to the tree view
self.__add_columns_log(treeview_log)
# Reset buttons
self.button_remove = gtk.Button(_('Reset'))
self.button_remove.connect("clicked", self.on_remove_log_clicked,
treeview_log)
vbox_button.pack_start(self.button_remove, False, False, 0)
self.button_remove.show()
self.button_remove.set_sensitive(True)
# Refresh buttons
self.button_refresh = gtk.Button(stock='gtk-refresh')
self.button_refresh.connect("clicked", self.on_refresh_log_clicked)
vbox_button.pack_start(self.button_refresh, False, False, 0)
self.button_refresh.show()
self.button_refresh.set_sensitive(True)
# Load lists
self.user_changed_cb(self.combo_user)
self.reload_log()
def __init__(self, parent_diag, lista, part_act):
'''
Constructor
'''
gtk.Table.__init__(self, 6, 6)
self.lista = lista
self.part_act = part_act
self.parent_diag = parent_diag
#Tipo de partición
self.lbl1 = gtk.Label(_("Partition type:"))
self.lbl1.set_alignment(0, 0.5)
self.attach(self.lbl1, 0, 1, 0, 1)
self.lbl1.show()
self.cmb_tipo = gtk.combo_box_new_text()
if is_logic(self.part_act):
self.cmb_tipo.append_text(msj.particion.logica)
self.cmb_tipo.set_sensitive(False)
else:
self.cmb_tipo.append_text(msj.particion.primaria)
# Solo se permite una particion extendida en el disco
if not has_extended(self.lista):
self.cmb_tipo.append_text(msj.particion.extendida)
self.cmb_tipo.set_active(0)
self.attach(self.cmb_tipo, 1, 2, 0, 1)
self.cmb_tipo.connect("changed", self.cmb_tipo_on_changed)
self.cmb_tipo.show()
#Sistema de Archivos
self.lbl2 = gtk.Label(_("File system:"))
self.lbl2.set_alignment(0, 0.5)
self.attach(self.lbl2, 0, 1, 1, 2)
self.lbl2.show()
self.cmb_fs = gtk.combo_box_new_text()
self.cmb_fs_fill()
self.cmb_fs.connect("changed", self.cmb_fs_on_changed)
self.attach(self.cmb_fs, 1, 2, 1, 2)
self.cmb_fs.show()
# Punto de Montaje
self.lbl3 = gtk.Label(_("Mount point:"))
self.lbl3.set_alignment(0, 0.5)
self.lbl3.set_size_request(200, 30)
self.attach(self.lbl3, 0, 1, 2, 3)
self.lbl3.show()
self.cmb_montaje = gtk.combo_box_new_text()
self.cmb_montaje_fill()
self.attach(self.cmb_montaje, 1, 2, 2, 3)
self.cmb_montaje.connect("changed", self.cmb_montaje_on_changed)
self.cmb_montaje.show()
self.entrada = gtk.Entry()
self.entrada.set_text('/')
self.attach(self.entrada, 1, 2, 2, 3)
self.entrada.connect("changed", self.validate_m_point)
self.formatear = gtk.CheckButton(_("Format this partition"))
self.attach(self.formatear, 1, 2, 3, 4)
self.formatear.set_visible(is_usable(self.part_act))
self.formatear.connect("toggled", self.cmb_fs_on_changed)
self.formatear.show()
self.show()
def _launch_config_section_chooser_dialog(self,
name_section_dict,
prefs,
dialog_title,
config_title,
section_title,
null_section_choice=False):
chooser_dialog = gtk.Dialog(title=dialog_title,
parent=self.window,
buttons=(gtk.STOCK_CANCEL,
gtk.RESPONSE_REJECT, gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT))
config_label = gtk.Label(config_title)
config_label.show()
section_label = gtk.Label(section_title)
section_label.show()
config_name_box = gtk.combo_box_new_text()
name_keys = name_section_dict.keys()
name_keys.sort()
for k, name in enumerate(name_keys):
config_name_box.append_text(name)
if name in prefs:
config_name_box.set_active(k)
if config_name_box.get_active() == -1:
config_name_box.set_active(0)
config_name_box.show()
section_box = gtk.VBox()
section_box.show()
null_section_checkbutton = gtk.CheckButton(
rose.config_editor.DIALOG_LABEL_NULL_SECTION)
null_section_checkbutton.connect(
"toggled", lambda b: section_box.set_sensitive(not b.get_active()))
if null_section_choice:
null_section_checkbutton.show()
null_section_checkbutton.set_active(True)
index = config_name_box.get_active()
self._reload_section_choices(section_box,
name_section_dict[name_keys[index]],
prefs.get(name_keys[index], []))
config_name_box.connect(
'changed', lambda c: self._reload_section_choices(
section_box, name_section_dict[name_keys[c.get_active()]],
prefs.get(name_keys[c.get_active()], [])))
vbox = gtk.VBox(spacing=rose.config_editor.SPACING_PAGE)
vbox.pack_start(config_label, expand=False, fill=False)
vbox.pack_start(config_name_box, expand=False, fill=False)
vbox.pack_start(section_label, expand=False, fill=False)
vbox.pack_start(null_section_checkbutton, expand=False, fill=False)
vbox.pack_start(section_box, expand=False, fill=False)
vbox.show()
hbox = gtk.HBox()
hbox.pack_start(vbox,
expand=True,
fill=True,
padding=rose.config_editor.SPACING_PAGE)
hbox.show()
chooser_dialog.vbox.pack_start(hbox,
padding=rose.config_editor.SPACING_PAGE)
section_box.grab_focus()
response = chooser_dialog.run()
if response in [
gtk.RESPONSE_OK, gtk.RESPONSE_YES, gtk.RESPONSE_ACCEPT
]:
config_name_entered = name_keys[config_name_box.get_active()]
if null_section_checkbutton.get_active():
chooser_dialog.destroy()
return config_name_entered, None
for widget in section_box.get_children():
if hasattr(widget, 'get_active'):
index = widget.get_active()
sections = name_section_dict[config_name_entered]
section_name = sections[index]
chooser_dialog.destroy()
return config_name_entered, section_name
chooser_dialog.destroy()
return None, None
def __init__(
self,
username=None,
password=None,
authlevel=None,
levels_mapping=None,
parent=None,
):
if username:
super(AccountDialog, self).__init__(
_('Edit Account'),
_('Edit existing account'),
gtk.STOCK_DIALOG_INFO,
(
gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL,
gtk.STOCK_APPLY,
gtk.RESPONSE_OK,
),
parent,
)
else:
super(AccountDialog, self).__init__(
_('New Account'),
_('Create a new account'),
gtk.STOCK_DIALOG_INFO,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_ADD, gtk.RESPONSE_OK),
parent,
)
self.levels_mapping = levels_mapping
table = gtk.Table(2, 3, False)
self.username_label = gtk.Label()
self.username_label.set_markup('<b>' + _('Username:'******'</b>')
self.username_label.set_alignment(1.0, 0.5)
self.username_label.set_padding(5, 5)
self.username_entry = gtk.Entry()
table.attach(self.username_label, 0, 1, 0, 1)
table.attach(self.username_entry, 1, 2, 0, 1)
self.authlevel_label = gtk.Label()
self.authlevel_label.set_markup('<b>' + _('Authentication Level:') + '</b>')
self.authlevel_label.set_alignment(1.0, 0.5)
self.authlevel_label.set_padding(5, 5)
# combo_box_new_text is deprecated but no other pygtk alternative.
self.authlevel_combo = gtk.combo_box_new_text()
active_idx = None
for idx, level in enumerate(levels_mapping):
self.authlevel_combo.append_text(level)
if authlevel and authlevel == level:
active_idx = idx
elif not authlevel and level == 'DEFAULT':
active_idx = idx
if active_idx is not None:
self.authlevel_combo.set_active(active_idx)
table.attach(self.authlevel_label, 0, 1, 1, 2)
table.attach(self.authlevel_combo, 1, 2, 1, 2)
self.password_label = gtk.Label()
self.password_label.set_markup('<b>' + _('Password:'******'</b>')
self.password_label.set_alignment(1.0, 0.5)
self.password_label.set_padding(5, 5)
self.password_entry = gtk.Entry()
self.password_entry.set_visibility(False)
table.attach(self.password_label, 0, 1, 2, 3)
table.attach(self.password_entry, 1, 2, 2, 3)
self.vbox.pack_start(table, False, False, padding=5)
if username:
self.username_entry.set_text(username)
self.username_entry.set_editable(False)
else:
self.set_focus(self.username_entry)
if password:
self.password_entry.set_text(username)
self.show_all()
