Beispiel #1
0
    def __init__(self, gui):
        gtk.Window.__init__(self)
        #self.window.set_position(gtk.WIN_POS_CENTER)
        #self.window.connect("destroy", lambda w: gtk.main_quit())
        #self.window.connect('delete_event', self.exit)
        self.set_title('Graphs')
        vbox = gtk.VBox()
        self.expr = pack(vbox, [gtk.Entry(64), help(graph_help_text)])[0]
        self.expr.connect('activate', self.plot)

        completion = gtk.EntryCompletion()
        self.liststore = gtk.ListStore(str)
        for s in ['fmax', 's, e-E[0]', 'i, d(0,1)']:
            self.liststore.append([s])
        completion.set_model(self.liststore)
        self.expr.set_completion(completion)
        completion.set_text_column(0)

        button = pack(vbox,
                      [gtk.Button(_('Plot')),
                       gtk.Label(' x, y1, y2, ...')])[0]
        button.connect('clicked', self.plot, 'xy')
        button = pack(vbox, [gtk.Button(_('Plot')),
                             gtk.Label(' y1, y2, ...')])[0]
        button.connect('clicked', self.plot, 'y')
        save_button = gtk.Button(stock=gtk.STOCK_SAVE)
        save_button.connect('clicked', self.save)
        clear_button = gtk.Button(_('clear'))
        clear_button.connect('clicked', self.clear)
        pack(vbox, [save_button, clear_button])

        self.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui
Beispiel #2
0
    def __init__(self, gui):
        gtk.Window.__init__(self)
        #self.window.set_position(gtk.WIN_POS_CENTER)
        #self.window.connect("destroy", lambda w: gtk.main_quit())
        #self.window.connect('delete_event', self.exit)
        self.set_title('Graphs')
        vbox = gtk.VBox()
        self.expr = pack(vbox, [gtk.Entry(40),
                                help('Help for plot ...')])[0]
        self.expr.connect('activate', self.plot)

        completion = gtk.EntryCompletion()
        self.liststore = gtk.ListStore(str)
        for s in ['fmax', 's, e-E[0]', 'i, d(0,1)']:
            self.liststore.append([s])
        completion.set_model(self.liststore)
        self.expr.set_completion(completion)
        completion.set_text_column(0)

        button = pack(vbox, [gtk.Button('Plot'),
                             gtk.Label(' x, y1, y2, ...')])[0]
        button.connect('clicked', self.plot, 'xy')
        button = pack(vbox, [gtk.Button('Plot'),
                             gtk.Label(' y1, y2, ...')])[0]
        button.connect('clicked', self.plot, 'y')
        
        button = pack(vbox, gtk.Button(_('clear')))
                          
        button.connect('clicked', self.clear)

        self.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui
Beispiel #3
0
 def add_basis_atom(self, *args):
     """ add an atom to the customizable basis """
     n = len(self.elements)
     self.elements += [
         [
             gtk.Entry(max=3),
             gtk.Entry(max=8),
             gtk.Entry(max=8),
             gtk.Entry(max=8),
             gtk.Label("\t\t\t"),
             gtk.Label("\tx: "),
             gtk.Label("  y: "),
             gtk.Label("  z: "),
             gtk.Label(" "),
             gtk.Button(stock=gtk.STOCK_DELETE),
             True,
         ]
     ]
     self.elements[n][-2].connect("clicked", self.delete_basis_atom, {"n": n})
     pack(
         self.vbox_basis,
         [
             self.elements[n][4],
             self.elements[n][0],
             self.elements[n][5],
             self.elements[n][1],
             self.elements[n][6],
             self.elements[n][2],
             self.elements[n][7],
             self.elements[n][3],
             self.elements[n][8],
             self.elements[n][9],
         ],
     )
     self.update()
Beispiel #4
0
 def __init__(self, vbox):
     self.eventbox = gtk.EventBox()
     self.label = gtk.Label()
     self.eventbox.add(self.label)
     self.label.show()
     self.set_tip(self.eventbox, _('Tip for status box ...'))
     pack(vbox, self.eventbox)
Beispiel #5
0
 def material_from_selection(self,*args):
     box_selection = self.get_selection()
     selection = self.gui.images.selected.copy()
     if selection.any():
         Z = []
         for n in range(len(selection)):
             if selection[n]:
                 Z += [self.gui.images.Z[n]]
         name = formula(Z)
         if (box_selection == selection).all():
             name += ': ' + self.texture_selection.get_text()
         texture_button = gtk.combo_box_new_text()
         for t in self.finish_list:
             texture_button.append_text(t)
         texture_button.set_active(1)
         transparency = gtk.Adjustment(0,0.0,1.0,0.01)
         transparency_spin = gtk.SpinButton(transparency, 0, 0)
         transparency_spin.set_digits(2)
         delete_button = gtk.Button(stock=gtk.STOCK_DELETE)
         alignment = delete_button.get_children()[0]
         index = len(self.materials)
         delete_button.connect("clicked",self.delete_material,{"n":index})
         self.materials += [[True,selection,texture_button,
                             gtk.Label(_("  transparency: ")),transparency_spin,
                             gtk.Label("   "),delete_button,gtk.Label()]]
         self.materials[-1][-1].set_markup("    "+name)
         pack(self.tbox,[self.materials[-1][2],self.materials[-1][3],self.materials[-1][4],
                         self.materials[-1][5],self.materials[-1][6],self.materials[-1][7]])
     else:
         oops(_("Can not create new texture! Must have some atoms selected to create a new material!"))
Beispiel #6
0
    def __init__(self, gui):
        gtk.Window.__init__(self)
        self.set_title('Graphs')
        vbox = gtk.VBox()
        self.expr = pack(vbox, [gtk.Entry(64),
                                help(graph_help_text)])[0]
        self.expr.connect('activate', self.plot)

        completion = gtk.EntryCompletion()
        self.liststore = gtk.ListStore(str)
        for s in ['fmax', 's, e-E[0]', 'i, d(0,1)']:
            self.liststore.append([s])
        completion.set_model(self.liststore)
        self.expr.set_completion(completion)
        completion.set_text_column(0)

        button = pack(vbox, [gtk.Button(_('Plot')),
                             gtk.Label(' x, y1, y2, ...')])[0]
        button.connect('clicked', self.plot, 'xy')
        button = pack(vbox, [gtk.Button(_('Plot')),
                             gtk.Label(' y1, y2, ...')])[0]
        button.connect('clicked', self.plot, 'y')
        save_button = gtk.Button(stock=gtk.STOCK_SAVE)
        save_button.connect('clicked', self.save)
        clear_button = gtk.Button(_('clear'))
        clear_button.connect('clicked', self.clear)
        pack(vbox, [save_button, clear_button])

        self.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui
Beispiel #7
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.set_title(_('Constraints'))
     vbox = gtk.VBox()
     b = pack(vbox,
              [gtk.Button(_('Constrain')),
               gtk.Label(_(' selected atoms'))])[0]
     b.connect('clicked', self.selected)
     b = pack(
         vbox,
         [gtk.Button(_('Constrain')),
          gtk.Label(_(' immobile atoms:'))])[0]
     b.connect('clicked', self.immobile)
     b = pack(
         vbox,
         [gtk.Button(_('Unconstrain')),
          gtk.Label(_(' selected atoms:'))])[0]
     b.connect('clicked', self.unconstrain)
     b = pack(vbox, gtk.Button(_('Clear constraints')))
     b.connect('clicked', self.clear)
     close = pack(vbox, gtk.Button(_('Close')))
     close.connect('clicked', lambda widget: self.destroy())
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #8
0
Datei: gui.py Projekt: jboes/ase
    def open(self, button=None, filenames=None):
        if filenames == None:
            chooser = gtk.FileChooserDialog(
                _('Open ...'), None, gtk.FILE_CHOOSER_ACTION_OPEN,
                (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
                 gtk.STOCK_OPEN, gtk.RESPONSE_OK))
            chooser.set_filename(_("<<filename>>"))

            # Add a file type filter
            name_to_suffix = {}
            types = gtk.combo_box_new_text()
            for name, suffix in [(_('Automatic'), None),
                                 (_('Dacapo netCDF output file'),'dacapo'),
                                 (_('Virtual Nano Lab file'),'vnl'),
                                 (_('ASE pickle trajectory'),'traj'),
                                 (_('ASE bundle trajectory'),'bundle'),
                                 (_('GPAW text output'),'gpaw-text'),
                                 (_('CUBE file'),'cube'),
                                 (_('XCrySDen Structure File'),'xsf'),
                                 (_('Dacapo text output'),'dacapo-text'),
                                 (_('XYZ-file'),'xyz'),
                                 (_('VASP POSCAR/CONTCAR file'),'vasp'),
                                 (_('VASP OUTCAR file'),'vasp_out'),
                                 (_('Protein Data Bank'),'pdb'),
                                 (_('CIF-file'),'cif'),
                                 (_('FHI-aims geometry file'),'aims'),
                                 (_('FHI-aims output file'),'aims_out'),
                                 (_('TURBOMOLE coord file'),'tmol'),
                                 (_('exciting input'),'exi'),
                                 (_('WIEN2k structure file'),'struct'),
                                 (_('DftbPlus input file'),'dftb'),
                                 (_('ETSF format'),'etsf.nc'),
                                 (_('CASTEP geom file'),'cell'),
                                 (_('CASTEP output file'),'castep'),
                                 (_('CASTEP trajectory file'),'geom'),
                                 (_('DFTBPlus GEN format'),'gen')
                                ]:
                types.append_text(name)
                name_to_suffix[name] = suffix
            types.set_active(0)
            img_vbox = gtk.VBox()
            pack(img_vbox, [gtk.Label(_('File type:')), types])
            img_vbox.show()
            chooser.set_extra_widget(img_vbox)

            ok = chooser.run() == gtk.RESPONSE_OK
            if ok:
                filenames = [chooser.get_filename()]
                filetype = types.get_active_text()
            chooser.destroy()

            if not ok:
                return

        n_current = self.images.nimages
        self.reset_tools_modes()     
        self.images.read(filenames, slice(None), name_to_suffix[filetype])
        self.set_colors()
        self.set_coordinates(self.images.nimages - 1, focus=True)
Beispiel #9
0
    def __init__(self, gui):
        gtk.Window.__init__(self)
        self.set_position(gtk.WIN_POS_NONE)
        self.connect('destroy', self.close)
        #self.connect('delete_event', self.exit2)
        self.set_title('Movie')
        vbox = gtk.VBox()
        pack(vbox, gtk.Label(_('Image number:')))
        self.frame_number = gtk.Adjustment(gui.frame, 0,
                                           gui.images.nimages - 1,
                                           1.0, 5.0)
        self.frame_number.connect('value-changed', self.new_frame)

        hscale = pack(vbox, gtk.HScale(self.frame_number))
        hscale.set_update_policy(gtk.UPDATE_CONTINUOUS)
        hscale.set_digits(0)

        buttons = [gtk.Button(stock=gtk.STOCK_GOTO_FIRST),
                   gtk.Button(stock=gtk.STOCK_GO_BACK),
                   gtk.Button(stock=gtk.STOCK_GO_FORWARD),
                   gtk.Button(stock=gtk.STOCK_GOTO_LAST)]

        buttons[0].connect('clicked', self.click, -1, True)
        buttons[1].connect('clicked', self.click, -1)
        buttons[2].connect('clicked', self.click, 1)
        buttons[3].connect('clicked', self.click, 1, True)

        pack(vbox, buttons)

        play = gtk.Button(_('Play'))
        play.connect('clicked', self.play)
        stop = gtk.Button('Stop')
        stop.connect('clicked', self.stop)
        self.rock = gtk.CheckButton('Rock')

        pack(vbox, [play, stop, gtk.Label('  '), self.rock])

        if gui.images.nimages > 150:
            skipdefault = gui.images.nimages/150
            tdefault = min(max(gui.images.nimages/(skipdefault*5.0), 1.0), 30)
        else:
            skipdefault = 0
            tdefault = min(max(gui.images.nimages/5.0, 1.0), 30)
        self.time = gtk.Adjustment(tdefault, 1.0, 99, 0.1)
        self.time_spin = gtk.SpinButton(self.time, 0, 0)
        self.time_spin.set_digits(1)
        self.time.connect("value-changed",self.frame_rate_changed)
        self.skip = gtk.Adjustment(skipdefault, 0, 99, 1)
        self.skip_spin = gtk.SpinButton(self.skip, 0, 0)
        pack(vbox, [gtk.Label(' Frame rate: '), self.time_spin,
                    gtk.Label(' Skip frames: '), self.skip_spin,
                    gtk.Label('   ')])
        self.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui
        #gui.m=self
        self.direction = 1
        self.id = None
        gui.register_vulnerable(self)
