def __init__(self, gui):
SetupWindow.__init__(self)
self.set_title(_("Nanotube"))
vbox = gtk.VBox()
# Intoductory text
self.packtext(vbox, introtext)
# Choose the element and bond length
label1 = gtk.Label(_("Element: "))
#label.set_alignment(0.0, 0.2)
self.element = gtk.Entry(max=3)
self.element.set_text("C")
self.element.connect('activate', self.makeatoms)
self.bondlength = gtk.Adjustment(1.42, 0.0, 1000.0, 0.01)
label2 = gtk.Label(_(" Bond length: "))
label3 = gtk.Label(_(u"Å"))
bond_box = gtk.SpinButton(self.bondlength, 10.0, 3)
pack(vbox, [label1, self.element, label2, bond_box, label3])
self.elementinfo = gtk.Label("")
self.elementinfo.modify_fg(gtk.STATE_NORMAL,
gtk.gdk.color_parse('#FF0000'))
pack(vbox, [self.elementinfo])
pack(vbox, gtk.Label(""))
# Choose the structure.
pack(vbox,
[gtk.Label(_("Select roll-up vector (n,m) "
"and tube length:"))])
label1 = gtk.Label("n: ")
label2 = gtk.Label(" m: ")
self.n = gtk.Adjustment(5, 1, 100, 1)
self.m = gtk.Adjustment(5, 0, 100, 1)
spinn = gtk.SpinButton(self.n, 0, 0)
spinm = gtk.SpinButton(self.m, 0, 0)
label3 = gtk.Label(_(" Length: "))
self.length = gtk.Adjustment(1, 1, 100, 1)
spinl = gtk.SpinButton(self.length, 0, 0)
pack(vbox, [label1, spinn, label2, spinm, label3, spinl])
self.err = gtk.Label("")
self.err.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#FF0000'))
pack(vbox, [self.err])
pack(vbox, gtk.Label(""))
self.status = gtk.Label("")
pack(vbox, [self.status])
pack(vbox, [gtk.Label("")])
# Buttons
self.pybut = PyButton(_("Creating a nanoparticle."))
self.pybut.connect('clicked', self.makeatoms)
buts = cancel_apply_ok(cancel=lambda widget: self.destroy(),
apply=self.apply,
ok=self.ok)
pack(vbox, [self.pybut, buts], end=True, bottom=True)
# Finalize setup
self.makeatoms()
self.bondlength.connect('value-changed', self.makeatoms)
self.m.connect('value-changed', self.makeatoms)
self.n.connect('value-changed', self.makeatoms)
self.length.connect('value-changed', self.makeatoms)
self.add(vbox)
vbox.show()
self.show()
self.gui = gui
def do_circle(self, fWizard, tmpDir):
self.tmpDir = tmpDir
self.fWizard = fWizard
self.sRadius = 0.0
self.hSpeed = 100
self.W = gtk.Dialog('Circle',
None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
buttons=None)
self.W.set_keep_above(True)
self.W.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.W.set_default_size(250, 200)
t = gtk.Table(1, 1, True)
t.set_row_spacings(6)
self.W.vbox.add(t)
cutLabel = gtk.Label('Cut Type')
cutLabel.set_alignment(0.95, 0.5)
cutLabel.set_width_chars(10)
t.attach(cutLabel, 0, 1, 0, 1)
self.outside = gtk.RadioButton(None, 'Outside')
self.outside.connect('toggled', self.outside_toggled)
t.attach(self.outside, 1, 2, 0, 1)
inside = gtk.RadioButton(self.outside, 'Inside')
t.attach(inside, 2, 3, 0, 1)
offsetLabel = gtk.Label('Offset')
offsetLabel.set_alignment(0.95, 0.5)
offsetLabel.set_width_chars(10)
t.attach(offsetLabel, 3, 4, 0, 1)
self.offset = gtk.CheckButton('Kerf Width')
t.attach(self.offset, 4, 5, 0, 1)
lLabel = gtk.Label('Lead In')
lLabel.set_alignment(0.95, 0.5)
lLabel.set_width_chars(10)
t.attach(lLabel, 0, 1, 1, 2)
self.liEntry = gtk.Entry()
self.liEntry.set_width_chars(10)
t.attach(self.liEntry, 1, 2, 1, 2)
loLabel = gtk.Label('Lead Out')
loLabel.set_alignment(0.95, 0.5)
loLabel.set_width_chars(10)
t.attach(loLabel, 0, 1, 2, 3)
self.loEntry = gtk.Entry()
self.loEntry.set_width_chars(10)
t.attach(self.loEntry, 1, 2, 2, 3)
xSLabel = gtk.Label('X start')
xSLabel.set_alignment(0.95, 0.5)
xSLabel.set_width_chars(10)
t.attach(xSLabel, 0, 1, 3, 4)
self.xSEntry = gtk.Entry()
self.xSEntry.set_width_chars(10)
t.attach(self.xSEntry, 1, 2, 3, 4)
ySLabel = gtk.Label('Y start')
ySLabel.set_alignment(0.95, 0.5)
ySLabel.set_width_chars(10)
t.attach(ySLabel, 0, 1, 4, 5)
self.ySEntry = gtk.Entry()
self.ySEntry.set_width_chars(10)
t.attach(self.ySEntry, 1, 2, 4, 5)
self.centre = gtk.RadioButton(None, 'Centre')
t.attach(self.centre, 1, 2, 5, 6)
self.bLeft = gtk.RadioButton(self.centre, 'Bottom Left')
t.attach(self.bLeft, 0, 1, 5, 6)
dLabel = gtk.Label('Diameter')
dLabel.set_alignment(0.95, 0.5)
dLabel.set_width_chars(10)
t.attach(dLabel, 0, 1, 6, 7)
self.dEntry = gtk.Entry()
self.dEntry.set_width_chars(10)
self.dEntry.connect('changed', self.diameter_changed)
t.attach(self.dEntry, 1, 2, 6, 7)
ocDesc = gtk.Label('Over Cut')
ocDesc.set_alignment(0.95, 0.5)
ocDesc.set_width_chars(10)
t.attach(ocDesc, 0, 1, 7, 8)
self.overcut = gtk.CheckButton('')
self.overcut.connect('toggled', self.overcut_toggled)
self.overcut.set_sensitive(False)
t.attach(self.overcut, 1, 2, 7, 8)
ocLabel = gtk.Label('OC Length')
ocLabel.set_alignment(0.95, 0.5)
ocLabel.set_width_chars(10)
t.attach(ocLabel, 0, 1, 8, 9)
self.ocEntry = gtk.Entry()
self.ocEntry.set_width_chars(10)
self.ocEntry.set_sensitive(False)
self.ocEntry.connect('changed', self.ocentry_changed)
t.attach(self.ocEntry, 1, 2, 8, 9)
preview = gtk.Button('Preview')
preview.connect('pressed', self.send_preview)
t.attach(preview, 0, 1, 9, 10)
self.add = gtk.Button('Add')
self.add.set_sensitive(False)
self.add.connect('pressed', self.add_shape_to_file)
t.attach(self.add, 2, 3, 9, 10)
end = gtk.Button('Return')
end.connect('pressed', self.end_this_shape)
t.attach(end, 4, 5, 9, 10)
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
filename='./wizards/images/circle.png', width=240, height=240)
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
t.attach(image, 2, 5, 1, 9)
self.xSEntry.grab_focus()
self.W.show_all()
if os.path.exists(self.configFile):
f_in = open(self.configFile, 'r')
for line in f_in:
if line.startswith('preamble'):
self.preamble = line.strip().split('=')[1]
elif line.startswith('postamble'):
self.postamble = line.strip().split('=')[1]
elif line.startswith('origin'):
if line.strip().split('=')[1] == 'True':
self.centre.set_active(1)
else:
self.bLeft.set_active(1)
elif line.startswith('lead-in'):
self.liEntry.set_text(line.strip().split('=')[1])
elif line.startswith('lead-out'):
self.loEntry.set_text(line.strip().split('=')[1])
elif line.startswith('hole-diameter'):
self.sRadius = float(line.strip().split('=')[1]) / 2
elif line.startswith('hole-speed'):
self.hSpeed = float(line.strip().split('=')[1])
response = self.W.run()
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 __init__(self):
self._window = gtk.Window()
self._window.set_icon(getPixbuf("smart"))
self._window.set_title(_("New Mirror"))
self._window.set_modal(True)
self._window.set_position(gtk.WIN_POS_CENTER)
#self._window.set_geometry_hints(min_width=600, min_height=400)
def delete(widget, event):
gtk.main_quit()
return True
self._window.connect("delete-event", delete)
vbox = gtk.VBox()
vbox.set_border_width(10)
vbox.set_spacing(10)
vbox.show()
self._window.add(vbox)
table = gtk.Table()
table.set_row_spacings(10)
table.set_col_spacings(10)
table.show()
vbox.pack_start(table)
label = gtk.Label(_("Origin URL:"))
label.set_alignment(1.0, 0.5)
label.show()
table.attach(label, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
self._origin = gtk.Entry()
self._origin.set_width_chars(40)
self._origin.show()
table.attach(self._origin, 1, 2, 0, 1, gtk.EXPAND | gtk.FILL, gtk.FILL)
label = gtk.Label(_("Mirror URL:"))
label.set_alignment(1.0, 0.5)
label.show()
table.attach(label, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
self._mirror = gtk.Entry()
self._mirror.set_width_chars(40)
self._mirror.show()
table.attach(self._mirror, 1, 2, 1, 2, gtk.EXPAND | gtk.FILL, gtk.FILL)
sep = gtk.HSeparator()
sep.show()
vbox.pack_start(sep, expand=False)
bbox = gtk.HButtonBox()
bbox.set_spacing(10)
bbox.set_layout(gtk.BUTTONBOX_END)
bbox.show()
vbox.pack_start(bbox, expand=False)
self._okbutton = gtk.Button(stock="gtk-ok")
self._okbutton.show()
def clicked(x):
self._result = True
gtk.main_quit()
self._okbutton.connect("clicked", clicked)
bbox.pack_start(self._okbutton)
self._cancelbutton = gtk.Button(stock="gtk-cancel")
self._cancelbutton.show()
self._cancelbutton.connect("clicked", lambda x: gtk.main_quit())
bbox.pack_start(self._cancelbutton)
def __init__(self, controller):
GLIScreen.GLIScreen.__init__(self, controller)
self.has_systempkgs = GLIUtility.is_file("/usr/livecd/systempkgs.txt")
vert = gtk.VBox(False, 0)
vert.set_border_width(10)
content_str = """Here, you will select which stage you would like to start your install from.
Each option has a brief description beside it.
"""
content_label = gtk.Label(content_str)
vert.pack_start(content_label, expand=False, fill=False, padding=0)
self.radio_stages[1] = gtk.RadioButton(None, "Stage 1")
self.radio_stages[1].set_name("1")
self.radio_stages[1].connect("toggled", self.stage_selected, "1")
self.radio_stages[1].set_size_request(100, -1)
hbox = gtk.HBox(False, 0)
hbox.pack_start(self.radio_stages[1], expand=False, fill=False, padding=5)
tmplabel = gtk.Label("The entire system will be compiled from scratch with your CHOST and CFLAGS settings")
tmplabel.set_line_wrap(True)
hbox.pack_start(tmplabel, expand=False, fill=False, padding=20)
vert.pack_start(hbox, expand=False, fill=False, padding=10)
self.radio_stages[2] = gtk.RadioButton(self.radio_stages[1], "Stage 2")
self.radio_stages[2].set_name("2")
self.radio_stages[2].connect("toggled", self.stage_selected, "2")
self.radio_stages[2].set_size_request(100, -1)
hbox = gtk.HBox(False, 0)
hbox.pack_start(self.radio_stages[2], expand=False, fill=False, padding=5)
tmplabel = gtk.Label("Most of the system will be compiled with your CHOST and CFLAGS settings. Don't use this option unless you have a good reason")
tmplabel.set_line_wrap(True)
hbox.pack_start(tmplabel, expand=False, fill=False, padding=20)
vert.pack_start(hbox, expand=False, fill=False, padding=10)
self.radio_stages[3] = gtk.RadioButton(self.radio_stages[1], "Stage 3")
self.radio_stages[3].set_name("3")
self.radio_stages[3].connect("toggled", self.stage_selected, "3")
self.radio_stages[3].set_size_request(100, -1)
hbox = gtk.HBox(False, 0)
hbox.pack_start(self.radio_stages[3], expand=False, fill=False, padding=5)
tmplabel = gtk.Label("The base system will be installed using precompiled packages. You can recompile later with your custom settings if you choose. This is the fastest option")
tmplabel.set_line_wrap(True)
hbox.pack_start(tmplabel, expand=False, fill=False, padding=20)
vert.pack_start(hbox, expand=False, fill=False, padding=10)
self.check_grp = gtk.CheckButton("GRP Install")
self.check_grp.set_sensitive(False)
self.check_grp.set_size_request(100, -1)
hbox = gtk.HBox(False, 0)
hbox.pack_start(self.check_grp, expand=False, fill=False, padding=5)
tmplabel = gtk.Label("Any extra packages installed (beyond the stage3) will be installed using binaries from the LiveCD that you are installing from")
tmplabel.set_line_wrap(True)
hbox.pack_start(tmplabel, expand=False, fill=False, padding=20)
vert.pack_start(hbox, expand=False, fill=False, padding=10)
self.check_dynamic = gtk.CheckButton("Dynamic")
self.check_dynamic.set_sensitive(False)
self.check_dynamic.connect("toggled", self.dynamic_checked)
self.check_dynamic.set_size_request(100, -1)
if not self.has_systempkgs:
self.check_dynamic.set_sensitive(False)
hbox = gtk.HBox(False, 0)
hbox.pack_start(self.check_dynamic, expand=False, fill=False, padding=5)
tmplabel = gtk.Label("The stage3 will be generated from the packages on the LiveCD")
tmplabel.set_line_wrap(True)
hbox.pack_start(tmplabel, expand=False, fill=False, padding=20)
vert.pack_start(hbox, expand=False, fill=False, padding=10)
hbox = gtk.HBox(False, 0)
hbox.pack_start(gtk.Label("Stage tarball URI:"), expand=False, fill=False, padding=5)
self.entry_stage_tarball_uri = gtk.Entry()
self.entry_stage_tarball_uri.set_width_chars(50)
hbox.pack_start(self.entry_stage_tarball_uri, expand=False, fill=False, padding=10)
self.browse_uri = gtk.Button(" ... ")
self.browse_uri.connect("clicked", self.browse_uri_clicked)
hbox.pack_start(self.browse_uri, expand=False, fill=False, padding=5)
vert.pack_end(hbox, expand=False, fill=False, padding=0)
self.add_content(vert)
def __init__(self):
"""Create window, callbacks, ..."""
# create window
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.win.set_title("StuStaNet Druckservice")
self.win.set_border_width(5)
# create central vbox
self.vbox = gtk.VBox(homogeneous=False, spacing=0)
# logo
frm = gtk.Frame()
logo = gtk.Image()
logo.set_from_file(LOGO)
logo.show()
frm.add(logo)
frm.show()
self.vbox.pack_start(frm)
# ensure proper end of application
self.win.connect('delete_event', lambda w, e: gtk.main_quit())
self.win.connect('destroy', self.quit)
# uploaded files
frm = gtk.Frame(label=" Hochgeladene Dateien ")
self.upl_hbox = gtk.HBox(homogeneous=False, spacing=0)
self.upl_hbox.set_border_width(5)
lbl = gtk.Label("PIN: ")
lbl.show()
self.upl_hbox.pack_start(lbl, fill=False, expand=False)
self.pin_input = gtk.Entry()
self.pin_input.show()
self.upl_hbox.pack_start(self.pin_input)
self.upl_button = gtk.Button("Laden")
self.upl_button.connect('clicked', self.load_uploaded, None)
self.upl_button.show()
self.upl_hbox.pack_start(self.upl_button, padding=5, fill=False, expand=False)
self.upl_hbox.show()
frm.add(self.upl_hbox)
frm.show()
self.vbox.pack_start(frm)
# file chooser button
frm = gtk.Frame(label=' Dateien von USB-Stick oder Festplatte ')
hbox = gtk.HBox(homogeneous=False, spacing=0)
hbox.set_border_width(5)
self.open_filter = gtk.FileFilter()
self.open_filter.add_pattern('*.pdf')
self.open_filter.set_name('PDF Dateien')
self.chooser_dialog = gtk.FileChooserDialog(
action=gtk.FILE_CHOOSER_ACTION_OPEN,
title='Datei drucken',
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)
)
self.chooser_dialog.set_local_only(True)
self.chooser_dialog.set_select_multiple(False)
self.chooser_dialog.set_filter(self.open_filter)
self.open_button = gtk.FileChooserButton(self.chooser_dialog)
self.open_button.set_width_chars(30)
self.open_button.connect('file-set', self.file_selected, None)
self.open_button.show()
lbl = gtk.Label('Datei öffnen: ')
lbl.show()
hbox.pack_start(lbl, expand=False, fill=False)
hbox.pack_start(self.open_button)
hbox.show()
frm.add(hbox)
frm.show()
self.vbox.pack_start(frm)
# duplex and b/w checkboxes
frm = gtk.Frame(" Druckeinstellungen ")
vbox = gtk.VBox(homogeneous=False, spacing=0)
self.bw_checkbox = gtk.CheckButton(label="Schwarz / Weiss")
self.bw_checkbox.show()
self.simplex_radio = gtk.RadioButton(None, "Einseitig")
self.simplex_radio.show()
self.simplex_radio.connect('toggled', self.checkbox_changed, None)
#self.simplex_radio.set_active(True)
self.long_edge_radio = gtk.RadioButton(self.simplex_radio, "Doppelseitig (lange Seite)")
self.long_edge_radio.show()
self.long_edge_radio.connect('toggled', self.checkbox_changed, None)
self.short_edge_radio = gtk.RadioButton(self.simplex_radio, "Doppelseitig (kurze Seite)")
self.short_edge_radio.show()
self.short_edge_radio.connect('toggled', self.checkbox_changed, None)
self.bw_checkbox.connect('toggled', self.checkbox_changed, None)
vbox.pack_start(self.simplex_radio)
vbox.pack_start(self.long_edge_radio)
vbox.pack_start(self.short_edge_radio)
vbox.pack_start(self.bw_checkbox)
vbox.show()
frm.add(vbox)
frm.show()
self.vbox.pack_start(frm)
# button
self.action_button = gtk.Button(
label="Berechnen"
)
self.action_button.child.set_use_markup(True)
self.action_button.connect('clicked', self.do_action, None)
self.action_button.show()
self.vbox.pack_start(self.action_button)
# add main hbox
self.win.add(self.vbox)
self.apply_state()
# show window
self.vbox.show()
self.win.show()
def __init__(self, *args, **kwargs):
gtk.Window.__init__(self, *args, **kwargs)
self.set_title('Spell check')
self.set_default_size(350, 200)
self._checker = None
self._numContext = 40
self.errors = None
# create accel group
accel_group = gtk.AccelGroup()
self.add_accel_group(accel_group)
# list of widgets to disable if there's no spell error left
self._conditional_widgets = []
conditional = self._conditional_widgets.append
# layout
mainbox = gtk.VBox(spacing=5)
hbox = gtk.HBox(spacing=5)
self.add(mainbox)
mainbox.pack_start(hbox, padding=5)
box1 = gtk.VBox(spacing=5)
hbox.pack_start(box1, padding=5)
conditional(box1)
# unrecognized word
text_view_lable = gtk.Label('Unrecognized word')
text_view_lable.set_justify(gtk.JUSTIFY_LEFT)
box1.pack_start(text_view_lable, False, False)
text_view = gtk.TextView()
text_view.set_wrap_mode(gtk.WRAP_WORD)
text_view.set_editable(False)
text_view.set_cursor_visible(False)
self.error_text = text_view.get_buffer()
text_buffer = text_view.get_buffer()
text_buffer.create_tag("fg_black", foreground="black")
text_buffer.create_tag("fg_red", foreground="red")
box1.pack_start(text_view)
# Change to
change_to_box = gtk.HBox()
box1.pack_start(change_to_box, False, False)
change_to_label = gtk.Label('Change to:')
self.replace_text = gtk.Entry()
text_view_lable.set_justify(gtk.JUSTIFY_LEFT)
change_to_box.pack_start(change_to_label, False, False)
change_to_box.pack_start(self.replace_text)
# scrolled window
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
box1.pack_start(sw)
self.suggestion_list_view = create_list_view('Suggestions')
self.suggestion_list_view.connect("button_press_event",
self._onButtonPress)
self.suggestion_list_view.connect("cursor-changed",
self._onSuggestionChanged)
sw.add(self.suggestion_list_view)
#---Buttons---#000000#FFFFFF----------------------------------------------------
button_box = gtk.VButtonBox()
hbox.pack_start(button_box, False, False)
# Ignore
button = gtk.Button("Ignore")
button.connect("clicked", self._onIgnore)
button.add_accelerator("activate", accel_group, gtk.keysyms.Return, 0,
gtk.ACCEL_VISIBLE)
button_box.pack_start(button)
conditional(button)
# Ignore all
button = gtk.Button("Ignore All")
button.connect("clicked", self._onIgnoreAll)
button_box.pack_start(button)
conditional(button)
# Replace
button = gtk.Button("Replace")
button.connect("clicked", self._onReplace)
button_box.pack_start(button)
conditional(button)
# Replace all
button = gtk.Button("Replace All")
button.connect("clicked", self._onReplaceAll)
button_box.pack_start(button)
conditional(button)
# Recheck button
button = gtk.Button("_Add")
button.connect("clicked", self._onAdd)
button_box.pack_start(button)
conditional(button)
# Close button
button = gtk.Button(stock=gtk.STOCK_CLOSE)
button.connect("clicked", self._onClose)
button.add_accelerator("activate", accel_group, gtk.keysyms.Escape, 0,
gtk.ACCEL_VISIBLE)
button_box.pack_end(button)
# dictionary label
self._dict_lable = gtk.Label('')
mainbox.pack_start(self._dict_lable, False, False, padding=5)
mainbox.show_all()
sys.path.insert(0, '..')
import clubBD.database
import clubBD.model
clubBD.database.start('../db.db')
model1 = generic_tree.Model(
clubBD.database.session.query(clubBD.model.Editor))
model2 = generic_tree.Model(
clubBD.database.session.query(clubBD.model.Serial))
w = gtk.Window()
b = gtk.VBox()
e1 = gtk.Entry()
e2 = gtk.Entry()
b.add(e1)
b.add(e2)
w.add(b)
def match_func_name(obj, key):
return obj.name.lower().startswith(key.lower())
def match_func_title(obj, key):
return obj.title.lower().startswith(key.lower())
def display_func_name(obj):
return obj.name
def add_toolbar_button_assistant():
def cb_close(assistant):
assi.destroy()
return False
def cb_name_entry_key_press(entry, event):
assi.set_page_complete(entry.get_parent(),
len(entry.get_text()) > 0)
def cb_func_entry_key_press(entry, event):
assi.set_page_complete(entry.get_parent(),
len(entry.get_text()) > 0)
def cb_entry_key_press(entry, event):
assi.set_page_complete(entry.get_parent(),
len(entry.get_text()) > 0)
def cb_apply(assistant):
name_str = name_entry.get_text()
func_str = func_entry.get_text()
save_qm = radiobutton_yes.get_active()
icon_iter = icon_combobox.get_active_iter()
icon = None
if (icon_iter):
icon, icon_stock, icon_filename = icon_model.get(
icon_iter, 0, 1, 2)
if (icon_stock):
icon = icon_stock
coot_toolbar_button(name_str, func_str, icon)
if (save_qm):
save_toolbar_to_init_file(name_str, func_str, icon)
assi = gtk.Assistant()
assi.set_title("Toolbutton Assistant")
assi.connect('delete_event', cb_close)
assi.connect('close', cb_close)
assi.connect('cancel', cb_close)
assi.connect('apply', cb_apply)
# Construct page 0 (enter the button name)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
vbox.show()
assi.append_page(vbox)
assi.set_page_title(vbox, 'Create a new Coot toolbutton')
assi.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
label = gtk.Label(
"Please enter the name for the new toolbutton...")
label.set_line_wrap(True)
label.show()
vbox.pack_start(label, True, True, 0)
name_entry = gtk.Entry()
name_entry.connect("key-press-event", cb_name_entry_key_press)
name_entry.show()
vbox.pack_end(name_entry)
# check if name exists!!!!
# Construct page 1 (enter the function)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
vbox.show()
assi.append_page(vbox)
assi.set_page_title(vbox, 'Set the function')
assi.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
label = gtk.Label(
"Please enter the python function... (e.g. refine_active_residue())"
)
label.set_line_wrap(True)
label.show()
vbox.pack_start(label, True, True, 0)
func_entry = gtk.Entry()
func_entry.connect("key-press-event", cb_func_entry_key_press)
func_entry.show()
vbox.pack_start(func_entry, True, True, 0)
# add advanced option? FIXME (for callable func and args!?)
#adv_button = gtk.Button("Advanced options...")
#adv_button.show()
#vbox.pack_start(adv_button, False, False, 0)
# Construct page 2 (save?)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
vbox.show()
assi.append_page(vbox)
assi.set_page_title(vbox, 'Save to preferences?')
assi.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
label = gtk.Label(
"Do you want to save the button in your preferences?")
label.set_line_wrap(True)
label.show()
vbox.pack_start(label, True, True, 0)
radiobutton_yes = gtk.RadioButton(None, "Yes")
radiobutton_no = gtk.RadioButton(radiobutton_yes, "No")
radiobutton_yes.set_active(True)
radiobutton_yes.show()
radiobutton_no.show()
vbox.pack_start(radiobutton_yes, True, True, 0)
vbox.pack_start(radiobutton_no, True, True, 0)
assi.set_page_complete(radiobutton_yes.get_parent(), True)
# Construct page 3 (select icon)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
vbox.show()
assi.append_page(vbox)
assi.set_page_title(vbox, 'Select an icon')
assi.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
label = gtk.Label("Please select an icon or leave as it is...")
label.set_line_wrap(True)
label.show()
vbox.pack_start(label, True, True, 0)
hbox = gtk.HBox(False, 5)
icon_model = make_icons_model()
icon_combobox = icon_selection_combobox(icon_model)
icon_combobox.show()
hbox.show()
hbox.pack_start(icon_combobox, True, False, 2)
vbox.pack_end(hbox)
assi.set_page_complete(label.get_parent(), True)
# Final page
# As this is the last page needs to be of page_type
# gtk.ASSISTANT_PAGE_CONFIRM or gtk.ASSISTANT_PAGE_SUMMARY
label = gtk.Label('Thanks for using the toolbutton assistent!')
label.set_line_wrap(True)
label.show()
assi.append_page(label)
assi.set_page_title(label, 'Finish')
assi.set_page_complete(label, True)
assi.set_page_type(label, gtk.ASSISTANT_PAGE_CONFIRM)
assi.show()
def __init__(self, df, si, file_location):
#Retrieve Dataframe and Size dictionary
self.df = df
self.si = si
self.showSize = 1
self.menu_items = (
("/_File", None, None, 0, "<Branch>"),
("/File/_Read HEX Signatures with IDs & Size(.csv)", "<control>O",
self.read_from_csv, 0, None),
("/File/_Read Text Signatures(.txt)", "<control>T",
self.read_from_text, 0, None),
("/File/_Save", "<control>S", self.save_signature, 0, None),
("/File/sep1", None, None, 0, "<Separator>"),
("/File/Quit", "<control>Q", self.destroy, 0, None),
("/_Display", None, None, 0, "<Branch>"),
("/Display/_Display Original Text Signatures", "<control>D",
self.display_original_text, 0, None),
("/_Generate", None, None, 0, "<Branch>"),
("/Generate/Generate Random Text Signatures", None,
self.generate_pattern, 0, None),
("/_Inject", None, None, 0, "<Branch>"),
("/_Inject/Choose a Stream(.txt)", None, self.inject, 0, None),
("/_View", None, None, 0, "<Branch>"),
("/_View/Stream View", None, self.stream_view, 0, None),
)
#Create new GTK Window instance
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", lambda w: gtk.main_quit())
self.window.set_title("Signature Utility | File: " +
str(file_location))
self.window.set_default_size(640, 480)
main_vbox = gtk.VBox(False, 1)
main_vbox.set_border_width(1)
#self.window.add(main_vbox)
main_vbox.show()
menubar = self.get_main_menu(self.window)
main_vbox.pack_start(menubar, False, True, 0)
menubar.show()
#Create partition for Data display
dataBox = gtk.VBox(spacing=30)
frame = gtk.Frame("Pattern Values")
#Create scrollable display
scrolledWin = gtk.ScrolledWindow()
scrolledWin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
#Create Table to display values
self.table = gtk.Table(rows=len(df) + 1, columns=5, homogeneous=False)
self.table.set_col_spacings(10)
title_bar = ['ID', 'Size', 'HEX', 'Enable', 'Index']
for i in range(5):
label = gtk.Label(title_bar[i])
label.modify_font(pango.FontDescription("Sans bold 15"))
self.table.attach(label, i, i + 1, 0, 1)
#Loop through table to display values
ctr = 0
self.button = [None] * 5
self.entry = [None] * 5
for i in range(5):
ctr = 0
for j in range(1, len(df) + 1):
if (i < 3):
label = gtk.Label(str(df[title_bar[i]][j - 1]))
label.modify_font(pango.FontDescription("Sans 10"))
#label.set_use_markup(gtk.TRUE)
#label.set_markup('<span size="20000">'+str(df[title_bar[i]][j-1])+'</span>')
label.set_alignment(0, 0)
self.table.attach(label, i, i + 1, j, j + 1)
elif (i == 3):
self.button[ctr] = gtk.CheckButton()
self.button[ctr].set_alignment(0, 0)
self.table.attach(self.button[ctr], i, i + 1, j, j + 1)
ctr = ctr + 1
else:
self.entry[ctr] = gtk.Entry()
self.entry[ctr].set_alignment(0)
self.entry[ctr].set_width_chars(3)
self.table.attach(self.entry[ctr], i, i + 1, j, j + 1)
ctr = ctr + 1
scrolledWin.add_with_viewport(self.table)
self.table.show()
frame.add(scrolledWin)
scrolledWin.show()
dataBox.pack_start(frame, expand=False, fill=True, padding=5)
dataBox.set_border_width(1)
#Create Partition for displaying size information
sizeBox = gtk.VBox()
frame = gtk.Frame("Size information")
sorted_size = sorted(self.si.items(), key=operator.itemgetter(0))
#Initialize table for size information
table2 = gtk.Table(rows=len(sorted_size) + 1,
columns=2,
homogeneous=False)
table2.attach(gtk.Label("Size"), 0, 1, 0, 1)
table2.attach(gtk.Label("Count"), 1, 2, 0, 1)
for i in range(2):
for j in range(1, len(sorted_size) + 1):
label = gtk.Label(str(sorted_size[j - 1][i]))
table2.attach(label, i, i + 1, j, j + 1)
frame.add(table2)
sizeBox.pack_start(frame, expand=False, fill=True, padding=0)
#Arrange all the elements legibly
self.window.add(main_vbox)
main_vbox.add(dataBox)
dataBox.add(sizeBox)
#sizeBox.add(buttonBox)
self.window.show_all()
#Verification utility
retVal, textVal = verify_size(self.si)
if (retVal):
self.message_display("Signatures have the following error(s):\n" +
textVal)
def __init__(self, viewertoolbox):
debug.mainthreadTest()
toolboxGUI.GfxToolbox.__init__(self, "Viewer", viewertoolbox)
mainbox = gtk.VBox()
self.gtk.add(mainbox)
infoframe = gtk.Frame("Position Information")
infoframe.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(infoframe, fill=0, expand=0)
infotable = gtk.Table(columns=3, rows=2)
infoframe.add(infotable)
pixellabel = gtk.Label("Pixel: ")
pixellabel.set_alignment(1.0, 0.5)
self.pixel_x = gtk.Entry()
gtklogger.setWidgetName(self.pixel_x, "PixelX")
self.pixel_x.set_size_request(ndigits * guitop.top().digitsize, -1)
self.pixel_x.set_editable(0)
self.pixel_y = gtk.Entry()
gtklogger.setWidgetName(self.pixel_y, "PixelY")
self.pixel_y.set_size_request(ndigits * guitop.top().digitsize, -1)
self.pixel_y.set_editable(0)
physicallabel = gtk.Label("Physical: ")
physicallabel.set_alignment(1.0, 0.5)
self.physical_x = gtk.Entry()
gtklogger.setWidgetName(self.physical_x, "PhysicalX")
self.physical_x.set_size_request(ndigits * guitop.top().digitsize, -1)
self.physical_x.set_editable(0)
self.physical_y = gtk.Entry()
gtklogger.setWidgetName(self.physical_y, "PhysicalY")
self.physical_y.set_size_request(ndigits * guitop.top().digitsize, -1)
self.physical_y.set_editable(0)
infotable.attach(pixellabel,
0,
1,
0,
1,
xpadding=5,
ypadding=2,
xoptions=0)
infotable.attach(self.pixel_x,
1,
2,
0,
1,
xpadding=1,
ypadding=2,
xoptions=gtk.FILL | gtk.EXPAND)
infotable.attach(self.pixel_y,
2,
3,
0,
1,
xpadding=1,
ypadding=2,
xoptions=gtk.FILL | gtk.EXPAND)
infotable.attach(physicallabel,
0,
1,
1,
2,
xpadding=5,
ypadding=2,
xoptions=0)
infotable.attach(self.physical_x,
1,
2,
1,
2,
xpadding=1,
ypadding=2,
xoptions=gtk.FILL | gtk.EXPAND)
infotable.attach(self.physical_y,
2,
3,
1,
2,
xpadding=1,
ypadding=2,
xoptions=gtk.FILL | gtk.EXPAND)
zoomframe = gtk.Frame("Zoom")
gtklogger.setWidgetName(zoomframe, "Zoom")
zoomframe.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(zoomframe, fill=0, expand=0)
zoombox = gtk.VBox()
zoomframe.add(zoombox)
buttonrow = gtk.HBox(homogeneous=1, spacing=2)
zoombox.pack_start(buttonrow, expand=0, fill=1, padding=2)
inbutton = gtkutils.StockButton(gtk.STOCK_ZOOM_IN, 'In')
buttonrow.pack_start(inbutton, expand=0, fill=1)
gtklogger.setWidgetName(inbutton, "In")
gtklogger.connect(inbutton, 'clicked', self.inCB)
outbutton = gtkutils.StockButton(gtk.STOCK_ZOOM_OUT, 'Out')
buttonrow.pack_start(outbutton, expand=0, fill=1)
gtklogger.setWidgetName(outbutton, "Out")
gtklogger.connect(outbutton, 'clicked', self.outCB)
fillbutton = gtkutils.StockButton(gtk.STOCK_ZOOM_FIT, 'Fill')
buttonrow.pack_start(fillbutton, expand=0, fill=1)
gtklogger.setWidgetName(fillbutton, "Fill")
gtklogger.connect(fillbutton, 'clicked', self.fillCB)
factorrow = gtk.HBox()
zoombox.pack_start(factorrow, expand=0, fill=0, padding=2)
factorrow.pack_start(gtk.Label("Zoom Factor: "), expand=0, fill=0)
self.zoomfactor = gtk.Entry()
self.zoomfactor.set_editable(1)
self.zoomfactor.set_size_request(ndigits * guitop.top().digitsize, -1)
gtklogger.setWidgetName(self.zoomfactor, "Factor")
self.zfactorsignal = gtklogger.connect_passive(self.zoomfactor,
"changed")
factorrow.pack_start(self.zoomfactor, expand=1, fill=1)
zoombox.pack_start(gtk.HSeparator(), fill=0, expand=0, padding=2)
label0 = gtk.Label("Shift+Click: Zoom in\nCtrl+Click: Zoom out")
label0.set_pattern(" _______\n ________\n")
label0.set_justify(gtk.JUSTIFY_LEFT)
zoombox.pack_start(label0, fill=0, expand=0, padding=2)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_end(align, expand=0, fill=0, padding=2)
canvas_info = gtkutils.StockButton(gtk.STOCK_DIALOG_INFO,
"Canvas Info")
gtklogger.setWidgetName(canvas_info, "Info")
gtklogger.connect(canvas_info, "clicked", self.canvas_infoCB)
tooltips.set_tooltip_text(
canvas_info, "Display canvas information in the message window.")
align.add(canvas_info)
self.currentZFactor = self.gfxwindow().zoomFactor()
switchboard.requestCallbackMain("zoom factor changed", self.zfactorCB)
# Make sure that the Zoom commands in the graphics windows
# Settings menu use an up-to-date zoom factor.
self.gfxwindow().menu.Settings.Zoom.In.add_gui_callback(
self.wrapMenuZoom)
self.gfxwindow().menu.Settings.Zoom.Out.add_gui_callback(
self.wrapMenuZoom)
def on_menuitem_activate(self, widget, email):
self.window = gtk.Window()
self.window.set_border_width(5)
self.window.set_title(_("Conversation log for %s") % email)
self.window.set_default_size(650,350)
self.window.set_position(gtk.WIN_POS_CENTER)
textview = gtk.TextView()
self.textBuffer = textview.get_buffer()
self.textBuffer.create_tag('highlight', background = 'yellow')
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.textview = HtmlTextView(self.controller, self.textBuffer, scroll)
self.textview.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.textview.set_left_margin(6)
self.textview.set_right_margin(6)
self.textview.set_editable(False)
self.textview.set_cursor_visible(False)
scroll.add(self.textview)
hbox = gtk.HBox(False, 5)
saveButton = gtk.Button(stock=gtk.STOCK_SAVE)
saveButton.connect("clicked", self.on_save_logs)
refreshButton = gtk.Button(stock=gtk.STOCK_REFRESH)
refreshButton.connect("clicked", self.on_refresh_log, email)
closeButton = gtk.Button(stock=gtk.STOCK_CLOSE)
closeButton.connect("clicked", lambda w: self.window.hide())
############ Search TreeView ###################
self.search_active = False
self.searchStore = gtk.ListStore(str, str, str, str)
self.searchTree = gtk.TreeView(self.searchStore)
self.searchTree.connect("row-activated", self.set_cursor)
self.searchTree.set_rules_hint(True)
cell = gtk.CellRendererText()
nameCol = gtk.TreeViewColumn(_("Date"), cell, text=0)
dateCol = gtk.TreeViewColumn(_("Time"), cell, text=1)
timeCol = gtk.TreeViewColumn(_("Name"), cell, text=2)
msgCol = gtk.TreeViewColumn(_("Message"), cell, text=3)
nameCol.set_resizable(True)
dateCol.set_resizable(True)
timeCol.set_resizable(True)
msgCol.set_resizable(True)
self.searchTree.append_column(nameCol)
self.searchTree.append_column(dateCol)
self.searchTree.append_column(timeCol)
self.searchTree.append_column(msgCol)
self.searchSw = gtk.ScrolledWindow()
self.searchSw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.searchSw.add(self.searchTree)
self.searchSw.set_size_request(100, 30)
##################################################
#search box
searchLabel = gtk.Label(_("Search:"))
self.searchBox = gtk.Entry()
self.searchBox.connect("key-press-event", self.enter_pressed)
hbox.pack_end(saveButton, False, False)
hbox.pack_end(refreshButton, False, False)
hbox.pack_end(closeButton, False, False)
hbox.pack_end(self.searchBox, False, False)
hbox.pack_end(searchLabel, False, False)
textRenderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_("Date"), textRenderer, markup=0)
self.datesListstore = gtk.ListStore(str)
self.datesTree = gtk.TreeView(self.datesListstore)
self.datesTree.connect("cursor-changed", self.on_dates_cursor_change)
self.datesTree.append_column(column)
self.datesTree.set_headers_visible(False)
datesScroll = gtk.ScrolledWindow()
datesScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
datesScroll.add_with_viewport(self.datesTree)
datesScroll.set_size_request(150, -1)
hPaned = gtk.HPaned()
hPaned.pack1(datesScroll)
hPaned.pack2(scroll)
vbox = gtk.VBox(spacing=5)
vbox.pack_start(hPaned)
vbox.pack_start(hbox, False, False)
vbox.pack_start(self.searchSw)
vbox.pack_start(gtk.Statusbar(), False, False)
self.datesStamps = {}
logsCant = len(self.fill_dates_tree(email))
if not logsCant > 0:
dialog.information(_("No logs were found for %s") % (email))
else:
self.window.add(vbox)
self.window.show_all()
self.searchSw.hide_all()
def __init__(self):
# GTK Stuffs
self.parent = common.get_toplevel_window()
self.dialog = gtk.Dialog(title=_('Login'), parent=self.parent,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.dialog.set_icon(TRYTON_ICON)
tooltips = common.Tooltips()
button_cancel = gtk.Button(_('_Cancel'), use_underline=True)
img_cancel = gtk.Image()
img_cancel.set_from_stock('gtk-cancel', gtk.ICON_SIZE_BUTTON)
button_cancel.set_image(img_cancel)
button_cancel.set_always_show_image(True)
tooltips.set_tip(button_cancel,
_('Cancel connection to the Tryton server'))
self.dialog.add_action_widget(button_cancel, gtk.RESPONSE_CANCEL)
self.button_connect = gtk.Button(_('C_onnect'), use_underline=True)
img_connect = gtk.Image()
img_connect.set_from_stock('tryton-connect', gtk.ICON_SIZE_BUTTON)
self.button_connect.set_image(img_connect)
self.button_connect.set_always_show_image(True)
self.button_connect.set_can_default(True)
tooltips.set_tip(self.button_connect, _('Connect the Tryton server'))
self.dialog.add_action_widget(self.button_connect, gtk.RESPONSE_OK)
self.dialog.set_default_response(gtk.RESPONSE_OK)
alignment = gtk.Alignment(yalign=0, yscale=0, xscale=1)
self.table_main = gtk.Table(3, 3, False)
self.table_main.set_border_width(0)
self.table_main.set_row_spacings(3)
self.table_main.set_col_spacings(3)
alignment.add(self.table_main)
self.dialog.vbox.pack_start(alignment, True, True, 0)
image = gtk.Image()
image.set_from_file(os.path.join(PIXMAPS_DIR, 'tryton.png'))
image.set_alignment(0.5, 1)
ebox = gtk.EventBox()
ebox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#1b2019"))
ebox.add(image)
self.table_main.attach(ebox, 0, 3, 0, 1, ypadding=2)
self.profile_store = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.combo_profile = gtk.ComboBox()
cell = gtk.CellRendererText()
self.combo_profile.pack_start(cell, True)
self.combo_profile.add_attribute(cell, 'text', 0)
self.combo_profile.add_attribute(cell, 'sensitive', 1)
self.combo_profile.set_model(self.profile_store)
self.combo_profile.connect('changed', self.profile_changed)
self.profile_label = gtk.Label(set_underline(_(u'Profile:')))
self.profile_label.set_use_underline(True)
self.profile_label.set_justify(gtk.JUSTIFY_RIGHT)
self.profile_label.set_alignment(1, 0.5)
self.profile_label.set_padding(3, 3)
self.profile_label.set_mnemonic_widget(self.combo_profile)
self.profile_button = gtk.Button(set_underline(_('Manage profiles')),
use_underline=True)
self.profile_button.connect('clicked', self.profile_manage)
self.table_main.attach(self.profile_label, 0, 1, 1, 2,
xoptions=gtk.FILL)
self.table_main.attach(self.combo_profile, 1, 2, 1, 2)
self.table_main.attach(self.profile_button, 2, 3, 1, 2,
xoptions=gtk.FILL)
image = gtk.Image()
image.set_from_stock('gtk-edit', gtk.ICON_SIZE_BUTTON)
self.profile_button.set_image(image)
self.profile_button.set_always_show_image(True)
self.expander = gtk.Expander()
self.expander.set_label(_('Host / Database information'))
self.expander.connect('notify::expanded', self.expand_hostspec)
self.table_main.attach(self.expander, 0, 3, 3, 4)
self.label_host = gtk.Label(set_underline(_('Host:')))
self.label_host.set_use_underline(True)
self.label_host.set_justify(gtk.JUSTIFY_RIGHT)
self.label_host.set_alignment(1, 0.5)
self.label_host.set_padding(3, 3)
self.entry_host = gtk.Entry()
self.entry_host.connect_after('focus-out-event',
self.clear_profile_combo)
self.entry_host.set_activates_default(True)
self.label_host.set_mnemonic_widget(self.entry_host)
self.table_main.attach(self.label_host, 0, 1, 4, 5, xoptions=gtk.FILL)
self.table_main.attach(self.entry_host, 1, 3, 4, 5)
self.label_database = gtk.Label(set_underline(_('Database:')))
self.label_database.set_use_underline(True)
self.label_database.set_justify(gtk.JUSTIFY_RIGHT)
self.label_database.set_alignment(1, 0.5)
self.label_database.set_padding(3, 3)
self.entry_database = gtk.Entry()
self.entry_database.connect_after('focus-out-event',
self.clear_profile_combo)
self.entry_database.set_activates_default(True)
self.label_database.set_mnemonic_widget(self.entry_database)
self.table_main.attach(self.label_database, 0, 1, 5, 6,
xoptions=gtk.FILL)
self.table_main.attach(self.entry_database, 1, 3, 5, 6)
self.entry_login = gtk.Entry()
self.entry_login.set_activates_default(True)
self.table_main.attach(self.entry_login, 1, 3, 6, 7)
label_username = gtk.Label(set_underline(_("User name:")))
label_username.set_use_underline(True)
label_username.set_alignment(1, 0.5)
label_username.set_padding(3, 3)
label_username.set_mnemonic_widget(self.entry_login)
self.table_main.attach(label_username, 0, 1, 6, 7, xoptions=gtk.FILL)
# Profile informations
self.profile_cfg = os.path.join(get_config_dir(), 'profiles.cfg')
self.profiles = ConfigParser.SafeConfigParser()
if not os.path.exists(self.profile_cfg):
short_version = '.'.join(__version__.split('.', 2)[:2])
name = 'demo%s.tryton.org' % short_version
self.profiles.add_section(name)
self.profiles.set(name, 'host', name)
self.profiles.set(name, 'database', 'demo%s' % short_version)
self.profiles.set(name, 'username', 'demo')
else:
self.profiles.read(self.profile_cfg)
for section in self.profiles.sections():
active = all(self.profiles.has_option(section, option)
for option in ('host', 'database'))
self.profile_store.append([section, active])
def __init__(self, parent, profile_store, profiles, callback):
self.profiles = profiles
self.current_database = None
self.old_profile, self.current_profile = None, None
self.db_cache = None
self.updating_db = False
# GTK Stuffs
self.parent = parent
self.dialog = gtk.Dialog(title=_(u'Profile Editor'), parent=parent,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
self.ok_button = self.dialog.add_button(gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT)
self.ok_button.set_always_show_image(True)
self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.dialog.set_icon(TRYTON_ICON)
hpaned = gtk.HPaned()
vbox_profiles = gtk.VBox(homogeneous=False, spacing=6)
self.cell = gtk.CellRendererText()
self.cell.set_property('editable', True)
self.cell.connect('editing-started', self.edit_started)
self.profile_tree = gtk.TreeView()
self.profile_tree.set_model(profile_store)
self.profile_tree.insert_column_with_attributes(-1, _(u'Profile'),
self.cell, text=0)
self.profile_tree.connect('cursor-changed', self.profile_selected)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(self.profile_tree)
self.add_button = gtk.Button(_(u'_Add'), use_underline=True)
self.add_button.connect('clicked', self.profile_create)
add_image = gtk.Image()
add_image.set_from_stock('gtk-add', gtk.ICON_SIZE_BUTTON)
self.add_button.set_image(add_image)
self.add_button.set_always_show_image(True)
self.remove_button = gtk.Button(_(u'_Remove'), use_underline=True)
self.remove_button.connect('clicked', self.profile_delete)
remove_image = gtk.Image()
remove_image.set_from_stock('gtk-remove', gtk.ICON_SIZE_BUTTON)
self.remove_button.set_image(remove_image)
self.remove_button.set_always_show_image(True)
vbox_profiles.pack_start(scroll, expand=True, fill=True)
vbox_profiles.pack_start(self.add_button, expand=False, fill=True)
vbox_profiles.pack_start(self.remove_button, expand=False, fill=True)
hpaned.add1(vbox_profiles)
table = gtk.Table(4, 2, homogeneous=False)
table.set_row_spacings(3)
table.set_col_spacings(3)
host = gtk.Label(set_underline(_(u'Host:')))
host.set_use_underline(True)
host.set_alignment(1, 0.5)
host.set_padding(3, 3)
self.host_entry = gtk.Entry()
self.host_entry.connect('focus-out-event', self.display_dbwidget)
self.host_entry.connect('changed', self.update_profiles, 'host')
self.host_entry.set_activates_default(True)
host.set_mnemonic_widget(self.host_entry)
table.attach(host, 0, 1, 1, 2, yoptions=False, xoptions=gtk.FILL)
table.attach(self.host_entry, 1, 2, 1, 2, yoptions=False)
database = gtk.Label(set_underline(_(u'Database:')))
database.set_use_underline(True)
database.set_alignment(1, 0.5)
database.set_padding(3, 3)
self.database_entry = gtk.Entry()
self.database_entry.connect('changed', self.dbentry_changed)
self.database_entry.connect('changed', self.update_profiles,
'database')
self.database_entry.set_activates_default(True)
self.database_label = gtk.Label()
self.database_label.set_use_markup(True)
self.database_label.set_alignment(0, 0.5)
self.database_combo = gtk.ComboBox()
dbstore = gtk.ListStore(gobject.TYPE_STRING)
cell = gtk.CellRendererText()
self.database_combo.pack_start(cell, True)
self.database_combo.add_attribute(cell, 'text', 0)
self.database_combo.set_model(dbstore)
self.database_combo.connect('changed', self.dbcombo_changed)
self.database_progressbar = gtk.ProgressBar()
self.database_progressbar.set_text(_(u'Fetching databases list'))
image = gtk.Image()
image.set_from_stock('tryton-new', gtk.ICON_SIZE_BUTTON)
db_box = gtk.VBox(homogeneous=True)
db_box.pack_start(self.database_entry)
db_box.pack_start(self.database_combo)
db_box.pack_start(self.database_label)
db_box.pack_start(self.database_progressbar)
# Compute size_request of box in order to prevent "form jumping"
width, height = 0, 0
for child in db_box.get_children():
cwidth, cheight = child.size_request()
width, height = max(width, cwidth), max(height, cheight)
db_box.set_size_request(width, height)
table.attach(database, 0, 1, 2, 3, yoptions=False, xoptions=gtk.FILL)
table.attach(db_box, 1, 2, 2, 3, yoptions=False)
username = gtk.Label(set_underline(_(u'Username:'******'changed', self.update_profiles,
'username')
username.set_mnemonic_widget(self.username_entry)
self.username_entry.set_activates_default(True)
table.attach(username, 0, 1, 3, 4, yoptions=False, xoptions=gtk.FILL)
table.attach(self.username_entry, 1, 2, 3, 4, yoptions=False)
hpaned.add2(table)
hpaned.set_position(250)
self.dialog.vbox.pack_start(hpaned)
self.dialog.set_default_size(640, 350)
self.dialog.set_default_response(gtk.RESPONSE_ACCEPT)
self.dialog.connect('close', lambda *a: False)
self.dialog.connect('response', self.response)
self.callback = callback
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)
widget.set_size_request(150, -1)
widget.show()
box.pack_start(lab, 0, 0, 0)
if full:
box.pack_start(widget, 1, 1, 1)
else:
box.pack_start(widget, 0, 0, 0)
box.show()
# pylint: disable-msg=E1101
if full:
self.vbox.pack_start(box, 1, 1, 1)
else:
self.vbox.pack_start(box, 0, 0, 0)
self.__fields[label] = widget
def get_field(self, label):
return self.__fields.get(label, None)
if __name__ == "__main__":
# pylint: disable-msg=C0103
d = FieldDialog(buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK))
d.add_field("Foo", gtk.Entry())
d.add_field("Bar", make_choice(["A", "B"]))
d.run()
gtk.main()
d.destroy()
def __init__(self, image):
self.image = image
self.dialog = gimpui.Dialog(PLUGIN_TITLE, None, None, 0, None, None)
self.dialog.set_transient()
self.dialog.set_default_size(850, 660)
# self.dialog.set_size_request(850,660)
self.dialog.set_border_width(8)
dialog_position = retrieve_setting('dialog_position')
if dialog_position is not None:
self.dialog.move(*dialog_position)
self.directory_chooser_label = gtk.Label()
self.directory_chooser_label.set_markup(
"<b>Choose output directory</b>")
self.directory_chooser_label.set_alignment(0.0, 0.5)
self.directory_chooser = gtk.FileChooserWidget(
action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
self.hbox_file_format = gtk.HBox(homogeneous=False)
self.hbox_file_format.set_spacing(5)
self.file_format_label = gtk.Label()
self.file_format_label.set_markup("<b>File format:</b>")
self.file_format_label.set_alignment(0.0, 0.5)
self.file_format_label.set_size_request(100, -1)
self.file_format_entry = gtk.Entry()
self.file_format_entry.set_size_request(100, -1)
self.file_format_error_icon = gtk.Image()
self.file_format_error_icon.set_from_stock(gtk.STOCK_STOP,
gtk.ICON_SIZE_BUTTON)
self.file_format_error_message = gtk.Label()
self.file_format_error_message.set_alignment(0.0, 0.5)
self.hbox_file_format.pack_start(self.file_format_label, expand=False)
self.hbox_file_format.pack_start(self.file_format_entry, expand=False)
self.hbox_file_format.pack_start(self.file_format_error_icon,
expand=False)
self.hbox_file_format.pack_start(self.file_format_error_message,
expand=False)
self.hbox_export_options = gtk.HBox(homogeneous=False)
self.export_options_layer_groups = gtk.CheckButton(
"Treat layer groups as directories")
self.export_options_ignore_invisible = gtk.CheckButton(
"Ignore invisible layers")
self.export_options_is_autocrop = gtk.CheckButton("Autocrop layers")
self.export_options_use_image_size = gtk.CheckButton(
"Use image size instead of layer size")
self.hbox_export_options.pack_start(self.export_options_layer_groups)
self.hbox_export_options.pack_start(
self.export_options_ignore_invisible)
self.hbox_export_options.pack_start(self.export_options_is_autocrop)
self.hbox_export_options.pack_start(self.export_options_use_image_size)
self.hbox_action_area = gtk.HBox(homogeneous=False)
self.export_layers_button = gtk.Button(label="Export Layers")
self.export_layers_button.set_size_request(110, -1)
self.cancel_button = gtk.Button(label="Cancel")
self.cancel_button.set_size_request(110, -1)
self.progress_bar = gimpui.ProgressBar()
# self.progress_bar = gtk.ProgressBar()
self.hbox_action_area.set_spacing(8)
self.hbox_action_area.set_border_width(8)
self.hbox_action_area.pack_start(self.progress_bar,
expand=True,
fill=True)
self.hbox_action_area.pack_end(self.export_layers_button,
expand=False,
fill=True)
self.hbox_action_area.pack_end(self.cancel_button,
expand=False,
fill=True)
self.dialog.vbox.set_spacing(3)
self.dialog.vbox.pack_start(self.directory_chooser_label,
expand=False,
fill=False)
self.dialog.vbox.pack_start(self.directory_chooser, padding=5)
self.dialog.vbox.pack_start(self.hbox_file_format,
expand=False,
fill=False)
self.dialog.vbox.pack_start(self.hbox_export_options,
expand=False,
fill=False)
self.dialog.vbox.pack_start(self.hbox_action_area,
expand=False,
fill=False)
self.dialog.connect("response", self.response)
self.cancel_button.connect("clicked", self.cancel)
self.export_layers_button.connect("clicked", self.export)
# Assign last used values if last export was successful and
# if there are any, otherwise use default values.
selected_directory = retrieve_setting('output_directory')
if selected_directory is not None:
self.directory_chooser.set_current_folder(selected_directory)
else:
if self.image.uri is not None:
self.directory_chooser.set_uri(self.image.uri)
else:
self.directory_chooser.set_current_folder(
ExportLayersPlugin.
PARAMS_DEFAULT_VALUES['output_directory'])
self.file_format_entry.set_text(
retrieve_setting(
'file_format',
ExportLayersPlugin.PARAMS_DEFAULT_VALUES['file_format']))
self.export_options_layer_groups.set_active(
retrieve_setting(
'layer_groups_as_directories', ExportLayersPlugin.
PARAMS_DEFAULT_VALUES['layer_groups_as_directories']))
self.export_options_ignore_invisible.set_active(
retrieve_setting(
'ignore_invisible',
ExportLayersPlugin.PARAMS_DEFAULT_VALUES['ignore_invisible']))
self.export_options_is_autocrop.set_active(
retrieve_setting(
'is_autocrop',
ExportLayersPlugin.PARAMS_DEFAULT_VALUES['is_autocrop']))
self.export_options_use_image_size.set_active(
retrieve_setting(
'use_image_size',
ExportLayersPlugin.PARAMS_DEFAULT_VALUES['use_image_size']))
self.dialog.show_all()
# Action area is unused, the dialog bottom would otherwise be filled with empty space.
self.dialog.action_area.hide()
self.display_label_error_message()
self.progress_bar.set_visible(False)
def initialize_detail(self):
self.detail_container = self.get_widget("detail_container")
vbox = gtk.VBox(False, 6)
# Set up the Tag line
label = gtk.Label(_("Name:"))
label.set_size_request(90, -1)
label.set_properties(xalign=0, yalign=.5)
self.tag_entry = gtk.Entry()
self.tag_name_container = gtk.HBox(False, 0)
self.tag_name_container.pack_start(label, False, False, 0)
self.tag_name_container.pack_start(self.tag_entry, False, False, 0)
vbox.pack_start(self.tag_name_container, False, False, 0)
# Set up the Commit-sha line
label = gtk.Label(_("Revision:"))
label.set_size_request(90, -1)
label.set_properties(xalign=0, yalign=.5)
self.start_point_entry = gtk.Entry()
self.start_point_entry.set_size_request(300, -1)
self.start_point_container = gtk.HBox(False, 0)
if self.revision_obj.value:
self.start_point_entry.set_text(six.text_type(self.revision_obj))
self.log_dialog_button = gtk.Button()
self.log_dialog_button.connect("clicked",
self.on_log_dialog_button_clicked)
image = gtk.Image()
image.set_from_icon_name("rabbitvcs-show_log", 2)
self.log_dialog_button.set_image(image)
self.start_point_container.pack_start(label, False, False, 0)
self.start_point_container.pack_start(self.start_point_entry, False,
False, 0)
self.start_point_container.pack_start(self.log_dialog_button, False,
False, 0)
vbox.pack_start(self.start_point_container, False, False, 0)
# Set up the Log Message Entry line
label = gtk.Label(_("Message:"))
label.set_size_request(90, -1)
label.set_properties(xalign=0, yalign=0)
self.message_entry = rabbitvcs.ui.widget.TextView()
self.message_entry.view.set_size_request(300, 75)
swin = gtk.ScrolledWindow()
swin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
swin.add(self.message_entry.view)
self.message_entry_container = gtk.HBox(False, 0)
self.message_entry_container.pack_start(label, False, False, 0)
self.message_entry_container.pack_start(swin, False, False, 0)
vbox.pack_start(self.message_entry_container, False, False, 0)
# Set up Save button
label = gtk.Label("")
label.set_size_request(90, -1)
self.save_button = gtk.Button(label=_("Save"))
self.save_button.connect("clicked", self.on_save_clicked)
self.save_container = gtk.HBox(False, 0)
self.save_container.pack_start(label, False, False, 0)
self.save_container.pack_start(self.save_button, False, False, 0)
vbox.pack_start(self.save_container, False, False, 0)
# Set up the tagger line
label = gtk.Label(_("Tagger:"))
label.set_size_request(90, -1)
label.set_properties(xalign=0, yalign=0)
self.tagger_label = gtk.Label("")
self.tagger_label.set_properties(xalign=0, yalign=0, selectable=True)
self.tagger_label.set_line_wrap(True)
self.tagger_container = gtk.HBox(False, 0)
self.tagger_container.pack_start(label, False, False, 0)
self.tagger_container.pack_start(self.tagger_label, False, False, 0)
vbox.pack_start(self.tagger_container, False, False, 0)
# Set up the Date line
label = gtk.Label(_("Date:"))
label.set_size_request(90, -1)
label.set_properties(xalign=0, yalign=0)
self.date_label = gtk.Label("")
self.date_label.set_properties(xalign=0, yalign=0, selectable=True)
self.date_container = gtk.HBox(False, 0)
self.date_container.pack_start(label, False, False, 0)
self.date_container.pack_start(self.date_label, False, False, 0)
vbox.pack_start(self.date_container, False, False, 0)
# Set up the Revision line
label = gtk.Label(_("Revision:"))
label.set_size_request(90, -1)
label.set_properties(xalign=0, yalign=0)
self.revision_label = gtk.Label("")
self.revision_label.set_properties(xalign=0, selectable=True)
self.revision_label.set_line_wrap(True)
self.revision_container = gtk.HBox(False, 0)
self.revision_container.pack_start(label, False, False, 0)
self.revision_container.pack_start(self.revision_label, False, False,
0)
vbox.pack_start(self.revision_container, False, False, 0)
# Set up the Log Message line
label = gtk.Label(_("Message:"))
label.set_size_request(90, -1)
label.set_properties(xalign=0, yalign=0)
self.message_label = gtk.Label("")
self.message_label.set_properties(xalign=0, yalign=0, selectable=True)
self.message_label.set_line_wrap(True)
self.message_label.set_size_request(250, -1)
self.message_container = gtk.HBox(False, 0)
self.message_container.pack_start(label, False, False, 0)
self.message_container.pack_start(self.message_label, False, False, 0)
vbox.pack_start(self.message_container, False, False, 0)
self.add_containers = [
self.tag_name_container, self.message_entry_container,
self.start_point_container, self.save_container
]
self.view_containers = [
self.tag_name_container, self.tagger_container,
self.date_container, self.revision_container,
self.message_container
]
self.all_containers = [
self.tag_name_container, self.tagger_container,
self.date_container, self.revision_container,
self.message_container, self.message_entry_container,
self.save_container, self.start_point_container
]
vbox.show()
self.detail_container.add(vbox)
def fusion_dialog(self):
dialog = gtk.Dialog('CUT PARAMETERS', self.W,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT))
topL = gtk.Label('Items with a *** are mandatory')
infL = gtk.Label('For Material # {}\n{}'.format(self.fNUM, self.fNAM))
dNUl = gtk.Label('Material Number ***')
dNUl.set_alignment(0, 1)
dNU = gtk.Entry()
dNU.set_text(self.fNUM)
dNU.set_alignment(0.95)
dNAl = gtk.Label('Material Name')
dNAl.set_alignment(0, 1)
dNA = gtk.Entry()
dNA.set_text(self.fNAM)
dNA.set_alignment(0.95)
dKWl = gtk.Label('Kerf Width')
dKWl.set_alignment(0, 1)
dKW = gtk.Entry()
dKW.set_text(self.fKW)
dKW.set_alignment(0.95)
dTHC = gtk.CheckButton('THC Enabled')
dTHC.set_active(self.fTHC)
dPHl = gtk.Label('Pierce Height ***')
dPHl.set_alignment(0, 1)
dPH = gtk.Entry()
dPH.set_text(self.fPH)
dPH.set_alignment(0.95)
dPDl = gtk.Label('Pierce Delay ***')
dPDl.set_alignment(0, 1)
dPD = gtk.Entry()
dPD.set_text(self.fPD)
dPD.set_alignment(0.95)
dPJHl = gtk.Label('Puddle Jump Height')
dPJHl.set_alignment(0, 1)
dPJH = gtk.Entry()
dPJH.set_text(self.fPJH)
dPJH.set_alignment(0.95)
dPJDl = gtk.Label('Puddle Jump Delay')
dPJDl.set_alignment(0, 1)
dPJD = gtk.Entry()
dPJD.set_text(self.fPJD)
dPJD.set_alignment(0.95)
dCHl = gtk.Label('Cut Height ***')
dCHl.set_alignment(0, 1)
dCH = gtk.Entry()
dCH.set_text(self.fCH)
dCH.set_alignment(0.95)
dCSl = gtk.Label('Cut Speed ***')
dCSl.set_alignment(0, 1)
dCS = gtk.Entry()
dCS.set_text(self.fCS)
dCS.set_alignment(0.95)
dCAl = gtk.Label('Cut Amps')
dCAl.set_alignment(0, 1)
dCA = gtk.Entry()
dCA.set_text(self.fCA)
dCA.set_alignment(0.95)
dCVl = gtk.Label('Cut Volts')
dCVl.set_alignment(0, 1)
dCV = gtk.Entry()
dCV.set_text(self.fCV)
dCV.set_alignment(0.95)
dPEl = gtk.Label('Pause At End Of Cut')
dPEl.set_alignment(0, 1)
dPE = gtk.Entry()
dPE.set_text(self.fPE)
dPE.set_alignment(0.95)
dGPl = gtk.Label('Gas Pressure')
dGPl.set_alignment(0, 1)
dGP = gtk.Entry()
dGP.set_text(self.fGP)
dGP.set_alignment(0.95)
dCMl = gtk.Label('Cut Mode')
dCMl.set_alignment(0, 1)
dCM = gtk.Entry()
dCM.set_text(self.fCM)
dCM.set_alignment(0.95)
dialog.vbox.add(topL)
if self.inManual.get_active():
dialog.vbox.add(dNUl)
dialog.vbox.add(dNU)
dialog.vbox.add(dNAl)
dialog.vbox.add(dNA)
dialog.vbox.add(dKWl)
dialog.vbox.add(dKW)
else:
dialog.vbox.add(infL)
dialog.vbox.add(dTHC)
dialog.vbox.add(dPHl)
dialog.vbox.add(dPH)
dialog.vbox.add(dPDl)
dialog.vbox.add(dPD)
dialog.vbox.add(dPJHl)
dialog.vbox.add(dPJH)
dialog.vbox.add(dPJDl)
dialog.vbox.add(dPJD)
dialog.vbox.add(dCHl)
dialog.vbox.add(dCH)
if self.inManual.get_active():
dialog.vbox.add(dCSl)
dialog.vbox.add(dCS)
dialog.vbox.add(dCAl)
dialog.vbox.add(dCA)
dialog.vbox.add(dCVl)
dialog.vbox.add(dCV)
dialog.vbox.add(dPEl)
dialog.vbox.add(dPE)
dialog.vbox.add(dGPl)
dialog.vbox.add(dGP)
dialog.vbox.add(dCMl)
dialog.vbox.add(dCM)
dialog.show_all()
response = dialog.run()
if self.inManual.get_active():
self.fNUM = dNU.get_text()
self.fNAM = dNA.get_text()
self.fKW = dKW.get_text()
if dTHC.get_active():
self.fTHC = 1
else:
self.fTHC = 0
self.fPH = dPH.get_text()
self.fPD = dPD.get_text()
self.fPJH = dPJH.get_text()
self.fPJD = dPJD.get_text()
self.fCH = dCH.get_text()
if self.inManual.get_active():
self.fCS = dCS.get_text()
self.fCA = dCA.get_text()
self.fCV = dCV.get_text()
self.fPE = dPE.get_text()
self.fGP = dGP.get_text()
self.fCM = dCM.get_text()
dialog.destroy()
return response
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 caja3(self, homogeneous, spacing, expand, fill, padding):
caja = gtk.HBox(homogeneous, spacing)
caja.set_border_width(7)
rama = gtk.Label("Rama:")
caja.pack_start(rama, False, False, 5)
rama.show()
global texto2
texto2 = gtk.Entry()
texto2.set_text("pruebas")
texto2.set_sensitive(True)
caja.pack_start(texto2, True, True, 5)
texto2.show()
seccion = gtk.Label("Sección:")
caja.pack_start(seccion, False, False, 5)
seccion.show()
global texto3
texto3 = gtk.Entry()
texto3.set_text("usuarios")
texto3.set_sensitive(True)
caja.pack_start(texto3, True, True, 5)
texto3.show()
boton = gtk.Button(" Validar ")
#-------------Método para crear el hilo del método validar los repositorios-------------#
def hilo_validar_remotos(self):
hilo = threading.Thread(target=validar_remotos, args=self)
hilo.start()
#~~~~~~~~ Método para validar los repositorios remotos ~~~~~~~~~#
def validar_remotos(self):
if texto5.get_text() == "" or texto2.get_text(
) == "" or texto3.get_text() == "":
gtk.gdk.threads_enter()
error = gtk.MessageDialog(
parent=None,
flags=0,
type=gtk.MESSAGE_ERROR,
buttons=gtk.BUTTONS_CLOSE,
message_format=
"Debe tener todos los campos llenos para validar")
error.run()
error.destroy()
gtk.gdk.threads_leave()
else:
try:
urllib.urlopen(texto5.get_text())
if textbuffer.get_text(*textbuffer.get_bounds()).find(
texto5.get_text()) >= 0:
gtk.gdk.threads_enter()
message = gtk.MessageDialog(
parent=None,
flags=0,
type=gtk.MESSAGE_WARNING,
buttons=gtk.BUTTONS_CLOSE,
message_format="La dirección ya ha sido agregada")
message.run()
message.hide()
gtk.gdk.threads_leave()
else:
gtk.gdk.threads_enter()
textbuffer.set_text(
textbuffer.get_text(*textbuffer.get_bounds()) +
"deb " + texto5.get_text() + ' ' +
texto2.get_text() + ' ' + texto3.get_text() + "\n")
gtk.gdk.threads_leave()
except IOError:
gtk.gdk.threads_enter()
errorURL = gtk.MessageDialog(
parent=None,
flags=0,
type=gtk.MESSAGE_ERROR,
buttons=gtk.BUTTONS_CLOSE,
message_format=
"Debe introducir URL validas para el repositorio")
errorURL.run()
errorURL.destroy()
gtk.gdk.threads_leave()
boton.connect("clicked", hilo_validar_remotos)
caja.pack_start(boton, False, False, 5)
boton.show()
return caja
def __init__(self, name, toolbox, method):
debug.mainthreadTest()
toolboxGUI.GfxToolbox.__init__(self, name, toolbox)
self.method = method # RegisteredClass of selection methods
self.points = [] # locations of mouse events
# Was a modifier key pressed during the last button event?
self.shift = 0
self.ctrl = 0
outerbox = gtk.VBox(spacing=2)
self.gtk.add(outerbox)
## scroll = gtk.ScrolledWindow()
## scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
## outerbox.pack_start(scroll, expand=1, fill=1)
# Retrieve the registered class factory from the subclass.
self.selectionMethodFactory = self.methodFactory()
# self.selectionMethodFactory = regclassfactory.RegisteredClassFactory(
# method.registry, title="Method:", name="Method")
## scroll.add_with_viewport(self.selectionMethodFactory.gtk)
outerbox.pack_start(self.selectionMethodFactory.gtk, expand=1, fill=1)
self.historian = historian.Historian(self.setHistory,
self.sensitizeHistory)
self.selectionMethodFactory.set_callback(self.historian.stateChangeCB)
# Undo, Redo, Clear, and Invert buttons. The callbacks for
# these have to be defined in the derived classes.
hbox = gtk.HBox(homogeneous=True, spacing=2)
outerbox.pack_start(hbox, expand=0, fill=0)
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
hbox.pack_start(self.undobutton, expand=1, fill=1)
hbox.pack_start(self.redobutton, expand=1, fill=1)
gtklogger.setWidgetName(self.undobutton, "Undo")
gtklogger.setWidgetName(self.redobutton, "Redo")
gtklogger.connect(self.undobutton, 'clicked', self.undoCB)
gtklogger.connect(self.redobutton, 'clicked', self.redoCB)
tooltips.set_tooltip_text(self.undobutton,
"Undo the previous selection operation.")
tooltips.set_tooltip_text(self.redobutton,
"Redo an undone selection operation.")
self.clearbutton = gtk.Button(stock=gtk.STOCK_CLEAR)
gtklogger.setWidgetName(self.clearbutton, "Clear")
hbox.pack_start(self.clearbutton, expand=1, fill=1)
gtklogger.connect(self.clearbutton, 'clicked', self.clearCB)
tooltips.set_tooltip_text(self.clearbutton, "Unselect all objects.")
self.invertbutton = gtk.Button('Invert')
gtklogger.setWidgetName(self.invertbutton, "Invert")
hbox.pack_start(self.invertbutton, expand=1, fill=1)
gtklogger.connect(self.invertbutton, 'clicked', self.invertCB)
tooltips.set_tooltip_text(
self.invertbutton,
"Select all unselected objects, and deselect all selected objects."
)
# Selection history
frame = gtk.Frame('History')
frame.set_shadow_type(gtk.SHADOW_IN)
outerbox.pack_start(frame, expand=0, fill=0)
vbox = gtk.VBox()
frame.add(vbox)
table = gtk.Table(rows=2, columns=3)
vbox.pack_start(table, expand=0, fill=0)
table.attach(gtk.Label('down'), 0, 1, 0, 1, xoptions=0, yoptions=0)
table.attach(gtk.Label('up'), 0, 1, 1, 2, xoptions=0, yoptions=0)
self.xdownentry = gtk.Entry()
self.ydownentry = gtk.Entry()
self.xupentry = gtk.Entry()
self.yupentry = gtk.Entry()
gtklogger.setWidgetName(self.xdownentry, 'xdown')
gtklogger.setWidgetName(self.ydownentry, 'ydown')
gtklogger.setWidgetName(self.xupentry, 'xup')
gtklogger.setWidgetName(self.yupentry, 'yup') # yessirree, Bob!
entries = [
self.xdownentry, self.ydownentry, self.xupentry, self.yupentry
]
if config.dimension() == 3:
self.zdownentry = gtk.Entry()
self.zupentry = gtk.Entry()
gtklogger.setWidgetName(self.zdownentry, 'zdown')
gtklogger.setWidgetName(self.zdownentry, 'zup')
entries.append(self.zdownentry)
entries.append(self.zupentry)
self.entrychangedsignals = []
for entry in entries:
entry.set_size_request(12 * guitop.top().digitsize, -1)
self.entrychangedsignals.append(
gtklogger.connect(entry, "changed", self.poschanged))
table.attach(self.xdownentry, 1, 2, 0, 1)
table.attach(self.ydownentry, 2, 3, 0, 1)
table.attach(self.xupentry, 1, 2, 1, 2)
table.attach(self.yupentry, 2, 3, 1, 2)
if config.dimension() == 3:
table.attach(self.zdownentry, 3, 4, 0, 1)
table.attach(self.zupentry, 3, 4, 1, 2)
hbox = gtk.HBox(spacing=2)
vbox.pack_start(hbox, expand=0, fill=0)
self.prevmethodbutton = gtkutils.prevButton()
self.repeatbutton = gtkutils.StockButton(gtk.STOCK_REFRESH, 'Repeat')
gtklogger.setWidgetName(self.repeatbutton, 'Repeat')
self.nextmethodbutton = gtkutils.nextButton()
hbox.pack_start(self.prevmethodbutton, expand=0, fill=0)
hbox.pack_start(self.repeatbutton, expand=1, fill=0)
hbox.pack_start(self.nextmethodbutton, expand=0, fill=0)
gtklogger.connect(self.repeatbutton, 'clicked', self.repeatCB)
gtklogger.connect(self.repeatbutton, 'button-release-event',
self.repeateventCB)
gtklogger.connect(self.prevmethodbutton, 'clicked',
self.historian.prevCB)
gtklogger.connect(self.nextmethodbutton, 'clicked',
self.historian.nextCB)
tooltips.set_tooltip_text(
self.prevmethodbutton,
"Recall the settings and mouse coordinates for the previous"
" selection method.")
tooltips.set_tooltip_text(
self.nextmethodbutton,
"Recall the settings and mouse coordinates for the next"
" selection method.")
tooltips.set_tooltip_text(
self.repeatbutton,
"Execute the selection method as if the mouse had been clicked"
" at the above coordinates. Hold the shift key to retain the"
" previous selection. Hold the control key to toggle the"
" selection state of the selected pixels.")
# Selection information
hbox = gtk.HBox()
outerbox.pack_start(hbox, expand=0, fill=0)
hbox.pack_start(gtk.Label('Selection size: '), expand=0, fill=0)
self.sizetext = gtk.Entry()
gtklogger.setWidgetName(self.sizetext, 'size')
hbox.pack_start(self.sizetext, expand=1, fill=1)
self.sizetext.set_editable(False)
self.sizetext.set_size_request(12 * guitop.top().digitsize, -1)
self.setInfo()
# switchboard callbacks
self.sbcallbacks = [
switchboard.requestCallbackMain(method,
self.updateSelectionMethods),
switchboard.requestCallback(
(self.toolbox.gfxwindow(), 'layers changed'),
self.setInfo_subthread)
]
def add(self, widget):
widget_type = type(widget)
print widget_type
if (widget_type == Button or isinstance(widget, Button)):
widget.controller = gtk.Button(widget.text)
widget.controller.set_size_request(widget.width, widget.height)
self.fixed.put(widget.controller, widget.position_X,
widget.position_Y)
widget.controller.show()
if (widget.callbackMethod != None):
widget.controller.connect('clicked', widget.callbackMethod)
elif (widget_type == TextArea or isinstance(widget, TextArea)):
widget.controller = gtk.TextView(widget.buffer)
widget.controller.set_size_request(widget.width, widget.height)
self.fixed.put(widget.controller, widget.position_X,
widget.position_Y)
widget.controller.show()
if (widget.callbackMethod != None):
widget.controller.connect('clicked', widget.callbackMethod)
elif (widget_type == TextField or isinstance(widget, TextField)):
widget.controller = gtk.Entry()
widget.controller.set_size_request(widget.width, widget.height)
self.fixed.put(widget.controller, widget.position_X,
widget.position_Y)
widget.controller.set_text(widget.title)
widget.controller.show()
elif (widget_type == CheckBox or isinstance(widget, CheckBox)):
widget.controller = gtk.CheckButton(widget.title)
widget.controller.set_size_request(widget.width, widget.height)
self.fixed.put(widget.controller, widget.position_X,
widget.position_Y)
widget.controller.show()
widget.controller.set_active(widget.value)
elif (widget_type == RadioGroup or isinstance(widget, RadioGroup)):
widget.controller = []
radio_controller = gtk.RadioButton(None, widget.labels[0])
radio_controller.set_size_request(widget.width, widget.height)
self.fixed.put(radio_controller, widget.position_X[0],
widget.position_Y[0])
radio_controller.show()
widget.controller.append(radio_controller)
for i in range(1, len(widget.labels)):
radio_controller = gtk.RadioButton(widget.controller[0],
widget.labels[i])
radio_controller.set_size_request(widget.width, widget.height)
self.fixed.put(radio_controller, widget.position_X[i],
widget.position_Y[i])
radio_controller.show()
widget.controller.append(radio_controller)
if (widget.selected_pos != None):
widget.controller[widget.selected_pos].set_active(True)
elif (widget_type == ValueList or isinstance(widget, ValueList)):
widget.controller = gtk.OptionMenu()
widget.controller.set_size_request(widget.width, widget.height)
menu = gtk.Menu()
for name in widget.choices:
item = gtk.MenuItem(name)
item.show()
menu.append(item)
print "gis"
widget.controller.set_menu(menu)
widget.controller.show()
self.fixed.put(widget.controller, widget.position_X,
widget.position_Y)
elif (widget_type == LabelText or isinstance(widget, LabelText)):
widget.controller = gtk.Label(widget.text)
widget.controller.set_size_request(widget.width, widget.height)
self.fixed.put(widget.controller, widget.position_X,
widget.position_Y)
widget.controller.set_markup("<span font_desc='Calibri " +
str(widget.size) + "'>" +
widget.text + "</span>")
widget.controller.show()
elif (widget_type == Slider or isinstance(widget, Slider)):
widget.controller = gtk.Adjustment(1.0, widget._from, widget._to,
1.0, 1.0, 0.0)
widget.scale = gtk.HScale(widget.controller)
widget.scale.set_digits(0)
widget.scale.set_size_request(widget.width, widget.height)
self.fixed.put(widget.scale, widget.position_X, widget.position_Y)
widget.scale.show()
elif (widget_type == Dialog or isinstance(widget, Dialog)):
widget.title = widget.title
def __init__(self):
qtwindow.QTWindow.__init__(self, 'data', _L('Data Browser'))
self.connect("delete-event", self._delete_event_cb)
self._browser = None
self._meta_tags = set([])
self._meta_tag = 'header'
self._cur_path = None
self._dir_entry = gtk.Entry()
self._dir_entry.connect('activate', self._dir_activate_cb)
self._dir_button = gtk.Button(_L('Browse'))
self._dir_button.connect('clicked', self._dir_button_clicked_cb)
self._dir_hbox = gui.pack_hbox(
(gtk.Label('Directory'), self._dir_entry, self._dir_button), True,
True)
self._plot2d_button = gtk.Button(_L('Plot2D'))
self._plot2d_button.connect('clicked', self._plot2d_clicked_cb)
self._plot3d_button = gtk.Button(_L('Plot3D'))
self._plot3d_button.connect('clicked', self._plot3d_clicked_cb)
self._plot_name = gtk.Entry()
self._plot_name.set_text('databrowser')
self._plot_style = gtk.Entry()
self._columns = gtk.Entry()
self._clear_check = gtk.CheckButton()
self._clear_check.set_active(True)
self._clear_button = gtk.Button(_L('Clear'))
self._clear_button.connect('clicked', self._clear_clicked_cb)
self._ofs_entry = gtk.Entry()
self._traceofs_entry = gtk.Entry()
vbox1 = gui.pack_vbox([
gui.pack_hbox([gtk.Label(_L('Name')), self._plot_name], False,
False),
gui.pack_hbox([gtk.Label(_L('Clear')), self._clear_check], False,
False),
gui.pack_hbox([gtk.Label(_L('Style')), self._plot_style], False,
False),
gui.pack_hbox([gtk.Label(_L('Columns')), self._columns], False,
False),
], False, False)
vbox2 = gui.pack_vbox([
gui.pack_hbox([gtk.Label(_L('Offset')), self._ofs_entry], False,
False),
gui.pack_hbox(
[gtk.Label(_L('Trace offset')), self._traceofs_entry], False,
False),
], False, False)
self._plot_box = gui.pack_vbox([
gui.pack_hbox([vbox1, vbox2], True, True),
gui.pack_hbox(
[self._plot2d_button, self._plot3d_button, self._clear_button],
True, True),
], True, True)
self._plot_box.set_border_width(4)
self._plot_frame = gtk.Frame('Plot')
self._plot_frame.add(self._plot_box)
self._entries_model = gtk.ListStore(str)
self._entries_model.set_sort_column_id(0, gtk.SORT_ASCENDING)
self._entry_map = {}
self._entries_view = qttable.QTTable([(_L('Filename'), {})], \
self._entries_model)
self._entries_view.connect('row-activated', self._row_activated_cb)
self._entries_scroll = gtk.ScrolledWindow()
self._entries_scroll.set_policy(gtk.POLICY_AUTOMATIC, \
gtk.POLICY_AUTOMATIC)
self._entries_scroll.add_with_viewport(self._entries_view)
self._info_view = gtk.TextView()
self._info_view.set_border_width(4)
self._meta_dropdown = dropdowns.StringListDropdown([])
self._meta_dropdown.connect('changed', self._meta_drop_changed_cb)
self._info_box = gui.pack_vbox([self._meta_dropdown, self._info_view],
False, False)
self._info_box.set_border_width(4)
self._views_hbox = gui.pack_hbox(
(self._entries_scroll, self._info_box), True, True)
vbox = gtk.VBox()
vbox.pack_start(self._dir_hbox, False, False)
vbox.pack_start(self._plot_frame, False, False)
vbox.pack_start(self._views_hbox, True, True)
self.add(vbox)
vbox.show_all()
def createFlopTab(self):
# hierarchy: hbox / ddbox / ddhbox / Label + flop_games_cb | label + players_cb
# / gamehbox / in_frame / table /
# / out_frame
tab_title = _("Flop")
label = gtk.Label(tab_title)
ddbox = gtk.VBox(False, 0)
self.notebook.append_page(ddbox, label)
ddhbox = gtk.HBox(False, 0)
gamehbox = gtk.HBox(False, 0)
ddbox.add(ddhbox)
ddbox.add(gamehbox)
# Combo boxes in the top row
games = [
"Holdem",
"Omaha",
"Omaha 8",
]
players = ["2", "3", "4", "5", "6", "7", "8", "9", "10"]
flop_games_cb = self.create_combo_box(games)
players_cb = self.create_combo_box(players)
label = gtk.Label(_("Gametype") + ":")
ddhbox.add(label)
ddhbox.add(flop_games_cb)
label = gtk.Label(_("Players") + ":")
ddhbox.add(label)
ddhbox.add(players_cb)
# Frames for Stove input and output
in_frame = gtk.Frame(_("Input:"))
out_frame = gtk.Frame(_("Output:"))
gamehbox.add(in_frame)
gamehbox.add(out_frame)
self.outstring = """
No board given. Using Monte-Carlo simulation...
Enumerated 2053443 possible plays.
Your hand: (Ad Ac)
Against the range: {
AhAd, AhAs, AdAs, KhKd, KhKs,
KhKc, KdKs, KdKc, KsKc, QhQd,
QhQs, QhQc, QdQs, QdQc, QsQc,
JhJd, JhJs, JhJc, JdJs, JdJc,
JsJc
}
Win Lose Tie
69.91% 15.83% 14.26%
"""
self.outputlabel = gtk.Label(self.outstring)
out_frame.add(self.outputlabel)
# Input Frame
table = gtk.Table(4, 5, True)
label = gtk.Label(_("Board:"))
self.board = gtk.Entry()
#self.board.connect("changed", self.set_board_flop, self.board)
btn1 = gtk.Button()
btn1.set_image(
gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
#btn.connect('clicked', self._some_function, arg)
table.attach(label,
0,
1,
0,
1,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
table.attach(self.board,
1,
2,
0,
1,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
table.attach(btn1,
2,
3,
0,
1,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
label = gtk.Label(_("Player1:"))
self.p1_board = gtk.Entry()
#self.p1_board.connect("changed", self.set_hero_cards_flop, self.p1_board)
btn2 = gtk.Button()
btn2.set_image(
gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
#btn.connect('clicked', self._some_function, arg)
btn3 = gtk.Button()
btn3.set_image(
gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
#btn.connect('clicked', self._some_function, arg)
table.attach(label,
0,
1,
1,
2,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
table.attach(self.p1_board,
1,
2,
1,
2,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
table.attach(btn2,
2,
3,
1,
2,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
table.attach(btn3,
3,
4,
1,
2,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
label = gtk.Label(_("Player2:"))
self.p2_board = gtk.Entry()
#self.p2_board.connect("changed", self.set_villain_cards_flop, self.p2_board)
btn4 = gtk.Button()
btn4.set_image(
gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
#btn.connect('clicked', self._some_function, arg)
btn5 = gtk.Button()
btn5.set_image(
gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
#btn.connect('clicked', self._some_function, arg)
table.attach(label,
0,
1,
2,
3,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
table.attach(self.p2_board,
1,
2,
2,
3,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
table.attach(btn4,
2,
3,
2,
3,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
table.attach(btn5,
3,
4,
2,
3,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
btn6 = gtk.Button(_("Results"))
btn6.connect("pressed", self.update_flop_output_pane, btn6)
table.attach(btn6,
0,
1,
3,
4,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK)
in_frame.add(table)
def __init__(self, activity, channels):
self._arduino_context_id = None
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self.mode = 'arduino'
# Set up Sensores Button
self.time = RadioToolButton(group=None)
self.lista_sensores_button = []
self.we_are_logging = False
self._log_this_sample = False
self._logging_timer = None
self._logging_counter = 0
self._image_counter = 0
self._logging_interval = 0
self._channels_logged = []
self._busy = False
self._take_screenshot = True
log.debug('se agrega el boton refrescar')
self.refrescar_button = RadioToolButton(group=None)
self.refrescar_button.set_named_icon('recargar')
self.refrescar_button.connect('clicked', self.click_refresh_button)
self.insert(self.refrescar_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self.robot = Arduino()
self._port_entry = gtk.Entry()
self._port_entry.set_text('A5') # A
self._port_entry_changed_id = self._port_entry.connect(
'changed', self._read_sensor)
if hasattr(self._port_entry, 'set_tooltip_text'):
self._port_entry.set_tooltip_text(_('Enter a port to read.'))
self._port_entry.set_width_chars(2)
self._port_entry.show()
toolitem = gtk.ToolItem()
toolitem.add(self._port_entry)
self.insert(toolitem, -1)
toolitem.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_value = LOG_TIMER_VALUES[1]
self.log_label = gtk.Label(self._log_to_string(self._log_value))
toolitem = gtk.ToolItem()
toolitem.add(self.log_label)
self.insert(toolitem, -1)
self._log_button = ToolButton('timer-10')
self._log_button.set_tooltip(_('Select logging interval'))
self._log_button.connect('clicked', self._log_selection_cb)
self.insert(self._log_button, -1)
self._setup_log_palette()
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start Recording'))
self._record.connect('clicked', self.record_control_cb)
self.show_all()
self.reset_position(entry)
def manage_entry_position(entry):
manager = PositionManager()
entry.connect('focus-out-event', manager.focus_out)
entry.connect('focus-in-event', manager.focus_in)
entry.connect('changed', manager.changed)
if __name__ == '__main__':
win = gtk.Window()
win.set_title('Manage Entry Position')
win.connect('delete-event', lambda *a: gtk.main_quit())
vbox = gtk.VBox()
win.add(vbox)
entry1 = gtk.Entry()
vbox.pack_start(entry1, expand=False, fill=False)
manage_entry_position(entry1)
entry1.set_text(string.ascii_letters)
entry2 = gtk.Entry()
entry2.set_alignment(1.0)
vbox.pack_start(entry2, expand=False, fill=False)
manage_entry_position(entry2)
entry2.set_text(string.ascii_letters)
win.show_all()
gtk.main()
def __init__(self,
frame,
message="",
default_text='',
textview=None,
modal=True):
gtk.Dialog.__init__(self)
# Test if the signal is already binded since we do not clear it
# when we destroy FindDialog
if not gobject.signal_lookup("find-click", gtk.Window):
gobject.signal_new("find-click", gtk.Window,
gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_STRING, ))
self.textview = textview
self.nicotine = frame
self.connect("delete-event", self.quit)
# The destroy event shoul clean up the reference to FindDialog
# in the NicotineFrame object
self.connect("destroy", self.destroy)
self.nextPosition = None
self.currentPosition = None
self.lastdirection = "next"
if modal:
self.set_modal(True)
box = gtk.VBox(spacing=10)
box.set_border_width(10)
self.vbox.pack_start(box)
box.show()
if message:
label = gtk.Label(message)
box.pack_start(label, False, False)
label.set_line_wrap(True)
label.show()
self.entry = gtk.Entry()
box.pack_start(self.entry, False, False)
self.entry.show()
self.entry.grab_focus()
self.entry.connect("activate", self.next)
Cancelbutton = self.nicotine.CreateIconButton(gtk.STOCK_CANCEL,
"stock", self.quit,
_("Cancel"))
Cancelbutton.set_flags(gtk.CAN_DEFAULT)
self.action_area.pack_start(Cancelbutton)
Previousbutton = self.nicotine.CreateIconButton(
gtk.STOCK_GO_BACK, "stock", self.previous, _("Previous"))
Previousbutton.set_flags(gtk.CAN_DEFAULT)
self.action_area.pack_start(Previousbutton)
Nextbutton = self.nicotine.CreateIconButton(gtk.STOCK_GO_FORWARD,
"stock", self.next,
_("Next"))
Nextbutton.set_flags(gtk.CAN_DEFAULT)
self.action_area.pack_start(Nextbutton)
Nextbutton.grab_default()
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 _build_ui_tab(self, group):
# The scrolled window
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.show()
# Notebook tab
tab = self._notebook.append_page(sw, gtk.Label(_(group.get_name())))
# Settings table
table = gtk.Table(len(group), 2, False)
table.set_resize_mode(gtk.RESIZE_IMMEDIATE)
table.show()
sw.add_with_viewport(table)
row = 0
for element in group:
if not isinstance(element, settings.RadioSetting):
continue
# Label
label = gtk.Label(element.get_shortname() + ":")
label.set_alignment(0.0, 0.5)
label.show()
table.attach(label, 0, 1, row, row + 1,
xoptions=gtk.FILL, yoptions=0,
xpadding=6, ypadding=3)
if isinstance(element.value, list) and \
isinstance(element.value[0],
settings.RadioSettingValueInteger):
box = gtk.HBox(True)
else:
box = gtk.VBox(True)
# Widget container
box.show()
table.attach(box, 1, 2, row, row + 1,
xoptions=gtk.FILL, yoptions=0,
xpadding=12, ypadding=3)
for i in element.keys():
value = element[i]
if isinstance(value, settings.RadioSettingValueInteger):
widget = gtk.SpinButton()
adj = widget.get_adjustment()
adj.configure(value.get_value(),
value.get_min(), value.get_max(),
value.get_step(), 1, 0)
widget.connect("value-changed", self._save_setting, value)
elif isinstance(value, settings.RadioSettingValueFloat):
widget = gtk.Entry()
widget.set_width_chars(16)
widget.set_text(value.format())
widget.connect("focus-out-event", lambda w, e, v:
self._save_setting(w, v), value)
elif isinstance(value, settings.RadioSettingValueBoolean):
widget = gtk.CheckButton(_("Enabled"))
widget.set_active(value.get_value())
widget.connect("toggled", self._save_setting, value)
elif isinstance(value, settings.RadioSettingValueList):
widget = miscwidgets.make_choice([], editable=False)
model = widget.get_model()
model.clear()
for option in value.get_options():
widget.append_text(option)
current = value.get_value()
index = value.get_options().index(current)
widget.set_active(index)
widget.connect("changed", self._save_setting, value)
elif isinstance(value, settings.RadioSettingValueString):
widget = gtk.Entry()
widget.set_width_chars(32)
widget.set_text(str(value).rstrip())
widget.connect("focus-out-event", lambda w, e, v:
self._save_setting(w, v), value)
else:
LOG.error("Unsupported widget type: %s" % value.__class__)
widget.set_sensitive(value.get_mutable())
widget.show()
box.pack_start(widget, 1, 1, 1)
row += 1
return tab
