Python Combobox.get方法代码示例

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class FrOptions(LabelFrame):
    def __init__(self, title, txt, dicoprofils):
        LabelFrame.__init__(self, text=title)
        self.listing_profils(dicoprofils)

        # Dropdowm list of available profiles
        self.ddprofils = Combobox(self,
                                  values = dicoprofils.keys(),
                                  width = 35,
                                  height = len(dicoprofils.keys())*20)
        self.ddprofils.current(1)   # set the dropdown list to first element

        # export options
        caz_doc = Checkbutton(self, text = u'HTML / Word (.doc/.docx)',
                                    variable = self.master.opt_doc)
        caz_xls = Checkbutton(self, text = u'Excel 2003 (.xls)',
                                    variable = self.master.opt_xls)
        caz_xml = Checkbutton(self, text = u'XML (ISO 19139)',
                                    variable = self.master.opt_xml)

        # Basic buttons
        self.action = StringVar()
        self.action.set(txt.get('gui_choprofil'))
        self.val = Button(self, textvariable = self.action,
                                relief= 'raised',
                                command = self.bell)
        can = Button(self, text = 'Cancel (quit)',
                                relief= 'groove',
                                command = self.master.destroy)
        # Widgets placement
        self.ddprofils.bind('<<ComboboxSelected>>', self.alter_val)
        self.ddprofils.grid(row = 1, column = 0, columnspan = 3, sticky = N+S+W+E, padx = 2, pady = 5)
        caz_doc.grid(row = 2, column = 0, sticky = N+S+W, padx = 2, pady = 1)
        caz_xls.grid(row = 3, column = 0, sticky = N+S+W, padx = 2, pady = 1)
        caz_xml.grid(row = 4, column = 0, sticky = N+S+W, padx = 2, pady = 1)
        self.val.grid(row = 5, column = 0, columnspan = 2,
                            sticky = N+S+W+E, padx = 2, pady = 5)
        can.grid(row = 5, column = 2, sticky = N+S+W+E, padx = 2, pady = 5)

    def listing_profils(self, dictprofils):
        u""" List existing profilesin folder \data\profils """
        for i in glob(r'../data/profils/*.xml'):
            dictprofils[path.splitext(path.basename(i))[0]] = i