Beispiel #10
0
 def __init__(self, vbox):
     self.eventbox = gtk.EventBox()
     self.label = gtk.Label()
     self.eventbox.add(self.label)
     self.label.show()
     if gtk.pygtk_version < (2, 12):
         self.set_tip(self.eventbox, _('Tip for status box ...'))
     else:
         self.eventbox.set_tooltip_text(_('Tip for status box ...'))
     pack(vbox, self.eventbox)
     self.ordered_indices = []
Beispiel #11
0
 def __init__(self, vbox):
     self.eventbox = gtk.EventBox()
     self.label = gtk.Label()
     self.eventbox.add(self.label)
     self.label.show()
     if gtk.pygtk_version < (2, 12):
         self.set_tip(self.eventbox, _("Tip for status box ..."))
     else:
         self.eventbox.set_tooltip_text(_("Tip for status box ..."))
     pack(vbox, self.eventbox)
     self.ordered_indices = []
Beispiel #12
0
    def make_minimize_gui(self, box):
        self.algo = gtk.combo_box_new_text()
        for m in self.minimizers:
            self.algo.append_text(m)
        self.algo.set_active(0)
        self.algo.connect('changed', self.min_algo_specific)
        pack(box, [gtk.Label(_("Algorithm: ")), self.algo])
        
        self.fmax = gtk.Adjustment(0.05, 0.00, 10.0, 0.01)
        self.fmax_spin = gtk.SpinButton(self.fmax, 0, 3)
        lbl = gtk.Label()
        lbl.set_markup(_("Convergence criterion: F<sub>max</sub> = "))
        pack(box, [lbl, self.fmax_spin])

        self.steps = gtk.Adjustment(100, 1, 1000000, 1)
        self.steps_spin = gtk.SpinButton(self.steps, 0, 0)
        pack(box, [gtk.Label(_("Max. number of steps: ")), self.steps_spin])

        # Special stuff for MDMin
        lbl = gtk.Label(_("Pseudo time step: "))
        self.mdmin_dt = gtk.Adjustment(0.05, 0.0, 10.0, 0.01)
        spin = gtk.SpinButton(self.mdmin_dt, 0, 3)
        self.mdmin_widgets = [lbl, spin]
        pack(box, self.mdmin_widgets)
        self.min_algo_specific()
Beispiel #13
0
    def make_minimize_gui(self, box):
        self.algo = gtk.combo_box_new_text()
        for m in self.minimizers:
            self.algo.append_text(m)
        self.algo.set_active(0)
        self.algo.connect('changed', self.min_algo_specific)
        pack(box, [gtk.Label(_("Algorithm: ")), self.algo])

        self.fmax = gtk.Adjustment(0.05, 0.00, 10.0, 0.01)
        self.fmax_spin = gtk.SpinButton(self.fmax, 0, 3)
        lbl = gtk.Label()
        lbl.set_markup(_("Convergence criterion: F<sub>max</sub> = "))
        pack(box, [lbl, self.fmax_spin])

        self.steps = gtk.Adjustment(100, 1, 1000000, 1)
        self.steps_spin = gtk.SpinButton(self.steps, 0, 0)
        pack(box, [gtk.Label(_("Max. number of steps: ")), self.steps_spin])

        # Special stuff for MDMin
        lbl = gtk.Label(_("Pseudo time step: "))
        self.mdmin_dt = gtk.Adjustment(0.05, 0.0, 10.0, 0.01)
        spin = gtk.SpinButton(self.mdmin_dt, 0, 3)
        self.mdmin_widgets = [lbl, spin]
        pack(box, self.mdmin_widgets)
        self.min_algo_specific()
Beispiel #14
0
 def makebutbox(self, vbox, helptext=None):
     self.buttons = gtk.HButtonBox()
     runbut = gtk.Button(_("Run"))
     runbut.connect('clicked', self.run)
     closebut = gtk.Button(stock=gtk.STOCK_CLOSE)
     closebut.connect('clicked', lambda x: self.destroy())
     for w in (runbut, closebut):
         self.buttons.pack_start(w, 0, 0)
         w.show()
     if helptext:
         helpbut = [help(helptext)]
     else:
         helpbut = []
     pack(vbox, helpbut + [self.buttons], end=True, bottom=True)
Beispiel #15
0
 def makebutbox(self, vbox, helptext=None):
     self.buttons = gtk.HButtonBox()
     runbut = gtk.Button(_("Run"))
     runbut.connect('clicked', self.run)
     closebut = gtk.Button(stock=gtk.STOCK_CLOSE)
     closebut.connect('clicked', lambda x: self.destroy())
     for w in (runbut, closebut):
         self.buttons.pack_start(w, 0, 0)
         w.show()
     if helptext:
         helpbut = [help(helptext)]
     else:
         helpbut = []
     pack(vbox, helpbut + [self.buttons], end=True, bottom=True)
Beispiel #16
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.set_title('Repeat')
     vbox = gtk.VBox()
     pack(vbox, gtk.Label(_('Repeat atoms:')))
     self.repeat = [gtk.Adjustment(r, 1, 9, 1) for r in gui.images.repeat]
     pack(vbox, [gtk.SpinButton(r, 0, 0) for r in self.repeat])
     for r in self.repeat:
         r.connect('value-changed', self.change)
     button = pack(vbox, gtk.Button('Set unit cell'))
     button.connect('clicked', self.set_unit_cell)
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #17
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.set_title(_('Repeat'))
     vbox = gtk.VBox()
     pack(vbox, gtk.Label(_('Repeat atoms:')))
     self.repeat = [gtk.Adjustment(r, 1, 9, 1) for r in gui.images.repeat]
     pack(vbox, [gtk.SpinButton(r, 0, 0) for r in self.repeat])
     for r in self.repeat:
         r.connect('value-changed', self.change)
     button = pack(vbox, gtk.Button(_('Set unit cell')))
     button.connect('clicked', self.set_unit_cell)
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #18
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.gui = gui
     self.set_title(_("Expert user mode"))
     vbox = gtk.VBox()
     vbox.set_border_width(5)
     self.sw = gtk.ScrolledWindow()
     self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
     self.textview = gtk.TextView()
     self.textbuffer = self.textview.get_buffer()
     self.textview.set_editable(False)
     self.textview.set_cursor_visible(False)
     self.sw.add(self.textview)
     pack(vbox, self.sw, expand=True, padding=5)
     self.sw.set_size_request(540, 150)
     self.textview.show()
     self.add_text(_("Welcome to the ASE Expert user mode"))
     self.cmd = gtk.Entry(60)
     self.cmd.connect("activate", self.execute)
     self.cmd.connect("key-press-event", self.update_command_buffer)
     pack(vbox, [gtk.Label(">>>"), self.cmd])
     self.cmd_buffer = getattr(gui, "expert_mode_buffer", [""])
     self.cmd_position = len(self.cmd_buffer) - 1
     self.selected = gtk.CheckButton(_("Only selected atoms (sa)   "))
     self.selected.connect("toggled", self.selected_changed)
     self.images_only = gtk.CheckButton(_("Only current frame (cf)  "))
     self.images_only.connect("toggled", self.images_changed)
     pack(vbox, [self.selected, self.images_only])
     save_button = gtk.Button(stock=gtk.STOCK_SAVE)
     save_button.connect("clicked", self.save_output)
     help_button = gtk.Button(stock=gtk.STOCK_HELP)
     help_button.connect("clicked", self.terminal_help, "")
     stop_button = gtk.Button(stock=gtk.STOCK_STOP)
     stop_button.connect("clicked", self.stop_execution)
     self.stop = False
     pack(
         vbox,
         [
             gtk.Label(_("Global: Use A, D, E, M, N, R, S, n, frame;" " Atoms: Use a, f, m, s, x, y, z, Z     ")),
             stop_button,
             help_button,
             save_button,
         ],
         end=True,
     )
     self.add(vbox)
     vbox.show()
     self.show()
     # set color mode to manual when opening this window for rgb manipulation
     self.colors = self.gui.get_colors()
     rgb_data = self.gui.get_colors(rgb=True)
     self.rgb_data = []  # ensure proper format of rgb_data
     for i, rgb in enumerate(rgb_data):
         self.rgb_data += [[i, rgb]]
     self.gui.colordata = self.rgb_data
     self.gui.colors = list(self.colors)
     self.gui.colormode = "manual"
     self.cmd.grab_focus()
Beispiel #19
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     #self.window.set_position(gtk.WIN_POS_CENTER)
     #self.window.connect("destroy", lambda w: gtk.main_quit())
     #self.window.connect('delete_event', self.exit)
     self.set_title('Execute')
     vbox = gtk.VBox()
     self.cmd1, self.cmd2 = pack(vbox, [gtk.Entry(23),gtk.Entry(23)])
     self.cmd1.connect('activate', self.execute)
     self.cmd2.connect('activate', self.execute)
     self.selected = gtk.CheckButton('Only selected atoms')
     pack(vbox, self.selected)
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #20
0
 def __init__(self, gui):
     ui.Window.__init__(self)
     self.gui = gui
     self.set_title(_('Expert user mode'))
     vbox = ui.VBox()
     vbox.set_border_width(5)
     self.sw = ui.ScrolledWindow()
     self.sw.set_policy(ui.POLICY_AUTOMATIC, ui.POLICY_AUTOMATIC)
     self.textview = ui.TextView()
     self.textbuffer = self.textview.get_buffer()
     self.textview.set_editable(False)
     self.textview.set_cursor_visible(False)
     self.sw.add(self.textview)
     pack(vbox, self.sw, expand=True, padding=5)
     self.sw.set_size_request(540, 150)
     self.textview.show()
     self.add_text(_('Welcome to the ASE Expert user mode'))
     self.cmd = ui.Entry(60)
     self.cmd.connect('activate', self.execute)
     self.cmd.connect('key-press-event', self.update_command_buffer)
     pack(vbox, [ui.Label('>>>'), self.cmd])
     self.cmd_buffer = getattr(gui, 'expert_mode_buffer', [''])
     self.cmd_position = len(self.cmd_buffer) - 1
     self.selected = ui.CheckButton(_('Only selected atoms (sa)   '))
     self.selected.connect('toggled', self.selected_changed)
     self.images_only = ui.CheckButton(_('Only current frame (cf)  '))
     self.images_only.connect('toggled', self.images_changed)
     pack(vbox, [self.selected, self.images_only])
     save_button = ui.Button(_('Save'))
     save_button.connect('clicked', self.save_output)
     help_button = ui.Button(_('Help'))
     help_button.connect('clicked', self.terminal_help, "")
     stop_button = ui.Button(_('Stop'))
     stop_button.connect('clicked', self.stop_execution)
     self.stop = False
     pack(
         vbox, [
             ui.Label(
                 _('Global: Use A, D, E, M, N, R, S, n, frame;'
                   ' Atoms: Use a, f, m, s, x, y, z, Z     ')), stop_button,
             help_button, save_button
         ],
         end=True)
     self.add(vbox)
     vbox.show()
     self.show()
     # set color mode to manual when opening this window for rgb
     # manipulation
     self.colors = self.gui.get_colors()
     rgb_data = self.gui.get_colors(rgb=True)
     self.rgb_data = []  # ensure proper format of rgb_data
     for i, rgb in enumerate(rgb_data):
         self.rgb_data += [[i, rgb]]
     self.gui.colordata = self.rgb_data
     self.gui.colors = list(self.colors)
     self.gui.colormode = 'manual'
     self.cmd.grab_focus()
Beispiel #21
0
    def __init__(self, gui):
        gtk.Window.__init__(self)
        self.set_position(gtk.WIN_POS_NONE)
        self.connect('destroy', self.close)
        #self.connect('delete_event', self.exit2)
        self.set_title('Movie')
        vbox = gtk.VBox()
        pack(vbox, gtk.Label(_('Image number:')))
        self.frame_number = gtk.Adjustment(gui.frame, 0,
                                           gui.images.nimages - 1,
                                           1.0, 5.0)
        self.frame_number.connect('value-changed', self.new_frame)

        hscale = pack(vbox, gtk.HScale(self.frame_number))
        hscale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
        hscale.set_digits(0)

        buttons = [gtk.Button(stock=gtk.STOCK_GOTO_FIRST),
                   gtk.Button(stock=gtk.STOCK_GO_BACK),
                   gtk.Button(stock=gtk.STOCK_GO_FORWARD),
                   gtk.Button(stock=gtk.STOCK_GOTO_LAST)]

        for button in buttons:
            hboxb = button.child.child
            label = hboxb.get_children()[1]
            hboxb.remove(label)

        buttons[0].connect('clicked', self.click, -10000000)
        buttons[1].connect('clicked', self.click, -1)
        buttons[2].connect('clicked', self.click, 1)
        buttons[3].connect('clicked', self.click, 10000000)

        pack(vbox, buttons)

        play, stop = pack(vbox, [gtk.Button(_('Play')),
                                 gtk.Button('Stop')])
        play.connect('clicked', self.play)
        stop.connect('clicked', self.stop)

        self.rock = pack(vbox, gtk.CheckButton('Rock'))

        self.time = gtk.Adjustment(2.0, 0.5, 9.0, 0.2)
        hscale = pack(vbox, gtk.HScale(self.time))
        hscale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
            
        self.time.connect('value-changed', self.new_time)

        self.add(vbox)
        self.set_tip = gtk.Tooltips().set_tip
        self.set_tip(hscale, _('Adjust play time.'))
        vbox.show()
        self.show()
        self.gui = gui
        #gui.m=self
        self.direction = 1
        self.id = None
Beispiel #22
0
 def __init__(self, gui):
     ui.Window.__init__(self)
     self.gui = gui
     self.set_title(_('Expert user mode'))
     vbox = ui.VBox()
     vbox.set_border_width(5)
     self.sw = ui.ScrolledWindow()
     self.sw.set_policy(ui.POLICY_AUTOMATIC, ui.POLICY_AUTOMATIC)
     self.textview = ui.TextView()
     self.textbuffer = self.textview.get_buffer()
     self.textview.set_editable(False)
     self.textview.set_cursor_visible(False)
     self.sw.add(self.textview)
     pack(vbox, self.sw, expand=True, padding=5)
     self.sw.set_size_request(540, 150)
     self.textview.show()
     self.add_text(_('Welcome to the ASE Expert user mode'))
     self.cmd = ui.Entry(60)
     self.cmd.connect('activate', self.execute)
     self.cmd.connect('key-press-event', self.update_command_buffer)
     pack(vbox, [ui.Label('>>>'), self.cmd])
     self.cmd_buffer = getattr(gui, 'expert_mode_buffer', [''])
     self.cmd_position = len(self.cmd_buffer) - 1
     self.selected = ui.CheckButton(_('Only selected atoms (sa)   '))
     self.selected.connect('toggled', self.selected_changed)
     self.images_only = ui.CheckButton(_('Only current frame (cf)  '))
     self.images_only.connect('toggled', self.images_changed)
     pack(vbox, [self.selected, self.images_only])
     save_button = ui.Button(_('Save'))
     save_button.connect('clicked', self.save_output)
     help_button = ui.Button(_('Help'))
     help_button.connect('clicked', self.terminal_help, "")
     stop_button = ui.Button(_('Stop'))
     stop_button.connect('clicked', self.stop_execution)
     self.stop = False
     pack(vbox, [
         ui.Label(
             _('Global: Use A, D, E, M, N, R, S, n, frame;'
               ' Atoms: Use a, f, m, s, x, y, z, Z     ')), stop_button,
         help_button, save_button
     ],
          end=True)
     self.add(vbox)
     vbox.show()
     self.show()
     # set color mode to manual when opening this window for rgb
     # manipulation
     self.colors = self.gui.get_colors()
     rgb_data = self.gui.get_colors(rgb=True)
     self.rgb_data = []  # ensure proper format of rgb_data
     for i, rgb in enumerate(rgb_data):
         self.rgb_data += [[i, rgb]]
     self.gui.colordata = self.rgb_data
     self.gui.colors = list(self.colors)
     self.gui.colormode = 'manual'
     self.cmd.grab_focus()
Beispiel #23
0
    def __init__(self, gui):
        gtk.Window.__init__(self)
        self.set_title(_('DFT'))
        vbox = gtk.VBox()
        combo = gtk.combo_box_new_text()
        self.xcfuncs = 'None LDA PBE revPBE RPBE PW91 EXX PBE0'.split()
        for xc in self.xcfuncs:
            combo.append_text(xc)
        pack(vbox, [gtk.Label(_('XC-functional: ')), combo])

        button = radio(None, monkhorstpack)
        button = radio(button, special)
        pack(vbox, gtk.Label(_('Repeat atoms:')))
        self.kpts = [gtk.Adjustment(r, 1, 99, 1) for r in gui.atoms.repeat]
        pack(vbox, [gtk.SpinButton(r, 0, 0) for r in self.repeat])
        for r in self.repeat:
            r.connect('value-changed', self.change)

        close = pack(vbox, gtk.Button(_('Close')))
        close.connect('clicked', lambda widget: self.destroy())
        self.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui

        xc = gui.atoms.dft.get('xc', 'None')
        combo.set_active(self.xcfuncs.index(xc))
Beispiel #24
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     angles = irotate(gui.axes)
     self.set_title('Rotate')
     vbox = gtk.VBox()
     pack(vbox, gtk.Label('Rotation angles:'))
     self.rotate = [
         gtk.Adjustment(value=a,
                        lower=-360,
                        upper=360,
                        step_incr=1,
                        page_incr=10) for a in angles
     ]
     pack(vbox,
          [gtk.SpinButton(a, climb_rate=0, digits=1) for a in self.rotate])
     for r in self.rotate:
         r.connect('value-changed', self.change)
     button = pack(vbox, gtk.Button('Update'))
     button.connect('clicked', self.update_angles)
     pack(
         vbox,
         gtk.Label('Note:\nYou can rotate freely\n'
                   'with the mouse, by holding\n'
                   'down mouse botton 2.'))
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #25
0
    def __init__(self, gui):
        gtk.Window.__init__(self)
        self.set_title(_('DFT'))
        vbox = gtk.VBox()
        combo = gtk.combo_box_new_text()
        self.xcfuncs = 'None LDA PBE revPBE RPBE PW91 EXX PBE0'.split()
        for xc in self.xcfuncs:
            combo.append_text(xc)
        pack(vbox, [gtk.Label(_('XC-functional: ')), combo])

        button=radio(None,monkhorstpack)
        button=radio(button, special)
        pack(vbox, gtk.Label(_('Repeat atoms:')))
        self.kpts = [gtk.Adjustment(r, 1, 99, 1) for r in gui.atoms.repeat]
        pack(vbox, [gtk.SpinButton(r, 0, 0) for r in self.repeat])
        for r in self.repeat:
            r.connect('value-changed', self.change)

        close = pack(vbox, gtk.Button(_('Close')))
        close.connect('clicked', lambda widget: self.destroy())
        self.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui

        xc = gui.atoms.dft.get('xc', 'None')
        combo.set_active(self.xcfuncs.index(xc))
Beispiel #26
0
    def open(self, button=None):
        from ase.io.formats import all_formats, get_ioformat
        formats = [(_('Automatic'), None)]

        def key(item):
            return item[1][0]

        for format, (description, code) in sorted(all_formats.items(),
                                                  key=key):
            io = get_ioformat(format)
            if io.read and description != '?':
                formats.append((_(description), format))

        chooser = gtk.FileChooserDialog(
            _('Open ...'), None, gtk.FILE_CHOOSER_ACTION_OPEN,
            (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
             gtk.RESPONSE_OK))
        chooser.set_filename(_("<<filename>>"))

        # Add a file type filter
        name_to_format = {}
        types = gtk.combo_box_new_text()
        for name, format in formats:
            types.append_text(name)
            name_to_format[name] = format

        types.set_active(0)
        img_vbox = gtk.VBox()
        pack(img_vbox, [gtk.Label(_('File type:')), types])
        img_vbox.show()
        chooser.set_extra_widget(img_vbox)

        ok = chooser.run() == gtk.RESPONSE_OK
        if ok:
            filenames = [chooser.get_filename()]
            filetype = types.get_active_text()
        chooser.destroy()

        if not ok:
            return

        self.reset_tools_modes()
        self.images.read(filenames, slice(None), name_to_format[filetype])
        self.set_colors()
        self.set_coordinates(self.images.nimages - 1, focus=True)
Beispiel #27
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.set_title(_('Constraints'))
     vbox = gtk.VBox()
     b = pack(vbox, [gtk.Button(_('Constrain')),
                     gtk.Label(_(' selected atoms'))])[0]
     b.connect('clicked', self.selected)
     b = pack(vbox, [gtk.Button(_('Constrain')),
                     gtk.Label(_(' immobile atoms:'))])[0]
     b.connect('clicked', self.immobile)
     b = pack(vbox, gtk.Button('Clear constraints'))
     b.connect('clicked', self.clear)
     close = pack(vbox, gtk.Button(_('Close')))
     close.connect('clicked', lambda widget: self.destroy())
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #28
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.set_title(_("Quick Info"))
     vbox = gtk.VBox()
     images = gui.images
     if images.natoms < 1:
         txt = _("No atoms loaded.")
     else:
         (nimg, natoms, three) = images.P.shape
         assert three == 3
         img = gui.frame
         uc = images.A[img]
         if nimg > 1:
             equal = True
             for i in range(nimg):
                 equal = equal and (uc == images.A[i]).all()
             if equal:
                 uctxt = ucconst
             else:
                 uctxt = ucvaries
         else:
             uctxt = ""
         if nimg == 1:
             imgtxt = singleimage
         else:
             imgtxt = multiimage % (img, nimg - 1)
         
         periodic = [[_('no'), _('yes')][periodic]
                     for periodic in images.pbc]
         
         # TRANSLATORS: This has the form Periodic: no, no, yes
         pbcstring = _('Periodic: %s, %s, %s') % tuple(periodic)
         txt = format % ((imgtxt, natoms) + tuple(uc.flat) + 
                         (pbcstring,) + (uctxt,))
     label = gtk.Label(txt)
     pack(vbox, [label])
     but = gtk.Button(stock=gtk.STOCK_CLOSE)
     but.connect('clicked', self.close)
     pack(vbox, [but], end=True)
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #29
0
 def material_from_selection(self, *args):
     box_selection = self.get_selection()
     selection = self.gui.images.selected.copy()
     if selection.any():
         Z = []
         for n in range(len(selection)):
             if selection[n]:
                 Z += [self.gui.images.Z[n]]
         name = formula(Z)
         if (box_selection == selection).all():
             name += ': ' + self.texture_selection.get_text()
         texture_button = gtk.combo_box_new_text()
         for t in self.finish_list:
             texture_button.append_text(t)
         texture_button.set_active(1)
         transparency = gtk.Adjustment(0, 0.0, 1.0, 0.01)
         transparency_spin = gtk.SpinButton(transparency, 0, 0)
         transparency_spin.set_digits(2)
         delete_button = gtk.Button(stock=gtk.STOCK_DELETE)
         alignment = delete_button.get_children()[0]
         index = len(self.materials)
         delete_button.connect("clicked", self.delete_material,
                               {"n": index})
         self.materials += [[
             True, selection, texture_button,
             gtk.Label(_("  transparency: ")), transparency_spin,
             gtk.Label("   "), delete_button,
             gtk.Label()
         ]]
         self.materials[-1][-1].set_markup("    " + name)
         pack(self.tbox, [
             self.materials[-1][2], self.materials[-1][3],
             self.materials[-1][4], self.materials[-1][5],
             self.materials[-1][6], self.materials[-1][7]
         ])
     else:
         oops(
             _("Can not create new texture! Must have some atoms selected to create a new material!"
               ))
 def update_direction_table(self):
     "Update the part of the GUI containing the table of directions."
     #Discard old table
     oldwidgets = self.direction_table_box.get_children()
     assert len(oldwidgets) == 1
     oldwidgets[0].hide()
     self.direction_table_box.remove(oldwidgets[0])
     del oldwidgets  # It should now be gone
     tbl = gtk.Table(len(self.direction_table)+1, 7)
     pack(self.direction_table_box, [tbl])
     for i, data in enumerate(self.direction_table):
         tbl.attach(gtk.Label("%s: " % (str(data[0]),)),
                    0, 1, i, i+1)
         if self.method.get_active():
             # Wulff construction
             spin = gtk.SpinButton(data[2], 1.0, 3)
         else:
             # Layers
             spin = gtk.SpinButton(data[1], 1, 0)
         tbl.attach(spin, 1, 2, i, i+1)
         tbl.attach(gtk.Label("   "), 2, 3, i, i+1)
         but = gtk.Button(_("Up"))
         but.connect("clicked", self.row_swap_next, i-1)
         if i == 0:
             but.set_sensitive(False)
         tbl.attach(but, 3, 4, i, i+1)
         but = gtk.Button(_("Down"))
         but.connect("clicked", self.row_swap_next, i)
         if i == len(self.direction_table)-1:
             but.set_sensitive(False)
         tbl.attach(but, 4, 5, i, i+1)
         but = gtk.Button(_("Delete"))
         but.connect("clicked", self.row_delete, i)
         if len(self.direction_table) == 1:
             but.set_sensitive(False)
         tbl.attach(but, 5, 6, i, i+1)
     tbl.show_all()
     self.update()