##        if new > 0:
##            listing_lang()
##            load_textes(deroul_lang.get())
##            deroul_profils.setlist(sorted(dico_profils.keys()))
##            fen_choix.update()
        # End of function
        return dictprofils

    def alter_val(self, inutile):
        u""" Switch the label of the validation button contained in basics class
        in the case that a new profile is going to be created"""
        if self.ddprofils.get() == self.master.blabla.get('gui_nouvprofil'):
            self.action.set(self.master.blabla.get('gui_crprofil'))
        else:
            self.action.set(self.master.blabla.get('gui_choprofil'))
        # End of functionFin de fonction
        return self.action

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class ComboBox(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.parent = parent
        self.initUI()
        self.speed = 1.0

    def initUI(self):
        self.parent.title("Combobox")
        self.pack(fill = BOTH, expand=True)
        frame = Frame(self)
        frame.pack(fill=X)
        
        field = Label(frame, text = "Typing Speed:", width = 15)
        field.pack(side = LEFT, padx = 5, pady = 5)
        
        self.box_value = StringVar()
        self.box = Combobox(frame, textvariable=self.box_value, width = 5)
        self.box['values'] = ('1x', '2x', '5x', '10x' )
        self.box.current(0)
        self.box.pack(fill = X, padx =5, expand = True)
        self.box.bind("<<ComboboxSelected>>", self.value)
        

    def value(self,event):
        self.speed =  float(self.box.get()[:-1])

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class PreferencesDialog(Dialog):
    def __init__(self, parent, title, font, size):
        self._master = parent
        self.result = False
        self.font = font
        self.size = size
        Dialog.__init__(self, parent, title)

    def body(self, master):
        self._npFrame = LabelFrame(master, text='Annotation window text')
        self._npFrame.pack(fill=X)
        self._fontFrame = Frame(self._npFrame, borderwidth=0)
        self._fontLabel = Label(self._fontFrame, text='Font:', width=5)
        self._fontLabel.pack(side=LEFT, padx=3)
        self._fontCombo = Combobox(self._fontFrame, values=sorted(families()),
                                   state='readonly')
        self._fontCombo.pack(side=RIGHT, fill=X)
        self._sizeFrame = Frame(self._npFrame, borderwidth=0)
        self._sizeLabel = Label(self._sizeFrame, text='Size:', width=5)
        self._sizeLabel.pack(side=LEFT, padx=3)
        self._sizeCombo = Combobox(self._sizeFrame, values=range(8,15),
                                   state='readonly')
        self._sizeCombo.pack(side=RIGHT, fill=X)
        self._fontFrame.pack()
        self._sizeFrame.pack()
        self._npFrame.pack(fill=X)
        self._fontCombo.set(self.font)
        self._sizeCombo.set(self.size)

    def apply(self):
        self.font = self._fontCombo.get()
        self.size = self._sizeCombo.get()
        self.result = True

    def cancel(self, event=None):
        if self.parent is not None:
           self.parent.focus_set()
        self.destroy()

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class LevelsWindow(Tk):
    def __init__(self, menu):
        Tk.__init__(self)
        
        self.title("Pick a level")
        
        icon = PhotoImage(file=os.getcwd() + '/res/logo/logo.gif')
        self.tk.call("wm", "iconphoto", self._w, icon)
        
        self.eval('tk::PlaceWindow %s center' % self.winfo_pathname(self.winfo_id()))
        
        self.levels = [file[:-4] for file in listdir("res/levels")]
        self.protocol("WM_DELETE_WINDOW", self.shutdownTTK)
        
        if not self.levels:  # No levels
            self.withdraw()
            tkMessageBox.showwarning("Error", 'There doesn\'t seem to be any levels saved. Create one pressing the "Design Level" button!')
            self.shutdownTTK()
            
        else:
            self.menu = menu
            
            self.value = StringVar()
            self.levels_list = Combobox(self, textvariable=self.value, state='readonly')
            
            self.levels_list['values'] = self.levels
            self.levels_list.current(0)
            self.levels_list.grid(column=0, row=0)
            
            self.button = Button(self, text="Begin Level", command=self.begin_level)
            self.button.grid(column=0, row=1)
            self.mainloop()
    
            
            
    def begin_level(self):
        level = self.levels_list.get()
        self.shutdownTTK()
        self.menu.call_to("GameWindow", level)
    
    
    def shutdownTTK(self):
        # For some unholy reason, TTK won't shut down when we destroy the window
        # so we have to explicitly kill it.
        self.eval('::ttk::CancelRepeat')
        self.destroy()

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class ConnectGui:
    def __init__(self,root):
	root.title("Connect Four") 
	self.turn= 1 
	self.last_piece= None
	self.p1= None
	self.p2= None

	frame = Frame(root)
	frame.pack(side=TOP)

	label1 = Label(frame, text="Player 1:")
	label1.pack(side= LEFT)
	
	self.combobox = Combobox(frame, values= ('Human', 'Minimax', 'Random'))
        self.combobox.pack(side=LEFT)

	label2 = Label(frame, text="Player 2:")
        label2.pack(side=LEFT)

	self.combobox1 = Combobox(frame, values= ('Human', 'Minimax','Random'))
        self.combobox1.pack(side= LEFT)

	frame2= Frame(root)
	frame2.pack(side=TOP)

	label3= Label(frame2, text= "(If Minimax Chosen) Ply-Depth:")
	label3.pack(side= LEFT) 
	
	self.spinner = Spinbox(frame2,width=5,from_=2, to=5)
	self.spinner.pack(side= LEFT ) 

	playbutton = Button(frame2, text= "Start Game", command= self.play_game) 
	playbutton.pack(side= LEFT, padx= 20) 

	frame1= Frame(root)
	frame1.pack(side=TOP)

	for x in range(7):
	    button0 = Button(frame1, text= "Column %i" %(x+1), command = functools.partial(self.human_turn,x))
	    button0.grid(row=0, column= x) 
	
	self.b= connectfour.ConnectFour()
	self.board= Canvas(frame1, width= 705, height= 605)
	self.board.grid(row= 1, columnspan=7) 

	#for x in range(7):
	#    self.board.create_line(5, x*100+5, 705,x*100+5)
	#for x in range(8):    
	#    self.board.create_line(x*100+5, 5, x*100+5, 605)
	
    def human_turn(self, col):
	assert self.p1 and self.p2!= None
	assert self.b.is_game_over()== None
	if self.b.board[5][col]== None:
	    y= 0 
	    while self.b.board[y][col]!= None:
		y+=1
	    self.b.play_turn(self.turn, col)
	if self.last_piece!= None:
	    self.board.itemconfig(self.last_piece, outline= "black", width= 1) 
	if self.turn== 1: 
	    self.last_piece= self.board.create_oval(100*col+5,505-100*y,100*col+105,605-100*y, fill= "red", outline= "green", width= 5)
	    self.turn=2
	    if self.b.is_game_over()!= None:
	        win= self.b.is_game_over()
		for i in range(4):
   		    self.board.create_oval(100*(win[1]+i*win[3])+5,505-100*(win[0]+i*win[2]),100*(win[1]+i*win[3])+105,605-100*(win[0]+i*win[2]), outline= "blue", width= 7)
		return
	if self.p2== "Human":
		pass
	elif self.p2== "Random":
		return self.random_turn()
	elif self.p2== "Minimax":
		return self.minimax_turn()
	elif self.turn==2:
	    self.last_piece=self.board.create_oval(100*col+5,505-100*y,100*col+105,605-100*y, fill= "yellow", outline= "green", width= 5) 
	    self.turn=1
	    if self.b.is_game_over()!= None:
	        win= self.b.is_game_over()
		for i in range(4):
   		    self.board.create_oval(100*(win[1]+i*win[3])+5,505-100*(win[0]+i*win[2]),100*(win[1]+i*win[3])+105,605-100*(win[0]+i*win[2]), outline= "blue", width= 7)
		return 
	if self.p1== "Human":
		pass
	elif self.p1== "Random":
		return self.random_turn()
	elif self.p1== "Minimax":
		return self.minimax_turn()
    
    def random_turn(self):
	if self.last_piece!= None:
	    self.board.itemconfig(self.last_piece, outline= "black", width= 1) 
	cols = []
        for col in range(7):
            if self.b.get_position(5, col) == None:
                cols.append(col)
	col= random.choice(cols)
	if self.b.board[5][col]== None:
	    y= 0 
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
    class Monitor(Frame):
        def __init__(self, parent, port, baud_rate, ser, toolchain, bii):
            '''
            Params:
                parent: The parent Frame
                port: string
                baud_rate:
                ser: serial
            '''

            Frame.__init__(self, parent)
            self.parent = parent
            self.port = port
            self.baud_rate = baud_rate
            self.ser = ser
            self.toolchain = toolchain
            self.bii = bii
            self.initUI()

        def initUI(self):
            self.parent.title("Biicode serial monitor %s" % self.port)
            self.style = Style()  # We need to define a style, otherwhise seems flat whit in macos
            self.style.theme_use(get_style())
            for x in range(1):
                Grid.columnconfigure(self, x, weight=1)
            for y in [1, 2]:
                Grid.rowconfigure(self, y, weight=1)

            self._make_top_bar()
            self._make_user_input()
            self._make_rcv_log()
            self._make_button_bar()

            self.pack(fill=BOTH, expand=1)

            self.serial_buffer = ""
            self.count = 0
            self.running = True
            self.after(50, self.read_serial)  # check serial again soon

        def _make_top_bar(self):
            menubar = Menu(self.parent)
            filemenu = Menu(menubar, tearoff=0)
            biimenu = Menu(menubar, tearoff=0)
            editmenu = Menu(menubar, tearoff=0)

            biimenu.add_command(label="Work (Save and process)", command=self.bii.work)
            biimenu.add_command(label="Find", command=self.bii.find)
            menubar.add_cascade(label="bii", menu=biimenu)

            filemenu.add_command(label="Flash code", command=self.upload)
            filemenu.add_separator()
            filemenu.add_command(label="Exit", command=self.parent.quit)
            menubar.add_cascade(label="File", menu=filemenu)

            editmenu.add_command(label="Clear", command=self.clear)
            # editmenu.add_separator()
            menubar.add_cascade(label="Edit", menu=editmenu)
            self.parent.config(menu=menubar)

        def _make_button_bar(self):
            self.button_upload = Button(self, text="Flash code", command=self.upload)
            self.button_upload.style = self.style
            self.button_upload.grid(row=0, column=0, padx=2, pady=2)

            self.baud_rate = 9600
            self.button_combobox = Combobox(self)
            self.button_combobox.bind("<<ComboboxSelected>>", self._update_baud_rate)
            bauds = (300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200)
            self.button_combobox['values'] = bauds
            self.button_combobox.current(4)
            self.button_combobox.grid(row=3, column=1, padx=2, pady=2)

        def _make_user_input(self):
            # make user input
            self.user_input = Text(self, width=52, height=3, takefocus=1,
                                   borderwidth=1, relief='ridge')
            self.user_input.grid(row=1, column=0, padx=2, pady=2, sticky=N + S + E + W)

            # make send button
            self.button_send = Button(self, text="Send", command=self.send_clicked)
            self.button_send.style = self.style
            self.button_send.grid(row=1, column=1, padx=2, pady=2, sticky=N + S + E + W)

        def _make_rcv_log(self):
            # make receive log
            recvLogFrame = Frame(self, width=400, height=200)
            recvLogFrame.style = self.style
            recvLogFrame.grid(row=2, column=0, padx=2, pady=2, sticky=N + S + E + W)
            self.start_stop_button = Button(self, text="Stop", command=self.start_stop_clicked)
            self.start_stop_button.style = self.style
            self.start_stop_button.grid(row=2, column=1, padx=2, pady=2, sticky=N + S + E + W)

            # make a scrollbar
            self.scrollbar = Scrollbar(recvLogFrame)
            self.scrollbar.pack(side=RIGHT, fill=Y)

            # make a text box to put the serial output
            self.log = Text(recvLogFrame, width=50, height=30, takefocus=0,
                            borderwidth=1, relief='ridge')
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class MainFrame(Frame):
    def __init__(self,parent,stdoutq):
        Frame.__init__(self,parent)

        self.parent=parent
        self.width=700
        self.height=400
        self.title='Menotexport v1.0'
        self.stdoutq=stdoutq

        self.initUI()

        self.hasdb=False
        self.hasout=False
        self.hasaction=False
        self.exit=False

        self.path_frame=self.addPathFrame()
        self.action_frame=self.addActionFrame()
        self.message_frame=self.addMessageFrame()
        self.printStr()

        self.stateq=Queue.Queue()
        #self.workproc=Pool(1)




    def centerWindow(self):
        sw=self.parent.winfo_screenwidth()
        sh=self.parent.winfo_screenheight()
        x=(sw-self.width)/2
        y=(sh-self.height)/2
        self.parent.geometry('%dx%d+%d+%d' \
                %(self.width,self.height,x,y))


    def initUI(self):
        self.parent.title(self.title)
        self.style=Style()
        #Choose from default, clam, alt, classic
        self.style.theme_use('alt')
        self.pack(fill=tk.BOTH,expand=True)
        self.centerWindow()


    def printStr(self):
        while self.stdoutq.qsize() and self.exit==False:
            try:
                msg=self.stdoutq.get()
                self.text.update()
                self.text.insert(tk.END,'# '+msg)
                self.text.see(tk.END)
            except Queue.Empty:
                pass
        self.after(100,self.printStr)


    def checkReady(self):
        if self.isexport.get()==1 or self.ishighlight.get()==1\
                or self.isnote.get()==1:
            self.hasaction=True
        else:
            self.hasaction=False

        if self.hasdb and self.hasout and self.hasaction:
            self.start_button.configure(state=tk.NORMAL)
            print('Menotexport Ready.')
        else:
            self.start_button.configure(state=tk.DISABLED)


    def addPathFrame(self):
        frame=Frame(self)
        frame.pack(fill=tk.X,expand=0,side=tk.TOP,padx=8,pady=5)

        frame.columnconfigure(1,weight=1)

        #------------------Database file------------------
        label=tk.Label(frame,text='Mendeley Data file:',\
                bg='#bbb')
        label.grid(row=0,column=0,\
                sticky=tk.W,padx=8)

        self.db_entry=tk.Entry(frame)
        self.db_entry.grid(row=0,column=1,sticky=tk.W+tk.E,padx=8)

        self.db_button=tk.Button(frame,text='Open',command=self.openFile)
        self.db_button.grid(row=0,column=2,padx=8,sticky=tk.E)

        hint='''
Default location on Linux:
~/.local/share/data/Mendeley\ Ltd./Mendeley\ Desktop/[email protected]
Default location on Windows:
C:\Users\Your_name\AppData\Local\Mendeley Ltd\Mendeley Desktop\[email protected]'''

        hint_label=tk.Label(frame,text=hint,\
                justify=tk.LEFT,anchor=tk.NW)
        hint_label.grid(row=1,column=0,columnspan=3,\
                sticky=tk.W,padx=8)
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class App:
    """Main class for the gui layer."""

    def __init__(self, master):
        self.master = master
        self.master.title("Gaussian Elimination / Jacobi Method")
        self.create_widgets(master)
        # options for opening or saving a file
        self.file_opt = options = {}
        options['filetypes'] = [('all files', '*'), ('text files', '.txt'),
                                ('csv files', '.csv')]

    def create_widgets(self, master):
        """Populate the main window with gui components."""
        # buttons, slider, combobox etc.
        frame0 = Frame(master)
        frame0.grid(row=1, column=0, sticky=N)
        self.scale = Scale(frame0, from_=2, to=2000, orient=HORIZONTAL,
                           label='Matrix / vector size (n):')
        self.scale.pack(fill="x")
        btn_gen_mtx = Button(frame0, text="Generate matrix A (n x n)",
                             command=self.gen_mtx)
        btn_gen_mtx.pack(fill="x")
        btn_gen_vec = Button(frame0, text="Generate vector B (n)",
                             command=self.gen_vec)
        btn_gen_vec.pack(fill="x")
        btn_load_mtx = Button(frame0, text="Load matrix A",
                              command=self.load_mtx)
        btn_load_mtx.pack(fill="x")
        btn_load_vec = Button(frame0, text="Load vector B",
                              command=self.load_vec)
        btn_load_vec.pack(fill="x")
        btn_solve = Button(frame0, text="SOLVE",
                           command=self.solve)
        btn_solve.pack(fill="x")
        self.combobox = Combobox(frame0, state="readonly",
                                 values=("Gauss Method", "Jacobi Method",
                                         "numpy.linalg.solve()"))
        self.combobox.pack(fill="x")
        self.combobox.set("Gauss Method")  # default choice
        btn_quit = Button(frame0, text="Quit", command=self.quit)
        btn_quit.pack(fill='x', pady=28)

        # scrollbar text widget (matrix a)
        self.frame1 = Frame(master)
        xscrollbar1 = Scrollbar(self.frame1, orient=HORIZONTAL)
        xscrollbar1.grid(row=1, column=0, sticky=E+W)
        yscrollbar1 = Scrollbar(self.frame1)
        yscrollbar1.grid(row=0, column=1, sticky=N+S)
        self.text1 = Text(self.frame1, wrap=NONE, bd=0, state=DISABLED,
                          xscrollcommand=xscrollbar1.set,
                          yscrollcommand=yscrollbar1.set)
        self.text1.grid(row=0, column=0, sticky=N+S+W+E)
        xscrollbar1.config(command=self.text1.xview)
        yscrollbar1.config(command=self.text1.yview)
        self.frame1.grid_rowconfigure(0, weight=1)
        self.frame1.grid_columnconfigure(0, weight=1)
        self.frame1.grid(row=1, column=1, sticky=N+S+W+E)

        # scrollbar text widget (vector b)
        self.frame2 = Frame(master)
        xscrollbar2 = Scrollbar(self.frame2, orient=HORIZONTAL)
        xscrollbar2.grid(row=1, column=0, sticky=E+W)
        yscrollbar2 = Scrollbar(self.frame2)
        yscrollbar2.grid(row=0, column=1, sticky=N+S)
        self.text2 = Text(self.frame2, width=30, wrap=NONE, bd=0,
                          state=DISABLED, xscrollcommand=xscrollbar2.set,
                          yscrollcommand=yscrollbar2.set)
        self.text2.grid(row=0, column=0, sticky=N+S+E+W)
        xscrollbar2.config(command=self.text2.xview)
        yscrollbar2.config(command=self.text2.yview)
        self.frame2.grid_rowconfigure(0, weight=1)
        self.frame2.grid_columnconfigure(0, weight=1)
        self.frame2.grid(row=1, column=2, sticky=N+S)

        # scrollbar text widget (vector x)
        self.frame3 = Frame(master)
        xscrollbar3 = Scrollbar(self.frame3, orient=HORIZONTAL)
        xscrollbar3.grid(row=1, column=0, sticky=E+W)
        yscrollbar3 = Scrollbar(self.frame3)
        yscrollbar3.grid(row=0, column=1, sticky=N+S)
        self.text3 = Text(self.frame3, width=30, wrap=NONE, bd=0,
                          state=DISABLED, xscrollcommand=xscrollbar3.set,
                          yscrollcommand=yscrollbar3.set)
        self.text3.grid(row=0, column=0, sticky=N+S+E+W)
        xscrollbar3.config(command=self.text3.xview)
        yscrollbar3.config(command=self.text3.yview)
        self.frame3.grid_rowconfigure(0, weight=1)
        self.frame3.grid_columnconfigure(0, weight=1)
        self.frame3.grid(row=1, column=3, sticky=N+S)

        # labels
        label1 = Label(master, text="Matrix A")
        label1.grid(row=0, column=1)
        label2 = Label(master, text="Vector B")
        label2.grid(row=0, column=2)
        label3 = Label(master, text="Vector X")
        label3.grid(row=0, column=3)
        self.bottom_label = Label(master)
        self.bottom_label.grid(row=2, column=0, columnspan=4, sticky=W+E)
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class Metadator(Tk):
    def __init__(self):
        u"""
        Main window constructor
        Creates 1 frame and 2 labeled subframes
        """
        # first: the log
        # see: http://sametmax.com/ecrire-des-logs-en-python/
        self.logger = logging.getLogger()
        self.logger.setLevel(logging.DEBUG)  # all errors will be get
        log_form = logging.Formatter('%(asctime)s || %(levelname)s || %(message)s')
        logfile = RotatingFileHandler('Metadator_LOG.log', 'a', 5000000, 1)
        logfile.setLevel(logging.DEBUG)
        logfile.setFormatter(log_form)
        self.logger.addHandler(logfile)
        self.logger.info('\n\t ======== Metadator ========')  # first messages
        self.logger.info('Starting the UI')

        # checking the path to GDAL in the path
        if "GDAL_DATA" not in env.keys():
            try:
                gdal.SetConfigOption(str('GDAL_DATA'),
                                     str(path.abspath(r'data/gdal')))
            except:
                print("Oups! Something has gone wrong...\
                      see: https://github.com/Guts/Metadator/issues/21")
        else:
            pass

        # basics settings
        Tk.__init__(self)           # constructor of parent graphic class
        self.title(u'Metadator {0}'.format(MetadatorVersion))
        self.style = Style()        # more friendly windows style
        if opersys == 'win32':
            self.logger.info('Op. system: {0}'.format(platform.platform()))
            self.iconbitmap('Metadator.ico')    # windows icon
            self.uzer = env.get(u'USERNAME')
        elif opersys == 'linux2':
            self.logger.info('Op. system: {0}'.format(platform.platform()))
            self.uzer = env.get(u'USER')
            icon = Image("photo", file=r'data/img/metadator.gif')
            self.call('wm', 'iconphoto', self._w, icon)
            self.minsize(580, 100)
            self.style.theme_use('clam')
        elif opersys == 'darwin':
            self.logger.info('Op. system: {0}'.format(platform.platform()))
            self.uzer = env.get(u'USER')
        else:
            self.logger.warning('Operating system not tested')
            self.logger.info('Op. system: {0}'.format(platform.platform()))
        self.resizable(width=False, height=False)
        self.focus_force()

        self.logger.info('GDAL version: {}'.format(gdal.__version__))

        # variables
        self.def_rep = ""       # folder to search for
        self.def_lang = 'FR'    # language to start
        self.def_doc = IntVar()     # to export into Word
        self.def_xls = IntVar()     # to export into Excel 2003
        self.def_xml = IntVar()     # to export into ISO 19139
        self.def_cat = IntVar()     # to merge all output Word files
        self.def_odt = IntVar()     # to export into OpenDocumentText
        self.def_dict = IntVar()    # to make a dictionnary of data
        self.def_kass = IntVar()    # to handle field name case sensitive
        self.def_stat = IntVar()    # to active/disable stats fields
        self.li_pro = []            # list for profiles in language selected
        self.li_shp = []            # list for shapefiles path
        self.li_tab = []            # list for MapInfo tables path
        self.num_folders = 0        # number of folders explored
        self.today = strftime("%Y-%m-%d")   # date of the day
        self.dico_layer = OD()      # dictionary about layer properties
        self.dico_profil = OD()     # dictionary from profile selected
        self.dico_fields = OD()     # dictionary for fields information
        self.dico_rekur = OD()      # dictionary of recurring attributes
        self.dico_err = OD()     # errors list
        self.dico_help = OD()                # dictionary of help texts
        li_lang = [lg for lg in listdir(r'locale')]   # available languages
        self.blabla = OD()      # texts dictionary

        # GUI fonts
        ft_tit = tkFont.Font(family="Times", size=10, weight=tkFont.BOLD)

        # fillfulling
        self.load_settings()
        self.load_texts(self.def_lang)
        self.li_profiles(self.def_lang)
        self.li_rekurs(self.def_lang)
        self.recup_help(self.def_lang)

        # Tabs
        self.nb = Notebook(self)
        self.tab_globals = Frame(self.nb)   # tab_id = 0
        self.tab_options = Frame(self.nb)   # tab_id = 1
        self.tab_attribs = Frame(self.nb)   # tab_id = 2
        self.nb.add(self.tab_globals,
                    text=self.blabla.get('gui_tab1'), padding=3)
        self.nb.add(self.tab_options,
                    text=self.blabla.get('gui_tab2'), padding=3)
        self.nb.add(self.tab_attribs,
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class MainFrame(Frame):
    def __init__(self,parent,stdoutq):
        Frame.__init__(self,parent)

        self.parent=parent
        self.width=750
        self.height=450
        self.title=ximaexport.__version__
        self.stdoutq=stdoutq
        
        self.initUI()

        self.hasdb=False
        self.hasout=False
        self.exit=False

        self.path_frame=self.addPathFrame()
        self.action_frame=self.addActionFrame()
        self.message_frame=self.addMessageFrame()
        self.printStr()

        self.stateq=Queue.Queue()


    def centerWindow(self):
        sw=self.parent.winfo_screenwidth()
        sh=self.parent.winfo_screenheight()
        x=(sw-self.width)/2
        y=(sh-self.height)/2
        self.parent.geometry('%dx%d+%d+%d' \
                %(self.width,self.height,x,y))


    def initUI(self):
        self.parent.title(self.title)
        self.style=Style()
        #Choose from default, clam, alt, classic
        self.style.theme_use('alt')
        self.pack(fill=tk.BOTH,expand=True)
        self.centerWindow()


    def printStr(self):
        while self.stdoutq.qsize() and self.exit==False:
            try:
                msg=self.stdoutq.get()
                self.text.update()
                self.text.insert(tk.END,msg)
                self.text.see(tk.END)
            except Queue.Empty:
                pass
        self.after(100,self.printStr)



    def checkReady(self):

        if self.hasdb and self.hasout:
            self.start_button.configure(state=tk.NORMAL)
            #print('XimaExport Ready.')
            printch('XimaExport 就绪.')
        else:
            self.start_button.configure(state=tk.DISABLED)


    def addPathFrame(self):
        frame=Frame(self)
        frame.pack(fill=tk.X,expand=0,side=tk.TOP,padx=8,pady=5)

        frame.columnconfigure(1,weight=1)

        #------------------Database file------------------
        label=tk.Label(frame,text=dgbk('ting.sqlite文件:'),\
                bg='#bbb')
        label.grid(row=0,column=0,\
                sticky=tk.W,padx=8)

        self.db_entry=tk.Entry(frame)
        self.db_entry.grid(row=0,column=1,sticky=tk.W+tk.E,padx=8)

        self.db_button=tk.Button(frame,text=dgbk('打开'),command=self.openFile)
        self.db_button.grid(row=0,column=2,padx=8,sticky=tk.E)

        #--------------------Output dir--------------------
        label2=tk.Label(frame,text=dgbk('导出到文件夹:'),\
                bg='#bbb')
        label2.grid(row=2,column=0,\
                sticky=tk.W,padx=8)

        self.out_entry=tk.Entry(frame)
        self.out_entry.grid(row=2,column=1,sticky=tk.W+tk.E,padx=8)
        self.out_button=tk.Button(frame,text=dgbk('选择'),command=self.openDir)
        self.out_button.grid(row=2,column=2,padx=8,sticky=tk.E)
        


    def openDir(self):
        self.out_entry.delete(0,tk.END)
        dirname=askdirectory()
        self.out_entry.insert(tk.END,dirname)
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class Window(Frame):
    def __init__(self, parent, window_type):
        Frame.__init__(self, parent, msg = None)

        self.parent = parent
        if window_type == "main":
            self.initUI_main()
        if window_type == "err":
            self.initUI_err()

    def initUI_main(self):
        self.parent.title("Personal Helper")
        self.pack(fill=BOTH, expand=True)

        self.columnconfigure(0, weight=1)
        self.columnconfigure(7, weight=1)
        self.columnconfigure(5, pad=10)
        self.columnconfigure(3, pad=10)
        self.columnconfigure(1, weight=3)
        self.rowconfigure(0, weight=0)
        self.rowconfigure(5, weight=1)
        self.rowconfigure(5, pad=7)
        self.rowconfigure(6, pad=6)


        lbl = Label(self, text="Windows")
        lbl.grid(sticky=W+N, pady=4, padx=5)


        check_box = {"work": IntVar(),
                     "boost": IntVar()}

        check1 = Checkbutton(self, text="work-Mode", variable=check_box["work"])
        check1.grid(row=7, column=0)

        check2 = Checkbutton(self, text="boost games", variable=check_box["boost"])
        check2.grid(row=7, column=1)


        ### old version, may be used again later
        area = Treeview(self)
        area['show'] = 'headings'
        area["columns"] = ("one", "two", "three", "four")
        area.column("one", width=10)
        area.column("two", width=10)
        area.column("three", width=10)
        area.column("four", width=10)
        area.heading("one", text="process name")
        area.heading("two", text="Priority")
        area.heading("three", text="PID")
        area.heading("four", text="Usage")
        ###about this part
        #area.grid(row=1, column=0, columnspan=2, rowspan=4, padx=5, sticky=E + W + S + N)
        #######

        #comboboxes and relevant buttons

        self.block_drop = Combobox(self, postcommand= self.update_blocked)
        self.block_drop['values'] = working_bans
        self.block_drop.current(0)
        self.block_drop.grid(row=1, column=1, pady=1)
        self.entry = Entry(self)
        self.entry.insert(0, "enter to block")
        self.entry.grid(row=1, column=4)

        block_btn_remv = Button(self, text="Remove", command=lambda: remove_from_list(working_bans, self.block_drop.get()))
        block_btn_remv.grid(row=1, column=2)

        block_btn_add = Button(self, text="Add", command=lambda: add_to_list(working_bans, self.entry.get(), self.entry, defults["block"]))
        block_btn_add.grid(row=1, column=3)

        ############
        #boosted combo
        self.boost_drop = Combobox(self, postcommand=self.update_boosted)
        self.boost_drop['values'] = boosted
        self.boost_drop.current(0)
        self.boost_drop.grid(row=2, column=1, pady=1)
        self.entry2 = Entry(self)
        self.entry2.insert(0, "enter to buff priority")
        self.entry2.grid(row=2, column=4, pady=4)

        boost_btn_remv = Button(self, text="Remove", command=lambda: remove_from_list(boosted, self.boost_drop.get()))
        boost_btn_remv.grid(row=2, column=2)

        boost_btn_add = Button(self, text="Add", command=lambda: add_to_list(boosted, self.entry2.get(), self.entry2, defults["boost"]))
        boost_btn_add.grid(row=2, column=3)

        #########################################

        #degraded combo
        self.deg_drop = Combobox(self, postcommand=self.update_degraded)
        self.deg_drop['values'] = degraded
        self.deg_drop.current(0)
        self.deg_drop.grid(row=3, column=1, pady=1)
        self.entry3 = Entry(self)
        self.entry3.insert(0, "enter to lower priority")
        self.entry3.grid(row=3, column=4, pady=4)

        deg_btn_remv = Button(self, text="Remove", command=lambda: remove_from_list(degraded, self.deg_drop.get()))
        deg_btn_remv.grid(row=3, column=2)
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class Application(Frame):
    def __init__(self, master=None, config=config):
        self.config = config
        self.log = logging.getLogger("{0}.{1}".format(self.__class__.__name__, id(self)))
        self.display_connections = False
        Frame.__init__(self, master)
        self.grid()
        Style().configure("TFrame", background="#444")
        self.paint_tile = 1
        self.init_ui()

    def init_ui(self):
        self.connections = {}
        self.button_frame = Frame(self)
        self.button_frame.grid(row=0, column=0, columnspan=2)
        self.map_frame = Frame(self)
        self.map_frame.grid(row=1, column=0, padx=5, pady=5)
        self.picker_frame = Frame(self)
        self.picker_frame.grid(row=1, column=1)

        self.button_new = Button(self.button_frame)
        self.button_new["text"] = "New"
        self.button_new["command"] = self.new_map
        self.button_new.grid(row=0, column=0, padx=2)

        self.open = Button(self.button_frame)
        self.open["text"] = "Open"
        self.open["command"] = self.open_map
        self.open.grid(row=0, column=1, padx=2)

        self.save = Button(self.button_frame)
        self.save["text"] = "Save"
        self.save["command"] = self.save_map
        self.save.grid(row=0, column=2, padx=2)

        self.get_map_list()
        self.map_list.grid(row=0, column=3, padx=2)


    def get_map_list(self):
        self.available_maps = sorted(m for m in get_available_maps(config=self.config))
        self.map_list = Combobox(self.button_frame, height=24, width=24, values=self.available_maps)
        if len(self.available_maps):
            self.map_list.set(self.available_maps[0])

    def new_map(self):
        self.map_name = None
        self.init_map()
        self.map.blockdata_filename = os.path.join(self.config.map_dir, 'newmap.blk')
        self.map.blockdata = bytearray([self.paint_tile] * 20 * 20)
        self.map.width = 20
        self.map.height = 20
        self.draw_map()
        self.init_picker()

    def open_map(self):
        self.map_name = self.map_list.get()
        self.init_map()
        self.draw_map()
        self.init_picker()

    def save_map(self):
        if hasattr(self, 'map'):
            if self.map.blockdata_filename:
                filename = tkFileDialog.asksaveasfilename(initialfile=self.map.blockdata_filename)
                with open(filename, 'wb') as save:
                    save.write(self.map.blockdata)
                self.log.info('blockdata saved as {}'.format(self.map.blockdata_filename))
            else:
                self.log.info('dunno how to save this')
        else:
            self.log.info('nothing to save')

    def init_map(self):
        if hasattr(self, 'map'):
            self.map.kill_canvas()
        self.map = Map(self.map_frame, self.map_name, config=self.config)
        self.init_map_connections()

    def draw_map(self):
        self.map.init_canvas(self.map_frame)
        self.map.canvas.pack() #.grid(row=1,column=1)
        self.map.draw()
        self.map.canvas.bind('<Button-1>', self.paint)
        self.map.canvas.bind('<B1-Motion>', self.paint)

    def init_picker(self):
        self.current_tile = Map(self.button_frame, tileset_id=self.map.tileset_id, config=self.config)
        self.current_tile.blockdata = [self.paint_tile]
        self.current_tile.width = 1
        self.current_tile.height = 1
        self.current_tile.init_canvas()
        self.current_tile.draw()
        self.current_tile.canvas.grid(row=0, column=4, padx=4)

        if hasattr(self, 'picker'):
            self.picker.kill_canvas()
        self.picker = Map(self, tileset_id=self.map.tileset_id, config=self.config)
        self.picker.blockdata = range(len(self.picker.tileset.blocks))
        self.picker.width = 4
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class Application(Frame):
    def __init__(self, master=None, config=config):
        self.config = config
        self.log = logging.getLogger("{0}.{1}".format(self.__class__.__name__, id(self)))
        self.display_connections = True

        Frame.__init__(self, master)
        self.pack(fill=BOTH, expand=True)
        Style().configure("TFrame", background="#444")

        self.paint_tile = 1
        self.init_ui()

    def init_ui(self):
        self.connections = {}
        self.button_frame = Frame(self)
        self.button_frame.grid(row=0, column=0, columnspan=2)
        self.map_frame = Frame(self)
        self.map_frame.grid(row=1, column=0, padx=5, pady=5, sticky=N + S + E + W)
        self.picker_frame = Frame(self)
        self.picker_frame.grid(row=1, column=1)

        self.button_new = Button(self.button_frame)
        self.button_new["text"] = "New"
        self.button_new["command"] = self.new_map
        self.button_new.grid(row=0, column=0, padx=2)

        self.menubar = Menu(self)

        menu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="File", menu=menu)
        menu.add_command(label="New")
        menu.add_command(label="Open")
        menu.add_command(label="Save")

        self.open = Button(self.button_frame)
        self.open["text"] = "Open"
        self.open["command"] = self.open_map
        self.open.grid(row=0, column=1, padx=2)

        self.save = Button(self.button_frame)
        self.save["text"] = "Save"
        self.save["command"] = self.save_map
        self.save.grid(row=0, column=2, padx=2)

        self.get_map_list()
        self.map_list.grid(row=0, column=3, padx=2)

    def get_map_list(self):
        self.available_maps = sorted(m for m in get_available_maps(config=self.config))
        self.map_list = Combobox(self.button_frame, height=24, width=24, values=self.available_maps)
        if len(self.available_maps):
            self.map_list.set(self.available_maps[0])

    def new_map(self):
        self.map_name = None
        self.init_map()
        self.map.map.blockdata = bytearray([self.paint_tile] * 20 * 20)
        self.map.map.width = 20
        self.map.map.height = 20
        self.draw_map()
        self.init_picker()

    def open_map(self):
        self.map_name = self.map_list.get()
        self.init_map()
        self.draw_map()
        self.init_picker()

    def save_map(self):
        if hasattr(self, "map"):
            if self.map.map.blk_path:
                initial = self.map.map.blk_path
            else:
                initial = self.config.path
            filename = tkFileDialog.asksaveasfilename(initialfile=initial)
            if filename:
                with open(filename, "wb") as save:
                    save.write(self.map.map.blockdata)
                self.log.info("blockdata saved as {}".format(filename))
        else:
            self.log.info("nothing to save")

    def init_map(self):
        if hasattr(self, "map"):
            self.map.kill_canvas()
        self.map = MapRenderer(self.config, parent=self.map_frame, name=self.map_name)
        self.init_map_connections()

    def draw_map(self):
        self.map.init_canvas(self.map_frame)
        self.map.canvas.pack()  # .grid(row=1,column=1)
        self.map.draw()
        self.map.canvas.bind("<Button-1>", self.paint)
        self.map.canvas.bind("<B1-Motion>", self.paint)

    def init_picker(self):
        """This should really be its own class."""
        self.current_tile = MapRenderer(
            self.config, parent=self.button_frame, tileset=Tileset(id=self.map.map.tileset.id)
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class SolinetteGUI(Tk):
    def __init__(self):
        # basics settings
        Tk.__init__(self)               # constructor of parent graphic class
        self.title(u'Solinette: geolocalizar direcciones en Lima y Callo')
        self.iconbitmap('icone_Solinette.ico')
        self.resizable(width = False, height = False)
        self.columnconfigure(0, weight=1)
        self.rowconfigure(0, weight=1)

        # Frames
        self.FrPath = LabelFrame(self, name ='primero',
                            text = u'1: las direcciones para geolocalizar',
                            padx = 5, pady = 5)
        self.FrAttr = LabelFrame(self, name ='segundo',
                            text = u'2: columnas indispensables',
                            padx = 5, pady = 5)
        self.FrConn = LabelFrame(self, name ='tercero',
                            text = u'3: parámetros de conexión a la base de datos',
                            padx=5, pady=5)

        # Variables
        inutile = ['Esperando que se elige el archivo Excel']
        self.typcols = []
        self.host = StringVar()
        self.port = IntVar()
        self.dbnb = StringVar()
        self.usua = StringVar()
        self.mdpa = StringVar()
        self.ok = 0
        self.dico_cols = OD()
        self.dico_vals = OD()
        self.dico_param = {}

            ## Frame 1
        # target folder
        labtarg = Label(self.FrPath, text = u'Archivo Excel (.xls): ')
        self.target = Entry(self.FrPath, width = 35)
        self.browsetarg = Button(self.FrPath,
                                 text = 'Explorar',
                                 command = self.setpathtarg)

        # widgets placement
        labtarg.grid(row = 1, column = 1, columnspan = 1, sticky = N+S+W+E, padx = 2, pady = 2)
        self.target.grid(row = 1, column = 2, columnspan = 1, sticky = N+S+W+E, padx = 2, pady = 2)
        self.browsetarg.grid(row = 1, column = 3, columnspan = 1, sticky = N+S+W+E, padx = 2, pady = 2)

            ## Frame 2
        # Drop-down lists of columns
        labdir = Label(self.FrAttr, text = u'Columna dirección: ')
        self.ddl_dir = Combobox(self.FrAttr, values = inutile)
        labdis = Label(self.FrAttr, text = u'Columna distrito: ')
        self.ddl_dis = Combobox(self.FrAttr, values = inutile)

        # nombre de la tabla en PostgreSQL
        labtabl = Label(self.FrAttr, text = u'Nombre de la tabla: ')
        self.tabl = Entry(self.FrAttr, width = 35)

        # widgets placement
        labdir.grid(row = 1, column = 1, sticky = N+S+W, padx = 2, pady = 2)
        self.ddl_dir.grid(row = 1, column = 2, sticky = N+S+W+E, padx = 2, pady = 2)
        labdis.grid(row = 2, column = 1, sticky = N+S+W, padx = 2, pady = 2)
        self.ddl_dis.grid(row = 2, column = 2, sticky = N+S+W+E, padx = 2, pady = 2)
        labtabl.grid(row = 3, column = 1, sticky = N+S+W, padx = 2, pady = 2)
        self.tabl.grid(row = 3, column = 2, sticky = N+S+W+E, padx = 2, pady = 2)

            ## Frame 3

        # Etiquetas
        Label(self.FrConn, text = u'Host: ').grid(row = 1, column = 1,
                                                  padx = 2, pady = 2,
                                                  sticky = N+S+W)
        Label(self.FrConn, text = u'Puerto: ').grid(row = 2, column = 1,
                                             padx = 2, pady = 2,
                                             sticky = N+S+W)
        Label(self.FrConn, text = u'Base de datos: ').grid(row = 3,
                                                    column = 1,
                                                    padx = 2,
                                                    pady = 2,
                                                    sticky = N+S+W)
        Label(self.FrConn, text = u'Usuario: ').grid(row = 4,
                                              column = 1,
                                              padx = 2,
                                              pady = 2,
                                              sticky = N+S+W)
        Label(self.FrConn, text = u'Contraseña: ').grid(row = 5,
                                                 column = 1,
                                                 padx = 2,
                                                 pady = 2,
                                                 sticky = N+S+W)

        # Formulario
        self.H = Entry(self.FrConn, textvariable = self.host)
        self.P = Entry(self.FrConn, textvariable = self.port)
        self.D = Entry(self.FrConn, textvariable = self.dbnb)
        self.U = Entry(self.FrConn, textvariable = self.usua)
        self.M = Entry(self.FrConn, textvariable = self.mdpa, show='*')
        # pre relleno
        self.host.set('localhost')
        self.port.set('5432')
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Combobox [as 别名]
# 或者: from ttk.Combobox import get [as 别名]
class MainFrame(Frame):
    def __init__(self,parent,stdoutq):
        Frame.__init__(self,parent)

        self.parent=parent
        self.width=850
        self.height=650
        self.title=menotexport.__version__
        self.stdoutq=stdoutq

        self.initUI()

        self.hasdb=False
        self.hasout=False
        self.hasaction=False
        self.exit=False

        self.path_frame=self.addPathFrame()
        self.action_frame=self.addActionFrame()
        self.message_frame=self.addMessageFrame()
        self.printStr()

        self.stateq=Queue.Queue()
        #self.workproc=Pool(1)




    def centerWindow(self):
        sw=self.parent.winfo_screenwidth()
        sh=self.parent.winfo_screenheight()
        x=(sw-self.width)/2
        y=(sh-self.height)/2
        self.parent.geometry('%dx%d+%d+%d' \
                %(self.width,self.height,x,y))


    def initUI(self):
        self.parent.title(self.title)
        self.style=Style()
        #Choose from default, clam, alt, classic
        self.style.theme_use('alt')
        self.pack(fill=tk.BOTH,expand=True)
        self.centerWindow()


    def printStr(self):
        while self.stdoutq.qsize() and self.exit==False:
            try:
                msg=self.stdoutq.get()
                self.text.update()
                self.text.insert(tk.END,msg)
                self.text.see(tk.END)
            except Queue.Empty:
                pass
        self.after(100,self.printStr)


    def checkReady(self):
        if self.isexport.get()==1 or self.ishighlight.get()==1\
                or self.isnote.get()==1 or self.isbib.get()==1:
            self.hasaction=True
        else:
            self.hasaction=False

        if self.hasdb and self.hasout and self.hasaction:
            self.start_button.configure(state=tk.NORMAL)
            print('# <Menotexport>: Menotexport Ready.')
        else:
            self.start_button.configure(state=tk.DISABLED)


    def addPathFrame(self):
        frame=Frame(self)
        frame.pack(fill=tk.X,expand=0,side=tk.TOP,padx=8,pady=5)

        frame.columnconfigure(1,weight=1)

        #------------------Database file------------------
        label=tk.Label(frame,text='Mendeley Data file:',\
                bg='#bbb')
        label.grid(row=0,column=0,\
                sticky=tk.W,padx=8)

        self.db_entry=tk.Entry(frame)
        self.db_entry.grid(row=0,column=1,sticky=tk.W+tk.E,padx=8)

        self.db_button=tk.Button(frame,text='Open',command=self.openFile)
        self.db_button.grid(row=0,column=2,padx=8,sticky=tk.E)

        hint='''
Default location on Linux:
~/.local/share/data/Mendeley\ Ltd./Mendeley\ Desktop/[email protected]
Default location on Windows:
C:\Users\Your_name\AppData\Local\Mendeley Ltd\Mendeley Desktop\[email protected]'''

        hint_label=tk.Label(frame,text=hint,\
                justify=tk.LEFT,anchor=tk.NW)
        hint_label.grid(row=1,column=0,columnspan=3,\
                sticky=tk.W,padx=8)
#.........这里部分代码省略.........