Beispiel #31
0
 def makeoutputfield(self, box, label=_("Output:"), heading=None):
     frame = gtk.Frame(label)
     if box is not None:
         box.pack_start(frame, True, True, 0)
     box2 = gtk.VBox()
     frame.add(box2)
     if heading is not None:
         pack(box2, [gtk.Label(heading)])
     scrwin = gtk.ScrolledWindow()
     scrwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
     self.output = gtk.TextBuffer()
     txtview = gtk.TextView(self.output)
     txtview.set_editable(False)
     scrwin.add(txtview)
     scrwin.show_all()
     box2.pack_start(scrwin, True, True, 0)
     self.savebutton = gtk.Button(stock=gtk.STOCK_SAVE)
     self.savebutton.connect('clicked', self.saveoutput)
     self.savebutton.set_sensitive(False)
     pack(box2, [self.savebutton])
     box2.show()
     frame.show()
     return frame
Beispiel #32
0
 def makeoutputfield(self, box, label=_("Output:"), heading=None):
     frame = gtk.Frame(label)
     if box is not None:
         box.pack_start(frame, True, True, 0)
     box2 = gtk.VBox()
     frame.add(box2)
     if heading is not None:
         pack(box2, [gtk.Label(heading)])
     scrwin = gtk.ScrolledWindow()
     scrwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
     self.output = gtk.TextBuffer()
     txtview = gtk.TextView(self.output)
     txtview.set_editable(False)
     scrwin.add(txtview)
     scrwin.show_all()
     box2.pack_start(scrwin, True, True, 0)
     self.savebutton = gtk.Button(stock=gtk.STOCK_SAVE)
     self.savebutton.connect('clicked', self.saveoutput)
     self.savebutton.set_sensitive(False)
     pack(box2, [self.savebutton])
     box2.show()
     frame.show()
     return frame
Beispiel #33
0
 def packtext(self, vbox, text, label=None):
     "Pack an text frame into the window."
     pack(vbox, gtk.Label(""))
     txtframe = gtk.Frame(label)
     txtlbl = gtk.Label(text)
     txtframe.add(txtlbl)
     txtlbl.show()
     pack(vbox, txtframe)
     pack(vbox, gtk.Label(""))
Beispiel #34
0
 def packtext(self, vbox, text, label=None):
     "Pack an text frame into the window."
     pack(vbox, gtk.Label(""))
     txtframe = gtk.Frame(label)
     txtlbl = gtk.Label(text)
     txtframe.add(txtlbl)
     txtlbl.show()
     pack(vbox, txtframe)
     pack(vbox, gtk.Label(""))
Beispiel #35
0
    def __init__(self):
        DefaultProgressIndicator.__init__(self)

        # GPAW progress frame
        self.gpawframe = gtk.Frame("GPAW progress:")
        vbox = self.gpawvbox = gtk.VBox()
        self.gpawframe.add(vbox)
        self.table = gtk.Table(1, 2)
        self.tablerows = 0
        pack(vbox, self.table)
        self.status = gtk.Label("-")
        self.tablepack([gtk.Label(_("Status: ")), self.status])
        self.iteration = gtk.Label("-")
        self.tablepack([gtk.Label(_("Iteration: ")), self.iteration])
        self.tablepack([gtk.Label("")])
        lbl = gtk.Label()
        lbl.set_markup(_("log<sub>10</sub>(change):"))
        self.tablepack([gtk.Label(""), lbl])
        self.wfs_progress = gtk.ProgressBar()
        self.tablepack([gtk.Label(_("Wave functions: ")), self.wfs_progress])
        self.dens_progress = gtk.ProgressBar()
        self.tablepack([gtk.Label(_("Density: ")), self.dens_progress])
        self.energy_progress = gtk.ProgressBar()
        self.tablepack([gtk.Label(_("Energy: ")), self.energy_progress])
        self.tablepack([gtk.Label("")])
        self.versionlabel = gtk.Label("")
        self.tablepack([gtk.Label(_("GPAW version: ")), self.versionlabel])
        self.natomslabel = gtk.Label("")
        self.tablepack([gtk.Label(_("Number of atoms: ")), self.natomslabel])
        self.memorylabel = gtk.Label(_("N/A"))
        self.tablepack([gtk.Label(_("Memory estimate: ")), self.memorylabel])
        self.globalbox.pack_start(self.gpawframe)
        self.gpawframe.show()

        vbox.show()
        self.active = False
Beispiel #36
0
 def add_basis_atom(self, *args):
     """ add an atom to the customizable basis """
     n = len(self.elements)
     self.elements += [[
         gtk.Entry(max=3),
         gtk.Entry(max=8),
         gtk.Entry(max=8),
         gtk.Entry(max=8),
         gtk.Label('\t\t\t'),
         gtk.Label('\tx: '),
         gtk.Label('  y: '),
         gtk.Label('  z: '),
         gtk.Label(' '),
         gtk.Button(stock=gtk.STOCK_DELETE), True
     ]]
     self.elements[n][-2].connect("clicked", self.delete_basis_atom,
                                  {'n': n})
     pack(self.vbox_basis, [
         self.elements[n][4], self.elements[n][0], self.elements[n][5],
         self.elements[n][1], self.elements[n][6], self.elements[n][2],
         self.elements[n][7], self.elements[n][3], self.elements[n][8],
         self.elements[n][9]
     ])
     self.update()
Beispiel #37
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.set_title("Quick Info")
     vbox = gtk.VBox()
     images = gui.images
     if images.natoms < 1:
         txt = "No atoms loaded."
     else:
         (nimg, natoms, three) = images.P.shape
         assert three == 3
         img = gui.frame
         uc = images.A[img]
         if nimg > 1:
             equal = True
             for i in range(nimg):
                 equal = equal and (uc == images.A[i]).all()
             if equal:
                 uctxt = ucconst
             else:
                 uctxt = ucvaries
         else:
             uctxt = ""
         if nimg == 1:
             imgtxt = singleimage
         else:
             imgtxt = multiimage % (img, nimg-1)
         txt = format % ((imgtxt, natoms) + tuple(uc.flat) + (uctxt,))
     label = gtk.Label(txt)
     pack(vbox, [label])
     but = gtk.Button(stock=gtk.STOCK_CLOSE)
     but.connect('clicked', self.close)
     pack(vbox, [but], end=True)
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #38
0
 def __init__(self, gui):
     Simulation.__init__(self, gui)
     self.set_title(_("Potential energy and forces"))
     self.set_default_size(-1, 400)
     vbox = gtk.VBox()
     self.packtext(vbox, _("Calculate potential energy and the force on all " "atoms"))
     self.packimageselection(vbox)
     pack(vbox, gtk.Label(""))
     self.forces = gtk.CheckButton(_("Write forces on the atoms"))
     self.forces.set_active(True)
     pack(vbox, [self.forces])
     pack(vbox, [gtk.Label("")])
     self.makeoutputfield(vbox)
     pack(vbox, gtk.Label(""))
     self.makebutbox(vbox)
     vbox.show()
     self.add(vbox)
     self.show()
     self.gui.register_vulnerable(self)
Beispiel #39
0
 def __init__(self, gui):
     Simulation.__init__(self, gui)
     self.set_title("Potential energy and forces")
     self.set_default_size(-1, 400)
     vbox = gtk.VBox()
     self.packtext(vbox,
                   "Calculate potential energy and the force on all atoms")
     self.packimageselection(vbox)
     pack(vbox, gtk.Label(""))
     self.forces = gtk.CheckButton("Write forces on the atoms")
     self.forces.set_active(True)
     pack(vbox, [self.forces])
     pack(vbox, [gtk.Label("")])
     self.makeoutputfield(vbox)
     pack(vbox, gtk.Label(""))
     self.makebutbox(vbox)
     vbox.show()
     self.add(vbox)
     self.show()
     self.gui.register_vulnerable(self)
Beispiel #40
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.gui = gui
     self.set_title('Expert user mode')
     vbox = gtk.VBox()
     vbox.set_border_width(5)
     self.sw = gtk.ScrolledWindow()
     self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
     self.textview = gtk.TextView()
     self.textbuffer = self.textview.get_buffer()
     self.textview.set_editable(False)
     self.textview.set_cursor_visible(False)
     self.sw.add(self.textview)
     pack(vbox, self.sw, expand=True, padding=5)
     self.sw.set_size_request(540, 150)
     self.textview.show()
     self.add_text('Welcome to the ASE Expert user mode')
     self.cmd = gtk.Entry(60)
     self.cmd.connect('activate', self.execute)
     self.cmd.connect('key-press-event', self.update_command_buffer)
     pack(vbox, [gtk.Label('>>>'), self.cmd])
     self.cmd_buffer = getattr(gui, 'expert_mode_buffer', [''])
     self.cmd_position = len(self.cmd_buffer) - 1
     self.selected = gtk.CheckButton('Only selected atoms (sa)   ')
     self.selected.connect('toggled', self.selected_changed)
     self.images_only = gtk.CheckButton('Only current frame (cf)  ')
     self.images_only.connect('toggled', self.images_changed)
     pack(vbox, [self.selected, self.images_only])
     save_button = gtk.Button(stock=gtk.STOCK_SAVE)
     save_button.connect('clicked', self.save_output)
     help_button = gtk.Button(stock=gtk.STOCK_HELP)
     help_button.connect('clicked', self.terminal_help, "")
     pack(vbox, [
         gtk.Label('Global: Use n, N, R, A, S, D, E, frame;' +
                   ' Atoms: Use a, x, y, z, f, s, Z     '), help_button,
         save_button
     ])
     self.add(vbox)
     vbox.show()
     self.show()
     self.cmd.grab_focus()
Beispiel #41
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     angles = irotate(gui.axes)
     self.set_title(_('Rotate'))
     vbox = gtk.VBox()
     pack(vbox, gtk.Label(_('Rotation angles:')))
     self.rotate = [gtk.Adjustment(value=a, lower=-360, upper=360,
                                   step_incr=1, page_incr=10)
                    for a in angles]
     pack(vbox, [gtk.SpinButton(a, climb_rate=0, digits=1)
                 for a in self.rotate])
     for r in self.rotate:
         r.connect('value-changed', self.change)
     button = pack(vbox, gtk.Button(_('Update')))
     button.connect('clicked', self.update_angles)
     pack(vbox, gtk.Label(_('Note:\nYou can rotate freely\n'
                            'with the mouse, by holding\n'
                            'down mouse button 2.')))
     self.add(vbox)
     vbox.show()
     self.show()
     self.gui = gui
Beispiel #42
0
    def __init__(self, gui):
        Simulation.__init__(self, gui)
        self.set_title(_("Energy minimization"))
        
        vbox = gtk.VBox()
        self.packtext(vbox,
                      _("Minimize the energy with respect to the positions."))
        self.packimageselection(vbox)
        pack(vbox, gtk.Label(""))

        self.make_minimize_gui(vbox)
        
        pack(vbox, gtk.Label(""))
        self.status_label = gtk.Label("")
        pack(vbox, [self.status_label])
        self.makebutbox(vbox)
        vbox.show()
        self.add(vbox)
        self.show()
        self.gui.register_vulnerable(self)
Beispiel #43
0
    def __init__(self, gui):
        Simulation.__init__(self, gui)
        self.set_title(_("Energy minimization"))

        vbox = gtk.VBox()
        self.packtext(vbox,
                      _("Minimize the energy with respect to the positions."))
        self.packimageselection(vbox)
        pack(vbox, gtk.Label(""))

        self.make_minimize_gui(vbox)

        pack(vbox, gtk.Label(""))
        self.status_label = gtk.Label("")
        pack(vbox, [self.status_label])
        self.makebutbox(vbox)
        vbox.show()
        self.add(vbox)
        self.show()
        self.gui.register_vulnerable(self)
Beispiel #44
0
 def __init__(self, title, time, code):
     gtk.Window.__init__(self)
     self.set_title(_("ag: Python code"))
     vbox = gtk.VBox()
     lbl = gtk.Label(fr1_template % dict(title=title, time=time))
     lbl.set_alignment(0.0, 0.5)
     fr = gtk.Frame(_("Information:"))
     fr.add(lbl)
     pack(vbox, fr)
     txtbuf = gtk.TextBuffer()
     txtbuf.set_text(code)
     txtview = gtk.TextView(txtbuf)
     txtview.set_editable(False)
     fr = gtk.Frame(_("Python code:"))
     fr.add(txtview)
     fr.set_label_align(0.0, 0.5)
     pack(vbox, fr)
     but = gtk.Button(stock=gtk.STOCK_OK)
     but.connect('clicked', lambda x: self.destroy())
     pack(vbox, [but], end=True, bottom=True)
     self.add(vbox)
     self.show_all()
Beispiel #45
0
 def __init__(self, title, time, code):
     gtk.Window.__init__(self)
     self.set_title(_("ag: Python code"))
     vbox = gtk.VBox()
     lbl = gtk.Label(fr1_template % dict(title=title, time=time))
     lbl.set_alignment(0.0, 0.5)
     fr = gtk.Frame(_("Information:"))
     fr.add(lbl)
     pack(vbox, fr)
     txtbuf = gtk.TextBuffer()
     txtbuf.set_text(code)
     txtview = gtk.TextView(txtbuf)
     txtview.set_editable(False)
     fr = gtk.Frame(_("Python code:"))
     fr.add(txtview)
     fr.set_label_align(0.0, 0.5)
     pack(vbox, fr)
     but =  gtk.Button(stock=gtk.STOCK_OK)
     but.connect('clicked', lambda x: self.destroy())
     pack(vbox, [but], end=True, bottom=True)
     self.add(vbox)
     self.show_all()
Beispiel #46
0
    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.update_element)
        self.bondlength = gtk.Adjustment(1.42, 0.0, 1000.0, 0.01)
        label2 = gtk.Label("  Bond length: ")
        label3 = gtk.Label("Å")
        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.n.connect('value-changed', self.update_n)
        self.m.connect('value-changed', self.update_m)

        # 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.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui
Beispiel #47
0
 def __init__(self, gui):
     gtk.Window.__init__(self)
     self.gui = gui
     self.colormode = gui.colormode
     self.actual_colordata = None
     self.set_title(_("Colors"))
     vbox = gtk.VBox()
     self.add(vbox)
     vbox.show()
     # The main layout consists of two columns, the leftmost split in an upper and lower part.
     self.maintable = gtk.Table(2,2)
     pack(vbox, self.maintable)
     self.methodbox = gtk.VBox()
     self.methodbox.show()
     self.maintable.attach(self.methodbox, 0, 1, 0, 1)
     self.scalebox = gtk.VBox()
     self.scalebox.show()
     self.maintable.attach(self.scalebox, 0, 1, 1, 2)
     self.colorbox = gtk.Frame()
     self.colorbox.show()
     self.maintable.attach(self.colorbox, 1, 2, 0, 2, gtk.EXPAND)
     # Upper left: Choose how the atoms are colored.
     lbl = gtk.Label(_("Choose how the atoms are colored:"))
     pack(self.methodbox, [lbl])
     self.radio_jmol = gtk.RadioButton(None, _('By atomic number, default "jmol" colors'))
     self.radio_atno = gtk.RadioButton(self.radio_jmol,
                                       _('By atomic number, user specified'))
     self.radio_tag = gtk.RadioButton(self.radio_jmol, _('By tag'))
     self.radio_force = gtk.RadioButton(self.radio_jmol, _('By force'))
     self.radio_velocity = gtk.RadioButton(self.radio_jmol, _('By velocity'))
     self.radio_manual = gtk.RadioButton(self.radio_jmol, _('Manually specified'))
     self.radio_same = gtk.RadioButton(self.radio_jmol, _('All the same color'))
     self.force_box = gtk.VBox()
     self.velocity_box = gtk.VBox()
     for widget in (self.radio_jmol, self.radio_atno, self.radio_tag,
                   self.radio_force, self.force_box, self.radio_velocity,
                   self.velocity_box, self.radio_manual, self.radio_same):
         pack(self.methodbox, [widget])
         if isinstance(widget, gtk.RadioButton):
             widget.connect('toggled', self.method_radio_changed)
     # Now fill in the box for additional information in case the force is used.
     self.force_label = gtk.Label(_("This should not be displayed!"))
     pack(self.force_box, [self.force_label])
     self.force_min = gtk.Adjustment(0.0, 0.0, 100.0, 0.05)
     self.force_max = gtk.Adjustment(0.0, 0.0, 100.0, 0.05)
     self.force_steps = gtk.Adjustment(10, 2, 500, 1)
     force_apply = gtk.Button(_('Update'))
     force_apply.connect('clicked', self.set_force_colors)
     pack(self.force_box, [gtk.Label(_('Min: ')),
                           gtk.SpinButton(self.force_min, 10.0, 2),
                           gtk.Label(_('  Max: ')),
                           gtk.SpinButton(self.force_max, 10.0, 2),
                           gtk.Label(_('  Steps: ')),
                           gtk.SpinButton(self.force_steps, 1, 0),
                           gtk.Label('  '),
                           force_apply])
     self.force_box.hide()
     # Now fill in the box for additional information in case the velocity is used.
     self.velocity_label = gtk.Label("This should not be displayed!")
     pack(self.velocity_box, [self.velocity_label])
     self.velocity_min = gtk.Adjustment(0.0, 0.0, 10.0, 0.005)
     self.velocity_max = gtk.Adjustment(0.0, 0.0, 10.0, 0.005)
     self.velocity_steps = gtk.Adjustment(10, 2, 500, 1)
     velocity_apply = gtk.Button(_('Update'))
     velocity_apply.connect('clicked', self.set_velocity_colors)
     pack(self.velocity_box, [gtk.Label(_('Min: ')),
                              gtk.SpinButton(self.velocity_min, 10.0, 3),
                              gtk.Label(_('  Max: ')),
                              gtk.SpinButton(self.velocity_max, 10.0, 3),
                              gtk.Label(_('  Steps: ')),
                              gtk.SpinButton(self.velocity_steps, 1, 0),
                              gtk.Label('  '),
                              velocity_apply])
     self.velocity_box.hide()
     # Lower left: Create a color scale
     pack(self.scalebox, gtk.Label(""))
     lbl = gtk.Label(_('Create a color scale:'))
     pack(self.scalebox, [lbl])
     color_scales = (
         _('Black - white'),
         _('Black - red - yellow - white'),
         _('Black - green - white'),
         _('Black - blue - cyan'),
         _('Hue'),
         _('Named colors')
         )
     self.scaletype_created = None
     self.scaletype = gtk.combo_box_new_text()
     for s in color_scales:
         self.scaletype.append_text(s)
     self.createscale = gtk.Button(_("Create"))
     pack(self.scalebox, [self.scaletype, self.createscale])
     self.createscale.connect('clicked', self.create_color_scale)
     # The actually colors are specified in a box possibly with scrollbars
     self.colorwin = gtk.ScrolledWindow()
     self.colorwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
     self.colorwin.show()
     self.colorbox.add(self.colorwin)
     self.colorwin.add_with_viewport(gtk.VBox()) # Dummy contents
     buts = cancel_apply_ok(cancel=lambda widget: self.destroy(),
                            apply=self.apply,
                            ok=self.ok)
     pack(vbox, [buts], end=True, bottom=True)
     # Make the initial setup of the colors
     self.color_errors = {}
     self.init_colors_from_gui()
     self.show()
     gui.register_vulnerable(self)
Beispiel #48
0
 def __init__(self, gui):
     self.gui = gui
     gtk.Window.__init__(self)
     self.set_title(_('Render current view in povray ... '))
     vbox = gtk.VBox()
     vbox.set_border_width(5)
     self.natoms = self.gui.images.natoms
     pack(vbox, [gtk.Label(_("Rendering %d atoms.") % self.natoms)])
     self.size = [gtk.Adjustment(self.gui.width, 1, 9999, 50),
                  gtk.Adjustment(self.gui.height, 1, 9999, 50)]
     self.width = gtk.SpinButton(self.size[0], 0, 0)
     self.height = gtk.SpinButton(self.size[1], 0, 0)
     self.render_constraints = gtk.CheckButton(_("Render constraints"))
     self.render_constraints.set_sensitive(not self.gui.images.dynamic.all())
     self.render_constraints.connect("toggled",self.toggle_render_lines)
     pack(vbox, [gtk.Label(_("Width")), self.width,
                 gtk.Label(_("     Height")), self.height,
                 gtk.Label("       "),self.render_constraints])
     self.width.connect('value-changed',self.change_width,"")
     self.height.connect('value-changed',self.change_height,"")
     self.sizeratio = gui.width/float(gui.height)
     self.line_width = gtk.SpinButton(gtk.Adjustment(0.07,0.01,9.99,0.01), 0, 0)
     self.line_width.set_digits(3)
     self.render_cell = gtk.CheckButton(_("Render unit cell"))
     if self.gui.ui.get_widget('/MenuBar/ViewMenu/ShowUnitCell').get_active():
         self.render_cell.set_active(True)
     else:
         self.render_cell.set_active(False)
         self.render_cell.set_sensitive(False)
     self.render_cell.connect("toggled",self.toggle_render_lines)
     have_lines = (not self.gui.images.dynamic.all()) or self.render_cell.get_active()
     self.line_width.set_sensitive(have_lines)
     pack(vbox, [gtk.Label(_("Line width")),
                 self.line_width,
                 gtk.Label(_("Angstrom           ")),
                 self.render_cell])
     pack(vbox, [gtk.Label("")])
     filename = gui.window.get_title()
     len_suffix = len(filename.split('.')[-1])+1
     if len(filename) > len_suffix:
         filename = filename[:-len_suffix]
     self.basename = gtk.Entry(max = 30)
     self.basename.connect("activate",self.set_outputname,"")
     self.basename.set_text(basename(filename))
     set_name = gtk.Button(_("Set"))
     set_name.connect("clicked",self.set_outputname,"")
     pack(vbox,[gtk.Label(_("Output basename: ")), self.basename,set_name])
     self.outputname = gtk.Label("")
     pack(vbox,[gtk.Label(_("               Filename: ")),self.outputname])
     pack(vbox,[gtk.Label("")])
     self.tbox = gtk.VBox()
     self.tbox.set_border_width(10)
     self.default_texture = gtk.combo_box_new_text()
     for t in self.finish_list:
         self.default_texture.append_text(t)
     self.default_texture.set_active(1)
     self.default_transparency = gtk.Adjustment(0,0.0,1.0,0.01)
     self.transparency = gtk.SpinButton(self.default_transparency, 0, 0)
     self.transparency.set_digits(2)
     pack(self.tbox,[gtk.Label(_(" Default texture for atoms: ")), self.default_texture,
                     gtk.Label(_("    transparency: ")),self.transparency])
     pack(self.tbox,[gtk.Label(_("Define atom selection for new texture:"))])
     self.texture_selection = gtk.Entry(max = 50)
     self.texture_select_but = gtk.Button(_("Select"))
     self.texture_selection.connect("activate",self.select_texture,"")
     self.texture_select_but.connect("clicked",self.select_texture,"")
     pack(self.tbox,[self.texture_selection, self.texture_select_but])
     self.create_texture = gtk.Button(_("Create new texture from selection"))
     self.create_texture.connect("clicked",self.material_from_selection,"")
     self.selection_help_but = gtk.Button(_("Help on textures"))
     self.selection_help_but.connect("clicked",self.selection_help,"")
     self.materials = []
     pack(self.tbox,[self.create_texture,
                     gtk.Label("       "), self.selection_help_but])
     pack(vbox,[self.tbox])
     pack(vbox,[gtk.Label("")])
     self.camera_style = gtk.combo_box_new_text()
     for c in self.cameras:
         self.camera_style.append_text(c)
     self.camera_style.set_active(0)
     self.camera_distance = gtk.SpinButton(gtk.Adjustment(50.0,-99.0,99.0,1.0), 0, 0)
     self.camera_distance.set_digits(1)
     pack(vbox,[gtk.Label(_("Camera type: ")),self.camera_style,
                gtk.Label(_("     Camera distance")),self.camera_distance])
     self.single_frame = gtk.RadioButton(None,_("Render current frame"))
     self.nimages = self.gui.images.nimages
     self.iframe = self.gui.frame
     self.movie = gtk.RadioButton(self.single_frame,
                                  _("Render all %d frames") % self.nimages)
     self.movie.connect("toggled",self.set_movie)
     self.movie.set_sensitive(self.nimages > 1)
     self.set_outputname()
     pack(vbox,[self.single_frame,gtk.Label("   "),self.movie])
     self.transparent = gtk.CheckButton(_("Transparent background"))
     self.transparent.set_active(True)
     pack(vbox,[self.transparent])
     self.run_povray = gtk.CheckButton(_("Run povray       "))
     self.run_povray.set_active(True)
     self.run_povray.connect("toggled",self.toggle_run_povray,"")
     self.keep_files = gtk.CheckButton(_("Keep povray files       "))
     self.keep_files.set_active(False)
     self.keep_files_status = True
     self.window_open = gtk.CheckButton(_("Show output window"))
     self.window_open.set_active(True)
     self.window_open_status = True
     pack(vbox,[self.run_povray,self.keep_files,self.window_open])
     pack(vbox,[gtk.Label("")])
     cancel_but = gtk.Button(stock=gtk.STOCK_CANCEL)
     cancel_but.connect('clicked', lambda widget: self.destroy())
     ok_but = gtk.Button(stock=gtk.STOCK_OK)
     ok_but.connect('clicked', self.ok)
     close_but = gtk.Button(stock=gtk.STOCK_CLOSE)
     close_but.connect('clicked', lambda widget: self.destroy())
     butbox = gtk.HButtonBox()
     butbox.pack_start(cancel_but, 0, 0)
     butbox.pack_start(ok_but, 0, 0)
     butbox.pack_start(close_but, 0, 0)
     butbox.show_all()
     pack(vbox, [butbox], end=True, bottom=True)
     self.add(vbox)
     vbox.show()
     self.show()
Beispiel #49
0
    def __init__(self, gui):
        SetupWindow.__init__(self)
        self.set_title(_("Create Bulk Crystal by Spacegroup"))
        self.atoms = None
        vbox = gtk.VBox()
        self.packtext(vbox, introtext)
        self.structinfo = gtk.combo_box_new_text()
        self.structures = {}
        for c in crystal_definitions:
            self.structinfo.append_text(c[0])
            self.structures[c[0]] = c
        self.structinfo.set_active(0)
        self.structinfo.connect("changed", self.set_lattice_type)
        self.spacegroup = gtk.Entry(max=14)
        self.spacegroup.set_text('P 1')
        self.elementinfo = gtk.Label("")
        self.spacegroupinfo = gtk.Label(_('Number: 1'))
        pack(vbox, [
            gtk.Label(_("Lattice: ")), self.structinfo,
            gtk.Label(_("\tSpace group: ")), self.spacegroup,
            gtk.Label('  '), self.spacegroupinfo,
            gtk.Label('  '), self.elementinfo
        ])
        pack(vbox, [gtk.Label("")])
        self.size = [gtk.Adjustment(1, 1, 100, 1) for i in range(3)]
        buttons = [gtk.SpinButton(s, 0, 0) for s in self.size]
        pack(vbox, [
            gtk.Label(_("Size: x: ")), buttons[0],
            gtk.Label(_("  y: ")), buttons[1],
            gtk.Label(_("  z: ")), buttons[2],
            gtk.Label(_(" unit cells"))
        ])
        pack(vbox, [gtk.Label("")])
        self.lattice_lengths = [
            gtk.Adjustment(3.0, 0.0, 1000.0, 0.01) for i in range(3)
        ]
        self.lattice_angles = [
            gtk.Adjustment(90.0, 0.0, 180.0, 1) for i in range(3)
        ]
        self.lattice_lbuts = [
            gtk.SpinButton(self.lattice_lengths[i], 0, 0) for i in range(3)
        ]
        self.lattice_abuts = [
            gtk.SpinButton(self.lattice_angles[i], 0, 0) for i in range(3)
        ]
        for i in self.lattice_lbuts:
            i.set_digits(5)
        for i in self.lattice_abuts:
            i.set_digits(3)
        self.lattice_lequals = [gtk.combo_box_new_text() for i in range(3)]
        self.lattice_aequals = [gtk.combo_box_new_text() for i in range(3)]
        self.lattice_lequals[0].append_text(_('free'))
        self.lattice_lequals[0].append_text(_('equals b'))
        self.lattice_lequals[0].append_text(_('equals c'))
        self.lattice_lequals[0].append_text(_('fixed'))
        self.lattice_lequals[1].append_text(_('free'))
        self.lattice_lequals[1].append_text(_('equals a'))
        self.lattice_lequals[1].append_text(_('equals c'))
        self.lattice_lequals[1].append_text(_('fixed'))
        self.lattice_lequals[2].append_text(_('free'))
        self.lattice_lequals[2].append_text(_('equals a'))
        self.lattice_lequals[2].append_text(_('equals b'))
        self.lattice_lequals[2].append_text(_('fixed'))
        self.lattice_aequals[0].append_text(_('free'))
        self.lattice_aequals[0].append_text(_('equals beta'))
        self.lattice_aequals[0].append_text(_('equals gamma'))
        self.lattice_aequals[0].append_text(_('fixed'))
        self.lattice_aequals[1].append_text(_('free'))
        self.lattice_aequals[1].append_text(_('equals alpha'))
        self.lattice_aequals[1].append_text(_('equals gamma'))
        self.lattice_aequals[1].append_text(_('fixed'))
        self.lattice_aequals[2].append_text(_('free'))
        self.lattice_aequals[2].append_text(_('equals alpha'))
        self.lattice_aequals[2].append_text(_('equals beta'))
        self.lattice_aequals[2].append_text(_('fixed'))
        for i in range(3):
            self.lattice_lequals[i].set_active(0)
            self.lattice_aequals[i].set_active(0)
        pack(vbox, [gtk.Label(_('Lattice parameters'))])
        pack(vbox, [
            gtk.Label(_('\t\ta:\t')), self.lattice_lbuts[0],
            gtk.Label('  '), self.lattice_lequals[0],
            gtk.Label(_('\talpha:\t')), self.lattice_abuts[0],
            gtk.Label('  '), self.lattice_aequals[0]
        ])
        pack(vbox, [
            gtk.Label(_('\t\tb:\t')), self.lattice_lbuts[1],
            gtk.Label('  '), self.lattice_lequals[1],
            gtk.Label(_('\tbeta:\t')), self.lattice_abuts[1],
            gtk.Label('  '), self.lattice_aequals[1]
        ])
        pack(vbox, [
            gtk.Label(_('\t\tc:\t')), self.lattice_lbuts[2],
            gtk.Label('  '), self.lattice_lequals[2],
            gtk.Label(_('\tgamma:\t')), self.lattice_abuts[2],
            gtk.Label('  '), self.lattice_aequals[2]
        ])
        self.get_data = gtk.Button(_("Get from database"))
        self.get_data.connect("clicked", self.get_from_database)
        self.get_data.set_sensitive(False)
        pack(vbox, [gtk.Label("     "), self.get_data])
        pack(vbox, [gtk.Label("")])
        pack(vbox, [gtk.Label(_("Basis: "))])
        self.elements = [[
            gtk.Entry(max=3),
            gtk.Entry(max=8),
            gtk.Entry(max=8),
            gtk.Entry(max=8), True
        ]]
        self.element = self.elements[0][0]
        add_atom = gtk.Button(stock=gtk.STOCK_ADD)
        add_atom.connect("clicked", self.add_basis_atom)
        add_atom.connect("activate", self.add_basis_atom)
        pack(vbox, [
            gtk.Label(_('  Element:\t')), self.elements[0][0],
            gtk.Label(_('\tx: ')), self.elements[0][1],
            gtk.Label(_('  y: ')), self.elements[0][2],
            gtk.Label(_('  z: ')), self.elements[0][3],
            gtk.Label('\t'), add_atom
        ])
        self.vbox_basis = gtk.VBox()
        swin = gtk.ScrolledWindow()
        swin.set_border_width(0)
        swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        vbox.pack_start(swin, True, True, 0)
        swin.add_with_viewport(self.vbox_basis)
        self.vbox_basis.get_parent().set_shadow_type(gtk.SHADOW_NONE)
        self.vbox_basis.get_parent().set_size_request(-1, 100)
        swin.show()

        pack(self.vbox_basis, [gtk.Label('')])
        pack(vbox, [self.vbox_basis])
        self.vbox_basis.show()
        pack(vbox, [gtk.Label("")])
        self.status = gtk.Label("")
        pack(vbox, [self.status])
        pack(vbox, [gtk.Label("")])
        self.pybut = PyButton(_("Creating a crystal."))
        self.pybut.connect('clicked', self.update)

        clear = gtk.Button(stock=gtk.STOCK_CLEAR)
        clear.connect("clicked", self.clear)
        buts = cancel_apply_ok(cancel=lambda widget: self.destroy(),
                               apply=self.apply,
                               ok=self.ok)
        pack(vbox, [self.pybut, clear, buts], end=True, bottom=True)
        self.structinfo.connect("changed", self.update)
        self.spacegroup.connect("activate", self.update)
        for s in self.size:
            s.connect("value-changed", self.update)
        for el in self.elements:
            if el[-1]:
                for i in el[:-1]:
                    i.connect("activate", self.update)
                    i.connect("changed", self.update)
        for i in range(3):
            self.lattice_lbuts[i].connect("value-changed", self.update)
            self.lattice_abuts[i].connect("value-changed", self.update)
            self.lattice_lequals[i].connect("changed", self.update)
            self.lattice_aequals[i].connect("changed", self.update)
        self.clearing_in_process = False
        self.gui = gui
        self.add(vbox)
        vbox.show()
        self.show()
Beispiel #50
0
    def __init__(self, gui):
        SetupWindow.__init__(self)
        self.set_title(_("Graphene"))
        vbox = gtk.VBox()

        # Intoductory text
        self.packtext(vbox, introtext)

        # Choose structure
        label = gtk.Label(_("Structure: "))
        self.struct = gtk.combo_box_new_text()
        for s in (_("Infinite sheet"), _("Unsaturated ribbon"),
                  _("Saturated ribbon")):
            self.struct.append_text(s)
        self.struct.set_active(0)
        self.struct.connect('changed', self.update_gui)
        pack(vbox, [label, self.struct])

        # Orientation
        label = gtk.Label(_("Orientation: "))
        self.orient = gtk.combo_box_new_text()
        self.orient_text = []
        for s in (_("zigzag"), _("armchair")):
            self.orient.append_text(s)
            self.orient_text.append(s)
        self.orient.set_active(0)
        self.orient.connect('changed', self.update_gui)
        pack(vbox, [label, self.orient])
        pack(vbox, gtk.Label(""))

        # 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.update_element)
        self.bondlength = gtk.Adjustment(1.42, 0.0, 1000.0, 0.01)
        label2 = gtk.Label(_("  Bond length: "))
        label3 = gtk.Label(_("Å"))
        bond_box = gtk.SpinButton(self.bondlength, 10.0, 3)
        pack(vbox, [label1, self.element, label2, bond_box, label3])

        # Choose the saturation element and bond length
        self.sat_label1 = gtk.Label(_("Saturation: "))
        #label.set_alignment(0.0, 0.2)
        self.element2 = gtk.Entry(max=3)
        self.element2.set_text(_("H"))
        self.element2.connect('activate', self.update_element)
        self.bondlength2 = gtk.Adjustment(1.12, 0.0, 1000.0, 0.01)
        self.sat_label2 = gtk.Label(_("  Bond length: "))
        self.sat_label3 = gtk.Label(_("Å"))
        self.bond_box = gtk.SpinButton(self.bondlength2, 10.0, 3)
        pack(vbox, [
            self.sat_label1, self.element2, self.sat_label2, self.bond_box,
            self.sat_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(""))

        # Size
        label1 = gtk.Label(_("Width: "))
        label2 = gtk.Label(_("  Length: "))
        self.n = gtk.Adjustment(1, 1, 100, 1)
        self.m = gtk.Adjustment(1, 1, 100, 1)
        spinn = gtk.SpinButton(self.n, 0, 0)
        spinm = gtk.SpinButton(self.m, 0, 0)
        pack(vbox, [label1, spinn, label2, spinm])

        # Vacuum
        label1 = gtk.Label(_("Vacuum: "))
        self.vacuum = gtk.Adjustment(5.0, 0.0, 1000.0, 0.1)
        label2 = gtk.Label(_("Å"))
        vac_box = gtk.SpinButton(self.vacuum, 10.0, 2)
        pack(vbox, [label1, vac_box, label2])
        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, [buts], end=True, bottom=True)

        # Finalize setup
        self.update_gui()
        self.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui
Beispiel #51
0
    def __init__(self, gui):
        gtk.Window.__init__(self)
        self.set_title('Settings')
        self.gui = gui
        vbox = gtk.VBox()

        # Constraints
        a = pack(vbox, gtk.Label())
        a.set_markup('<span size="larger" underline="single">'
                     '%s</span>' % _('Constraints:'))
        a, b = pack(vbox, [gtk.Button(_('Constrain')),
                           gtk.Label('/'),
                           gtk.Button(_('release')),                        
                           gtk.Label(_(' selected atoms'))])[::2]
        a.connect('clicked', self.constrain_selected)
        b.connect('clicked', self.release_selected)
        a = pack(vbox, gtk.Button(_('Constrain immobile atoms')))
        a.connect('clicked', self.immobile)
        a = pack(vbox, gtk.Button(_('Clear all constraints')))
        a.connect('clicked', self.clear_constraints)

        # Visibility
        a = pack(vbox, gtk.Label())
        a.set_markup('\n<span size="larger" underline="single">'
                     '%s</span>' % _('Visibility:'))
        a, b = pack(vbox, [gtk.Button(_('Hide')),
                           gtk.Label('/'),
                           gtk.Button(_('show')),
                           gtk.Label(_(' selected atoms'))])[::2]
        a.connect('clicked', self.hide_selected)
        b.connect('clicked', self.show_selected)
        a = pack(vbox, gtk.Button(_('View all atoms')))
        a.connect('clicked', self.view_all)

        # Miscellaneous
        a = pack(vbox, gtk.Label())
        a.set_markup('\n<span size="larger" underline="single">'
                     '%s</span>' % _('Miscellaneous:'))
        self.scale = gtk.Adjustment(value=.89, lower=0.2, upper=2.0,
                                    step_incr=0.1, page_incr=0.5)
        pack(vbox, [gtk.Label(_('Scale atomic radii:')),
                    gtk.SpinButton(self.scale, climb_rate=0, digits=2)])
        self.scale.connect('value-changed', self.scale_radii)

        # A close button
        pack(vbox, gtk.Label(_('\n')))
        close = pack(vbox, gtk.Button(_('Close')))
        close.connect('clicked', lambda widget: self.destroy())

        # Add elements and show frame
        self.add(vbox)
        vbox.show()
        self.show()
Beispiel #52
0
 def __init__(self, gui):
     self.gui = gui
     gtk.Window.__init__(self)
     self.set_title(_('Render current view in povray ... '))
     vbox = gtk.VBox()
     vbox.set_border_width(5)
     self.natoms = self.gui.images.natoms
     pack(vbox, [gtk.Label(_("Rendering %d atoms.") % self.natoms)])
     self.size = [
         gtk.Adjustment(self.gui.width, 1, 9999, 50),
         gtk.Adjustment(self.gui.height, 1, 9999, 50)
     ]
     self.width = gtk.SpinButton(self.size[0], 0, 0)
     self.height = gtk.SpinButton(self.size[1], 0, 0)
     self.render_constraints = gtk.CheckButton(_("Render constraints"))
     self.render_constraints.set_sensitive(
         not self.gui.images.dynamic.all())
     self.render_constraints.connect("toggled", self.toggle_render_lines)
     pack(vbox, [
         gtk.Label(_("Width")), self.width,
         gtk.Label(_("     Height")), self.height,
         gtk.Label("       "), self.render_constraints
     ])
     self.width.connect('value-changed', self.change_width, "")
     self.height.connect('value-changed', self.change_height, "")
     self.sizeratio = gui.width / float(gui.height)
     self.line_width = gtk.SpinButton(
         gtk.Adjustment(0.07, 0.01, 9.99, 0.01), 0, 0)
     self.line_width.set_digits(3)
     self.render_cell = gtk.CheckButton(_("Render unit cell"))
     if self.gui.ui.get_widget(
             '/MenuBar/ViewMenu/ShowUnitCell').get_active():
         self.render_cell.set_active(True)
     else:
         self.render_cell.set_active(False)
         self.render_cell.set_sensitive(False)
     self.render_cell.connect("toggled", self.toggle_render_lines)
     have_lines = (not self.gui.images.dynamic.all()
                   ) or self.render_cell.get_active()
     self.line_width.set_sensitive(have_lines)
     pack(vbox, [
         gtk.Label(_("Line width")), self.line_width,
         gtk.Label(_("Angstrom           ")), self.render_cell
     ])
     pack(vbox, [gtk.Label("")])
     filename = gui.window.get_title()
     len_suffix = len(filename.split('.')[-1]) + 1
     if len(filename) > len_suffix:
         filename = filename[:-len_suffix]
     self.basename = gtk.Entry(max=30)
     self.basename.connect("activate", self.set_outputname, "")
     self.basename.set_text(basename(filename))
     set_name = gtk.Button(_("Set"))
     set_name.connect("clicked", self.set_outputname, "")
     pack(vbox,
          [gtk.Label(_("Output basename: ")), self.basename, set_name])
     self.outputname = gtk.Label("")
     pack(vbox,
          [gtk.Label(_("               Filename: ")), self.outputname])
     pack(vbox, [gtk.Label("")])
     self.tbox = gtk.VBox()
     self.tbox.set_border_width(10)
     self.default_texture = gtk.combo_box_new_text()
     for t in self.finish_list:
         self.default_texture.append_text(t)
     self.default_texture.set_active(1)
     self.default_transparency = gtk.Adjustment(0, 0.0, 1.0, 0.01)
     self.transparency = gtk.SpinButton(self.default_transparency, 0, 0)
     self.transparency.set_digits(2)
     pack(self.tbox, [
         gtk.Label(_(" Default texture for atoms: ")), self.default_texture,
         gtk.Label(_("    transparency: ")), self.transparency
     ])
     pack(self.tbox,
          [gtk.Label(_("Define atom selection for new texture:"))])
     self.texture_selection = gtk.Entry(max=50)
     self.texture_select_but = gtk.Button(_("Select"))
     self.texture_selection.connect("activate", self.select_texture, "")
     self.texture_select_but.connect("clicked", self.select_texture, "")
     pack(self.tbox, [self.texture_selection, self.texture_select_but])
     self.create_texture = gtk.Button(
         _("Create new texture from selection"))
     self.create_texture.connect("clicked", self.material_from_selection,
                                 "")
     self.selection_help_but = gtk.Button(_("Help on textures"))
     self.selection_help_but.connect("clicked", self.selection_help, "")
     self.materials = []
     pack(self.tbox, [
         self.create_texture,
         gtk.Label("       "), self.selection_help_but
     ])
     pack(vbox, [self.tbox])
     pack(vbox, [gtk.Label("")])
     self.camera_style = gtk.combo_box_new_text()
     for c in self.cameras:
         self.camera_style.append_text(c)
     self.camera_style.set_active(0)
     self.camera_distance = gtk.SpinButton(
         gtk.Adjustment(50.0, -99.0, 99.0, 1.0), 0, 0)
     self.camera_distance.set_digits(1)
     pack(vbox, [
         gtk.Label(_("Camera type: ")), self.camera_style,
         gtk.Label(_("     Camera distance")), self.camera_distance
     ])
     self.single_frame = gtk.RadioButton(None, _("Render current frame"))
     self.nimages = self.gui.images.nimages
     self.iframe = self.gui.frame
     self.movie = gtk.RadioButton(self.single_frame,
                                  _("Render all %d frames") % self.nimages)
     self.movie.connect("toggled", self.set_movie)
     self.movie.set_sensitive(self.nimages > 1)
     self.set_outputname()
     pack(vbox, [self.single_frame, gtk.Label("   "), self.movie])
     self.transparent = gtk.CheckButton(_("Transparent background"))
     self.transparent.set_active(True)
     pack(vbox, [self.transparent])
     self.run_povray = gtk.CheckButton(_("Run povray       "))
     self.run_povray.set_active(True)
     self.run_povray.connect("toggled", self.toggle_run_povray, "")
     self.keep_files = gtk.CheckButton(_("Keep povray files       "))
     self.keep_files.set_active(False)
     self.keep_files_status = True
     self.window_open = gtk.CheckButton(_("Show output window"))
     self.window_open.set_active(True)
     self.window_open_status = True
     pack(vbox, [self.run_povray, self.keep_files, self.window_open])
     pack(vbox, [gtk.Label("")])
     cancel_but = gtk.Button(stock=gtk.STOCK_CANCEL)
     cancel_but.connect('clicked', lambda widget: self.destroy())
     ok_but = gtk.Button(stock=gtk.STOCK_OK)
     ok_but.connect('clicked', self.ok)
     close_but = gtk.Button(stock=gtk.STOCK_CLOSE)
     close_but.connect('clicked', lambda widget: self.destroy())
     butbox = gtk.HButtonBox()
     butbox.pack_start(cancel_but, 0, 0)
     butbox.pack_start(ok_but, 0, 0)
     butbox.pack_start(close_but, 0, 0)
     butbox.show_all()
     pack(vbox, [butbox], end=True, bottom=True)
     self.add(vbox)
     vbox.show()
     self.show()
Beispiel #53
0
    def __init__(self, gui):
        # Set defaults
        self.log_file = None
        self.fchk_file = None
        self.coords = None
        self.scaling_method = "global"

        # Set up window
        gtk.Window.__init__(self)
        self.set_title("Level Diagrams")
        self.gui = gui
        vbox = gtk.VBox()
        vbox.set_border_width(5)

        # Button to select G09 log file
        a = pack(vbox, gtk.Label())
        self.log_entry_box, b = pack(vbox, [gtk.Entry(max=25), gtk.Button(_("Choose Gaussian output file"))])
        self.log_entry_box.set_max_length(0)
        self.log_entry_box.connect("activate", self.log_entry)
        b.connect("clicked", self.choose_log_file)

        # Button to select fchk file
        a = pack(vbox, gtk.Label())
        self.fchk_entry_box, b = pack(vbox, [gtk.Entry(max=25), gtk.Button(_("Choose fchk file"))])
        self.fchk_entry_box.set_max_length(0)
        self.fchk_entry_box.connect("activate", self.log_entry)
        b.connect("clicked", self.choose_fchk_file)

        # Dial to set number of occupied orbitals
        self.occ_scale = gtk.Adjustment(value=2, lower=0, upper=100, step_incr=1)
        self.occ_spinner = gtk.SpinButton(self.occ_scale, climb_rate=0, digits=0)
        self.occ_spinner.set_update_policy(gtk.UPDATE_IF_VALID)
        self.occ_spinner.set_numeric(True)
        pack(vbox, [gtk.Label(_("Plot ")), self.occ_spinner, gtk.Label(_("occupied states "))])
        self.occ_scale.connect("value-changed", self.scale_occ_orb)

        # Dial to set number of virtual orbitals
        self.virt_scale = gtk.Adjustment(value=2, lower=0, upper=100, step_incr=1)
        self.virt_spinner = gtk.SpinButton(self.virt_scale, climb_rate=0, digits=0)
        self.virt_spinner.set_update_policy(gtk.UPDATE_IF_VALID)
        self.virt_spinner.set_numeric(True)
        pack(vbox, [gtk.Label(_("Plot ")), self.virt_spinner, gtk.Label(_("unoccupied states "))])
        self.virt_scale.connect("value-changed", self.scale_virt_orb)

        # Dial to set number of bins
        self.bin_scale = gtk.Adjustment(value=0.3, lower=0.3, upper=0.5, step_incr=0.05)
        self.bin_spinner = gtk.SpinButton(self.bin_scale, climb_rate=0.05, digits=2)
        self.bin_spinner.set_update_policy(gtk.UPDATE_IF_VALID)
        self.bin_spinner.set_numeric(True)
        pack(vbox, [gtk.Label(_(u"Grid spacing (\u212B) ")), self.bin_spinner])
        pack(vbox, gtk.Label(_("Note that the grid spacing should be large compared to the width of the voxels.")))
        self.bin_scale.connect("value-changed", self.scale_bin_num)

        # Button to select atoms
        a = pack(vbox, gtk.Label())
        a, b = pack(vbox, [gtk.Label(_("Select two points and click ")), gtk.Button(_("Confirm"))])
        b.connect("clicked", self.confirm_points)

        # Button to set scaling
        a = pack(vbox, gtk.Label("Intensity scaling"))
        button = pack(vbox, gtk.RadioButton(None, "Global"))
        button.connect("toggled", self.set_scaling_method, "global")
        button.show()

        button = pack(vbox, gtk.RadioButton(button, "Orbital"))
        button.connect("toggled", self.set_scaling_method, "orbital")
        button.show()

        # Button to set all of the parameters
        a = pack(vbox, gtk.Label())
        a = pack(vbox, gtk.Button(_("Run")))
        a.connect("clicked", self.run_sold)

        # Add elements and show frame
        self.add(vbox)
        vbox.show()
        self.show()
Beispiel #54
0
    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.update_element)
        self.bondlength = gtk.Adjustment(1.42, 0.0, 1000.0, 0.01)
        label2 = gtk.Label(_("  Bond length: "))
        label3 = gtk.Label(_("Å"))
        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(""))

        # 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.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui
Beispiel #55
0
    def __init__(self):
        gtk.Window.__init__(self)
        self.set_title(_("Progress"))
        self.globalbox = gtk.VBox()
        self.nextupdate = 0
        self.fmax_max = 1.0
        
        # Scaling deformation progress frame
        self.scalebox = gtk.VBox()
        self.scaleframe = gtk.Frame(_("Scaling deformation:"))
        vbox = gtk.VBox()
        self.scaleframe.add(vbox)
        pack(self.scalebox, [self.scaleframe])
        pack(self.scalebox, gtk.Label(""))

        self.label_scale_stepno_format = _("Step number %s of %s.")
        self.label_scale_stepno = gtk.Label(
            self.label_scale_stepno_format % ("-" , "-"))
        pack(vbox, [self.label_scale_stepno])
        self.scale_progress = gtk.ProgressBar()
        self.scale_progress.modify_bg(gtk.STATE_PRELIGHT,
                                      gtk.gdk.color_parse('#00AA00'))
        pack(vbox, [self.scale_progress])

        vbox.show()
        self.scaleframe.show()
        self.globalbox.pack_start(self.scalebox)
        
        # Minimization progress frame
        self.minbox = gtk.VBox()  # Box containing frame and spacing
        self.minframe = gtk.Frame(_("Energy minimization:"))
        vbox = gtk.VBox()         # Box containing the frames content.
        self.minframe.add(vbox)
        pack(self.minbox, [self.minframe])
        pack(self.minbox, gtk.Label(""))
        
        self.label_min_stepno = gtk.Label("-")
        pack(vbox, [gtk.Label(_("Step number: ")), self.label_min_stepno])
        lbl = gtk.Label()
        lbl.set_markup(_("F<sub>max</sub>: "))
        self.minimize_progress = gtk.ProgressBar()
        pack(vbox, [lbl, self.minimize_progress])
        self.label_min_fmax = gtk.Label("-")
        lbl = gtk.Label()
        lbl.set_markup(_("Convergence criterion: F<sub>max</sub> = "))
        pack(vbox, [lbl, self.label_min_fmax])
        self.label_min_maxsteps = gtk.Label("-")
        pack(vbox, [gtk.Label(_("Max. number of steps: ")),
                    self.label_min_maxsteps])
        
        vbox.show()
        self.minframe.show()
        self.globalbox.pack_start(self.minbox)
        self.globalbox.show()
        self.add(self.globalbox)

        # Make the cancel button
        self.cancelbut = gtk.Button(stock=gtk.STOCK_CANCEL)
        self.cancelbut.connect('clicked', self.cancel)
        pack(self.globalbox, [self.cancelbut], end=True, bottom=True)
Beispiel #56
0
    def __init__(self, gui):
        SetupWindow.__init__(self)
        self.set_title("Nanoparticle")
        self.atoms = None
        self.no_update = True

        vbox = gtk.VBox()

        # Intoductory text
        self.packtext(vbox, introtext)

        # Choose the element
        label = gtk.Label("Element: ")
        label.set_alignment(0.0, 0.2)
        element = gtk.Entry(max=3)
        self.element = element
        lattice_button = gtk.Button("Get structure")
        lattice_button.connect('clicked', self.set_structure_data)
        self.elementinfo = gtk.Label(" ")
        pack(vbox, [label, element, self.elementinfo, lattice_button],
             end=True)
        self.element.connect('activate', self.update)
        self.legal_element = False

        # The structure and lattice constant
        label = gtk.Label("Structure: ")
        self.structure = gtk.combo_box_new_text()
        self.list_of_structures = []
        self.needs_4index = {}
        self.needs_2lat = {}
        self.factory = {}
        for abbrev, name, n4, c, factory in self.structure_data:
            self.structure.append_text(name)
            self.list_of_structures.append(abbrev)
            self.needs_4index[abbrev] = n4
            self.needs_2lat[abbrev] = c
            self.factory[abbrev] = factory
        self.structure.set_active(0)
        self.fourindex = self.needs_4index[self.list_of_structures[0]]
        self.structure.connect('changed', self.update_structure)

        label2 = gtk.Label("Lattice constant:  a =")
        self.lattice_const_a = gtk.Adjustment(3.0, 0.0, 1000.0, 0.01)
        self.lattice_const_c = gtk.Adjustment(5.0, 0.0, 1000.0, 0.01)
        self.lattice_box_a = gtk.SpinButton(self.lattice_const_a, 10.0, 3)
        self.lattice_box_c = gtk.SpinButton(self.lattice_const_c, 10.0, 3)
        self.lattice_box_a.numeric = True
        self.lattice_box_c.numeric = True
        self.lattice_label_c = gtk.Label(" c =")
        pack(vbox, [label, self.structure])
        pack(vbox, [
            label2, self.lattice_box_a, self.lattice_label_c,
            self.lattice_box_c
        ])
        self.lattice_label_c.hide()
        self.lattice_box_c.hide()
        self.lattice_const_a.connect('value-changed', self.update)
        self.lattice_const_c.connect('value-changed', self.update)

        # Choose specification method
        label = gtk.Label("Method: ")
        self.method = gtk.combo_box_new_text()
        for meth in ("Layer specification", "Wulff construction"):
            self.method.append_text(meth)
        self.method.set_active(0)
        self.method.connect('changed', self.update_gui_method)
        pack(vbox, [label, self.method])
        pack(vbox, gtk.Label(""))
        self.old_structure = None

        frame = gtk.Frame()
        pack(vbox, frame)
        framebox = gtk.VBox()
        frame.add(framebox)
        framebox.show()
        self.layerlabel = gtk.Label("Missing text")  # Filled in later
        pack(framebox, [self.layerlabel])
        # This box will contain a single table that is replaced when
        # the list of directions is changed.
        self.direction_table_box = gtk.VBox()
        pack(framebox, self.direction_table_box)
        pack(self.direction_table_box, gtk.Label("Dummy placeholder object"))
        pack(framebox, gtk.Label(""))
        pack(framebox, [gtk.Label("Add new direction:")])
        self.newdir_label = []
        self.newdir_box = []
        self.newdir_index = []
        packlist = []
        for txt in ('(', ', ', ', ', ', '):
            self.newdir_label.append(gtk.Label(txt))
            adj = gtk.Adjustment(0, -100, 100, 1)
            self.newdir_box.append(gtk.SpinButton(adj, 1, 0))
            self.newdir_index.append(adj)
            packlist.append(self.newdir_label[-1])
            packlist.append(self.newdir_box[-1])
        self.newdir_layers = gtk.Adjustment(5, 0, 100, 1)
        self.newdir_layers_box = gtk.SpinButton(self.newdir_layers, 1, 0)
        self.newdir_esurf = gtk.Adjustment(1.0, 0, 1000.0, 0.1)
        self.newdir_esurf_box = gtk.SpinButton(self.newdir_esurf, 10, 3)
        addbutton = gtk.Button("Add")
        addbutton.connect('clicked', self.row_add)
        packlist.extend([
            gtk.Label("): "), self.newdir_layers_box, self.newdir_esurf_box,
            gtk.Label("  "), addbutton
        ])
        pack(framebox, packlist)
        self.defaultbutton = gtk.Button("Set all directions to default values")
        self.defaultbutton.connect('clicked', self.default_direction_table)
        self.default_direction_table()

        # Extra widgets for the Wulff construction
        self.wulffbox = gtk.VBox()
        pack(vbox, self.wulffbox)
        label = gtk.Label("Particle size: ")
        self.size_n_radio = gtk.RadioButton(None, "Number of atoms: ")
        self.size_n_radio.set_active(True)
        self.size_n_adj = gtk.Adjustment(100, 1, 100000, 1)
        self.size_n_spin = gtk.SpinButton(self.size_n_adj, 0, 0)
        self.size_dia_radio = gtk.RadioButton(self.size_n_radio, "Volume: ")
        self.size_dia_adj = gtk.Adjustment(1.0, 0, 100.0, 0.1)
        self.size_dia_spin = gtk.SpinButton(self.size_dia_adj, 10.0, 2)
        pack(self.wulffbox, [
            label, self.size_n_radio, self.size_n_spin,
            gtk.Label("   "), self.size_dia_radio, self.size_dia_spin,
            gtk.Label("ų")
        ])
        self.size_n_radio.connect("toggled", self.update_gui_size)
        self.size_dia_radio.connect("toggled", self.update_gui_size)
        self.size_n_adj.connect("value-changed", self.update_size_n)
        self.size_dia_adj.connect("value-changed", self.update_size_dia)
        label = gtk.Label(
            "Rounding: If exact size is not possible, choose the size")
        pack(self.wulffbox, [label])
        self.round_above = gtk.RadioButton(None, "above  ")
        self.round_below = gtk.RadioButton(self.round_above, "below  ")
        self.round_closest = gtk.RadioButton(self.round_above, "closest  ")
        self.round_closest.set_active(True)
        butbox = gtk.HButtonBox()
        self.smaller_button = gtk.Button("Smaller")
        self.larger_button = gtk.Button("Larger")
        self.smaller_button.connect('clicked', self.wulff_smaller)
        self.larger_button.connect('clicked', self.wulff_larger)
        pack(butbox, [self.smaller_button, self.larger_button])
        buts = [self.round_above, self.round_below, self.round_closest]
        for b in buts:
            b.connect("toggled", self.update)
        buts.append(butbox)
        pack(self.wulffbox, buts, end=True)

        # Information
        pack(vbox, gtk.Label(""))
        infobox = gtk.VBox()
        label1 = gtk.Label("Number of atoms: ")
        self.natoms_label = gtk.Label("-")
        label2 = gtk.Label("   Approx. diameter: ")
        self.dia1_label = gtk.Label("-")
        pack(infobox, [label1, self.natoms_label, label2, self.dia1_label])
        pack(infobox, gtk.Label(""))
        infoframe = gtk.Frame("Information about the created cluster:")
        infoframe.add(infobox)
        infobox.show()
        pack(vbox, infoframe)

        # Buttons
        self.pybut = PyButton("Creating a nanoparticle.")
        self.pybut.connect('clicked', self.makeatoms)
        helpbut = help(helptext)
        buts = cancel_apply_ok(cancel=lambda widget: self.destroy(),
                               apply=self.apply,
                               ok=self.ok)
        pack(vbox, [self.pybut, helpbut, buts], end=True, bottom=True)
        self.auto = gtk.CheckButton("Automatic Apply")
        fr = gtk.Frame()
        fr.add(self.auto)
        fr.show_all()
        pack(vbox, [fr], end=True, bottom=True)

        # Finalize setup
        self.update_structure()
        self.update_gui_method()
        self.add(vbox)
        vbox.show()
        self.show()
        self.gui = gui
        self.no_update = False