Python Scrollbar.config方法代码示例

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
 def __init__(self, master):
     Frame.__init__(self, master)
     scrollbar = Scrollbar(self, orient=VERTICAL)
     scrollbar.pack(side=RIGHT, fill=Y)
     self.canvas = Canvas(self, bd=0, highlightthickness=0, yscrollcommand=scrollbar.set)
     self.canvas.pack(side=LEFT, fill=BOTH, expand=1)
     scrollbar.config(command=self.canvas.yview)
     
     self.mainframe = Frame(self.canvas)
     self.mainframe_id = self.canvas.create_window((0, 0), window=self.mainframe, anchor=NW)
     self.mainframe.bind('<Configure>', self.config_mainframe)
     self.canvas.bind('<Configure>', self.config_canvas)

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
    def __init__(self,parent,caller,**args):
        Frame.__init__(self,parent,**args)
        self.pack(side=TOP)

        self.canvas = Canvas(self,scrollregion=(0,0,1000,1000)
                             ,background='white',cursor='pencil')
        self.canvas.bind("<Button-1>",lambda event:caller.clickCell(event,1))
        self.canvas.bind("<B1-Motion>",lambda event:caller.clickCell(event,1))
        self.canvas.bind("<Control-Button-1>",lambda event:caller.clickCell(event,-1))
        self.canvas.bind("<Control-B1-Motion>",lambda event:caller.clickCell(event,-1))
        vScroll = Scrollbar(self, orient = VERTICAL)
        vScroll.pack(side = RIGHT, fill=Y)
        vScroll.config(command = self.canvas.yview)
        hScroll = Scrollbar(self, orient = HORIZONTAL)
        hScroll.pack(side = BOTTOM, fill=X)
        hScroll.config(command = self.canvas.xview)
        self.canvas.config(xscrollcommand = hScroll.set, yscrollcommand = vScroll.set)
        self.canvas.pack(side=LEFT)

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
class TypingField(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.parent = parent
        
        self.submit_tog = True
        self.initUI()
        self.text.bind_class("Text","<Control-a>", self.selectall)
        
    def initUI(self):
        self.parent.title("Text Field")
        self.pack(fill = BOTH, expand=True)
        
        frame1 = Frame(self, width = 50, height =25)
        frame1.pack(fill = X, expand=True)
        self.scroll = Scrollbar(frame1)
        self.scroll.pack(side = "right", fill = Y)
        self.text = Text(frame1)
        self.text.pack(fill=Y)
        self.scroll.config(command=self.text.yview)
        self.text.config(yscrollcommand=self.scroll.set)
        
        
        frame2 = Frame(self)
        frame2.pack(fill=X, expand=True)
        self.submit = Button(frame2,text="Start Test")
        self.submit.bind("<Button-1>", self.startPause)
        self.submit.pack(fill=X)
        
    def startPause(self, event):
        self.text.focus_set()
        if self.submit_tog:
            self.submit.configure(text = "Pause")
        else:
            self.submit.configure(text = "Start Test")
        self.submit_tog = not self.submit_tog
        
    def selectall(self, event):
        event.widget.tag_add("sel","1.0","end")

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
    def __init__(self, master, mixer):
        Frame.__init__(self, master)

        scrollbar_h = Scrollbar(self, orient='horizontal')
        scrollbar_v = Scrollbar(self, orient='vertical')
        self.canvas = Canvas(self,
                             background='gray',
                             scrollregion=(0, 0, (3 + len(mixer) * FADER_WIDTH), FADER_HEIGHT),
                             yscrollcommand=scrollbar_v.set,
                             xscrollcommand=scrollbar_h.set)

        scrollbar_v.config(command=self.canvas.yview)
        scrollbar_h.config(command=self.canvas.xview)

        master.bind("<MouseWheel>",
                         lambda e: self.canvas.yview_scroll(-e.delta, 'units'))
        master.bind("<Shift-MouseWheel>",
                         lambda e: self.canvas.xview_scroll(-e.delta, 'units'))

        Sizegrip(self).grid(column=2, row=1, sticky='se')
        self.canvas.grid(column=0, row=0, sticky='nwes')
        scrollbar_h.grid(column=0, row=1, sticky='we')
        scrollbar_v.grid(column=1, row=0, sticky='sn')

        master_fader = AudioFader(self, mixer.getVolume, mixer.setVolume, "Master")
        master_fader.grid(column=2, row=0, sticky='nwes')

        self.grid_columnconfigure(0, weight=1)
        self.grid_rowconfigure(0, weight=1)

        for i, channel in enumerate(mixer):
            if channel.device.id_variable is not None:
                name = channel.device.id_variable
            else:
                name = channel.device.name_id

            fader = AudioFader(self.canvas, channel.get_gain, channel.set_gain, name)
            self.canvas.create_window(i * FADER_WIDTH, 0, anchor='nw', window=fader)

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
class MainWindow(object):
    def __init__(self, root, debugger):
        '''
        -----------------------------------------------------
        | main button toolbar                               |
        -----------------------------------------------------
        |       < ma | in content area >      |             |
        |            |                        |             |
        | File list  | File name              | Inspector   |
        | (stack/    | Code area              |             |
        | breakpnts) |                        |             |
        |            |                        |             |
        |            |                        |             |
        -----------------------------------------------------
        |     status bar area                               |
        -----------------------------------------------------

        '''

        # Obtain and expand the current working directory.
        base_path = os.path.abspath(os.getcwd())
        base_path = os.path.normcase(base_path) + '/'

        # Create a filename normalizer based on the CWD.
        self.filename_normalizer = filename_normalizer(base_path)

        self.debugger = debugger
        # Associate the debugger with this view.
        self.debugger.view = self

        # Root window
        self.root = root
        self.root.title('Bugjar')
        self.root.geometry('1024x768')

        # Prevent the menus from having the empty tearoff entry
        self.root.option_add('*tearOff', False)
        # Catch the close button
        self.root.protocol("WM_DELETE_WINDOW", self.cmd_quit)
        # Catch the "quit" event.
        self.root.createcommand('exit', self.cmd_quit)

        # Setup the menu
        self._setup_menubar()

        # Set up the main content for the window.
        self._setup_button_toolbar()
        self._setup_main_content()
        self._setup_status_bar()

        # Now configure the weights for the root frame
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=0)
        self.root.rowconfigure(1, weight=1)
        self.root.rowconfigure(2, weight=0)

        debugger.start()

    ######################################################
    # Internal GUI layout methods.
    ######################################################

    def _setup_menubar(self):
        # Menubar
        self.menubar = Menu(self.root)

        # self.menu_Apple = Menu(self.menubar, name='Apple')
        # self.menubar.add_cascade(menu=self.menu_Apple)

        self.menu_file = Menu(self.menubar)
        self.menubar.add_cascade(menu=self.menu_file, label='File')

        self.menu_program = Menu(self.menubar)
        self.menubar.add_cascade(menu=self.menu_program, label='Program')

        self.menu_help = Menu(self.menubar)
        self.menubar.add_cascade(menu=self.menu_help, label='Help')

        # self.menu_Apple.add_command(label='Test', command=self.cmd_dummy)

        # self.menu_file.add_command(label='New', command=self.cmd_dummy, accelerator="Command-N")
        self.menu_file.add_command(label='Open...', command=self.cmd_open_file, accelerator="Command-O")
        self.root.bind('<Command-o>', self.cmd_open_file)
        # self.menu_file.add_command(label='Close', command=self.cmd_dummy)

        self.menu_program.add_command(label='Run', command=self.cmd_run, accelerator="R")
        self.root.bind('<r>', self.cmd_run)
        self.menu_program.add_command(label='Step', command=self.cmd_step, accelerator="S")
        self.root.bind('<s>', self.cmd_step)
        self.menu_program.add_command(label='Next', command=self.cmd_next, accelerator="N")
        self.root.bind('<n>', self.cmd_next)
        self.menu_program.add_command(label='Return', command=self.cmd_return, accelerator="BackSpace")
        self.root.bind('<BackSpace>', self.cmd_return)

        self.menu_help.add_command(label='Open Documentation', command=self.cmd_bugjar_docs)
        self.menu_help.add_command(label='Open Bugjar project page', command=self.cmd_bugjar_page)
        self.menu_help.add_command(label='Open Bugjar on GitHub', command=self.cmd_bugjar_github)
        self.menu_help.add_command(label='Open BeeWare project page', command=self.cmd_beeware_page)

        # last step - configure the menubar
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
## Tkinter below
root = Tk()
root.title("Updater ver: "+str(v))
root.minsize(280,300)

frame = Frame(root, height=210,width=600, relief=SUNKEN)
frame.pack_propagate(0)
frame.pack(anchor=NE,side=TOP,padx=20,pady=20)

S = Scrollbar(frame)
T = Text(frame, height=46, width=80,wrap=WORD)
        
S.pack(side=RIGHT, fill=Y)
T.pack(side=BOTTOM,fill=BOTH,expand=1)
S.config(command=T.yview)
T.tag_configure('redcol', foreground='red')
T.tag_configure('blackcol', foreground='black')
T.tag_configure('greencol', background='#c8d9ea',foreground='#009900')
T.tag_configure('failed', background='#c8d9ea',foreground='red')

button = Button(root, text='Reopen client', command=lambda: {restart_client(),root.destroy()})
button.place(x=180,y=250)
button2 = Button(root, text='Close', command=lambda: {root.destroy()})
button2.place(x=360,y=250)

## Create download link list 
tlist = []
tfile = readf('load/upd_filelist')

def worker_thread():

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
    def StartGui(self):
        self.tkRoot = Tk(baseName="")
        self.tkRoot.geometry("350x300+0+0")
        self.tkRoot.title("Engine SAPI GUI")
        self.GUIVisible = True

        frame = Frame(self.tkRoot)
        frame.style = Style()
        frame.style.theme_use("alt")
        frame.pack(fill=BOTH, expand=1)

        frame.columnconfigure(1, weight=1)
        frame.columnconfigure(7, pad=7)
        frame.rowconfigure(13, weight=1)
        frame.rowconfigure(13, pad=7)
        
        Label(frame, text="Start:").grid(row = 0, column=0)
        self.labelStart = Label(frame, text="0")
        self.labelStart.grid(row = 1, column=0)

        Label(frame, text="Length:").grid(row = 0, column=1)
        self.labelLength = Label(frame, text="0")
        self.labelLength.grid(row = 1, column=1)

        Label(frame, text="Total:").grid(row = 0, column=2)
        self.labelTotal = Label(frame, text="0")
        self.labelTotal.grid(row = 1, column=2)
        
        self.labelSentenceLeft = Label(frame, text="...")
        self.labelSentenceLeft.grid(row = 2, column=0, sticky=E)
        self.labelSentenceSpoken = Label(frame, text="...", foreground="red")
        self.labelSentenceSpoken.grid(row = 2, column=1)
        self.labelSentenceRight = Label(frame, text="...")
        self.labelSentenceRight.grid(row = 2, column=2, sticky=W, columnspan=2)   

        scrollbar = Scrollbar(frame, orient=VERTICAL)
        self.labelQueueToSpeak = Label(frame, text="Queue to speak:").grid(row = 3, column=0, pady=4, padx=5, sticky=W)
        self.listboxQueueToSpeak = Listbox(frame, width=50, height=3, yscrollcommand=scrollbar.set)
        
        scrollbar.config(command=self.listboxQueueToSpeak.yview)
        self.listboxQueueToSpeak.grid( sticky=N+S+E+W, row = 4, column = 0, columnspan = 2 ,rowspan = 3, padx=3)
        scrollbar.grid(sticky=N+S+W, row = 4, column = 2, rowspan = 3)

        self.buttonPauze = Button(frame, text="Pauze", command=self.communicationProtocal.handlePauze)
        self.buttonPauze.grid(row = 4, column=3)

        self.buttonStop = Button(frame, text="Stop", command=self.communicationProtocal.restartProcess)
        self.buttonStop.grid(row = 5, column=3)

        self.buttonResume = Button(frame, text="Resume", command=self.communicationProtocal.handleResume)
        self.buttonResume.grid(row = 6, column=3)

        Label(frame, text="Text to say:").grid(row = 7, column=0, padx=3, sticky=W)

        self.stringVarTextToSay = StringVar()
        self.entryTextToSay = Entry(frame, textvariable=self.stringVarTextToSay, width=500)
        self.entryTextToSay.grid(row=8, column=0, columnspan=3, padx=3, sticky=W)
        self.stringVarTextToSay.set("Hello SAPI Speak Engine")
        self.entryTextToSay.bind('<Return>', self.CallBackReturnSay)

        self.buttonSay = Button(frame, text="Say", command=self.CallBackButtonSay)
        self.buttonSay.grid(row = 8, column=3)

        Label(frame, text="Recover action:").grid(row = 9, column=0, padx=3, sticky=W)
        self.recoverActionLabelText = "None"
        self.labelRecoverAction = Label(frame, text=self.recoverActionLabelText, foreground="blue")
        self.labelRecoverAction.grid(row = 10, column=0)   

        Label(frame, text="Voice speed:").grid(row = 9, column=1, sticky=W)
        self.buttonSpeedDown = Button(frame, text="Speed down", command=self.communicationProtocal.handleSpeedDown)
        self.buttonSpeedDown.grid(row = 10, column=1, padx=3, sticky=E)

        self.speedValue = 0
        self.intVarSpeed = IntVar()
        vcmd = (self.tkRoot.register(self.OnValidateEntrySpeakSpeed), '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
        self.entrySpeakSpeed = Entry(frame, textvariable=self.intVarSpeed, validate="key", validatecommand=vcmd, width=5)
        self.entrySpeakSpeed.grid(row=10,column=2)
        self.entrySpeakSpeed.bind('<Return>', self.CallBackSetSpeed)

        self.buttonSpeedUp = Button(frame, text="Speed up", command=self.communicationProtocal.handleSpeedUp)
        self.buttonSpeedUp.grid(row = 10, column=3)

        Label(frame, text="voice:").grid(row = 11, column=0, padx=3, sticky=W)
        self.buttonPrevVoice = Button(frame, text="Prev voice", command=self.communicationProtocal.handlePrevVoice)
        self.buttonPrevVoice.grid(row = 12, column=0, padx=3, sticky=W)

        self.buttonNextVoice = Button(frame, text="Next voice", command=self.communicationProtocal.handleNextVoice)
        self.buttonNextVoice.grid(row = 12, column=3)

        self.currentVoice = StringVar(self.tkRoot)
        self.currentVoice.set(self.communicationProtocal.CurrentVoiceName)

        engine = pyttsx.init()
        voices = engine.getProperty("voices")
        voiceNames = list()
        for x in xrange(0, len(voices)):
            voiceNames.append(voices[x].name)
        self.optionMenuVoices = OptionMenu(frame, self.currentVoice, *tuple(voiceNames), command=self.CallBackOptionMenuVoices)
        self.optionMenuVoices.config(width=500)
        self.optionMenuVoices.grid(sticky=W, row = 12, column = 1)
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
class MacroFrame(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent, background="white")
        self.parent = parent
        self.numStates = 0
        self.initUI()

    def initUI(self):
        self.columnconfigure(0, weight=0)
        self.columnconfigure(1, weight=0)
        self.columnconfigure(2, weight=1)
        self.columnconfigure(3, weight=1)

        self.rowconfigure(0, weight=1)

        self.commandFrame = Frame(self, background="white")
        self.commandFrame.grid(row=0, column=0, columnspan=5, sticky=W + E)
        self.commandFrame.columnconfigure(1, weight=1)

        self.btnCommand = Button(self.commandFrame, text="Run")
        self.btnCommand.grid(row=0, column=0)

        self.strCommand = StringVar()
        self.entCommand = Entry(self.commandFrame, textvariable=self.strCommand)
        self.entCommand.grid(row=0, column=1, sticky=W + E)

        self.lstMacro = Listbox(self)
        self.lstMacro.grid(row=1, column=0, sticky=N + S + W + E)

        self.treeview = Treeview(self, columns=("Angle"), displaycolumns="#all", selectmode="browse")
        self.treeview.grid(row=1, column=1, columnspan=4, sticky=N + S + W + E)
        self.treeScrollbar = Scrollbar(self)
        self.treeScrollbar.grid(row=1, column=5, sticky=N + S)
        self.treeview.config(yscrollcommand=self.treeScrollbar.set)
        self.treeScrollbar.config(command=self.treeview.yview)

        self.btnFrame = Frame(self, background="white")
        self.btnFrame.grid(row=2, column=0, columnspan=5, sticky=W + E)

        self.btnRun = Button(self.btnFrame, text="Run", command=self.runMacro)
        self.btnRun.grid(row=0, column=0)

        self.btnStop = Button(self.btnFrame, text="Stop")
        self.btnStop.grid(row=0, column=1)

        self.btnSaveMacro = Button(self.btnFrame, text="Save Macro", command=self.saveMacro)
        self.btnSaveMacro.grid(row=0, column=2)

        self.btnDeleteMacro = Button(self.btnFrame, text="Delete Macro")
        self.btnDeleteMacro.grid(row=0, column=3)

        self.btnDeleteState = Button(self.btnFrame, text="Delete State")
        self.btnDeleteState.grid(row=0, column=4)

    def addState(self, robot):
        stateName = "state" + str(self.numStates)
        self.treeview.insert("", END, iid=stateName, text=stateName)
        limbNum = 0
        for limb in robot.getLimbs():
            limbName = "limb" + str(limbNum)
            self.treeview.insert(stateName, END, iid=stateName + "_" + limbName, text=limbName)
            partNum = 0
            for part in limb.getComponents():
                partName = "joint" + str(partNum)
                if isinstance(part, Joint):
                    self.treeview.insert(
                        stateName + "_" + limbName,
                        END,
                        iid=stateName + "_" + limbName + "_" + partName,
                        text=partName,
                        values=[part.angle],
                    )
                    partNum += 1
            limbNum += 1
        self.numStates += 1

    def getState(self, stateNum, robot):
        stateName = "state" + str(stateNum)
        limbNum = 0
        for limb in robot.getLimbs():
            limbName = "limb" + str(limbNum)
            partNum = 0
            for part in limb.getComponents():
                partName = "joint" + str(partNum)
                if isinstance(part, Joint):
                    part.setAngle(int(self.treeview.item(stateName + "_" + limbName + "_" + partName, "values")[0]))
                    partNum += 1
            limbNum += 1

    def runMacro(self):
        thread = threading.Thread(target=self.updateState)
        thread.start()

    def updateState(self):
        for i in range(self.numStates):
            self.getState(i, self.parent.robotFrame.robot)
            time.sleep(0.1)

    def saveMacro(self):
        pass

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
class GuiFrame():
  
    ## The constructor
    #
    #  @param  self          [in]   Object reference
    #  @param  parent        [in]   Root object reference
    #  @param  rulesFile     [in]   Rules file name
    #  @param  outDir        [in]   Location of output directory
    #  @return None
    def __init__(self, parent, rulesFile, outDir):
        self.exit = False
        self.parent = parent
        self.rulesFile = rulesFile
        self.outDir = outDir
        self.bgndFrm = None
        self.scrollbar = None
        self.log = None
        
        # Create the outdir if it doesn't exist
        if not os.path.exists(outDir):
            os.makedirs(outDir)
        
        self.initUI()
        self.parseRules = ParseRules(self)
        self.parseRules.verifyParameters()            
    
    ## Close button press
    #
    #  Called when the close button is pressed.  
    #
    #  @param  self          [in]   Object reference
    #  @return None
    def closeBtnPress(self):
        self.exit = True
        
    ## Init UI
    #
    #  Initialize the user interface.  Create the cmd panel at the
    #  top which contains the status and column headings.  Walk
    #  through the cardType array and create a panel for each card.
    #
    #  @param  self          [in]   Object reference
    #  @return None
    def initUI(self):
        self.parent.wm_title("Generate Python Code GUI")
        self.parent.columnconfigure(0, weight=1)
        self.parent.rowconfigure(0, weight=1)
        self.bgndFrm = Frame(self.parent)
        self.bgndFrm.grid()
        
        self.cmdPanel()
        self.consolePanel()
        
    ## Create command panel
    #
    #  Create the command panel.  It contains the close button.
    #
    #  @param  self          [in]   Object reference
    #  @return None
    def cmdPanel(self):
        tmpFrm = Frame(self.bgndFrm, borderwidth = 5, relief=RAISED)
        tmpFrm.grid()
        tmpFrm.grid(column = 0, row = 0)
        tmpBtn = Button(tmpFrm, width = 12, text="Close", command=self.closeBtnPress)
        tmpBtn.grid(column = 0, row = 0, padx=4, pady=8)
        
    ## Create console panel
    #
    #  Create the console panel.  It the console text box.
    #
    #  @param  self          [in]   Object reference
    #  @return None
    def consolePanel(self):
        tmpFrm = Frame(self.bgndFrm, borderwidth = 5, relief=RAISED)
        tmpFrm.grid()
        tmpFrm.grid(column = 0, row = 1)
        self.scrollbar = Scrollbar(tmpFrm)
        self.scrollbar.pack(side=RIGHT, fill=Y)
        self.log = Text(tmpFrm, wrap=WORD, yscrollcommand=self.scrollbar.set)
        self.log.pack()
        self.scrollbar.config(command=self.log.yview)
        
    ## Update console
    #
    #  Update the console window with new text
    #
    #  @param  self          [in]   Object reference
    #  @param  text          [in]   Text to be added to the console window
    #  @return None
    def updateConsole(self, text):
        self.log['state'] = 'normal'
        self.log.insert('end', text + "\n")
        self.log['state'] = 'disabled'
        self.log.see(END)
        
    ## GUI exit
    #
    #  Set the exit flag.
    #
    #  @param  self          [in]   Object reference
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
class Scrolling_Area(Frame, object):

    def __init__(self, master, width=None, height=None, mousewheel_speed = 2, scroll_horizontally=True, xscrollbar=None, scroll_vertically=True, yscrollbar=None, outer_background=None, inner_frame=Frame, **kw):
        super(Scrolling_Area, self).__init__(master, **kw)

        self.grid_columnconfigure(0, weight=1)
        self.grid_rowconfigure(0, weight=1)

        self._clipper = Frame(self, background=outer_background, width=width, height=height)
        self._clipper.grid(row=0, column=0, sticky=N+E+W+S)
        
        self._width = width
        self._height = height

        self.innerframe = inner_frame(self._clipper, padx=0, pady=0, highlightthickness=0)
        self.innerframe.place(in_=self._clipper, x=0, y=0)

        if scroll_vertically:
            if yscrollbar is not None:
                self.yscrollbar = yscrollbar
            else:
                self.yscrollbar = Scrollbar(self, orient=VERTICAL)
                self.yscrollbar.grid(row=0, column=1,sticky=N+S)
                
            self.yscrollbar.set(0.0, 1.0)
            self.yscrollbar.config(command=self.yview)
        else:
            self.yscrollbar = None
            
        self._scroll_vertically = scroll_vertically

        if scroll_horizontally:
            if xscrollbar is not None:
                self.xscrollbar = xscrollbar
            else:
                self.xscrollbar = Scrollbar(self, orient=HORIZONTAL)
                self.xscrollbar.grid(row=1, column=0, sticky=E+W)
            
            self.xscrollbar.set(0.0, 1.0)
            self.xscrollbar.config(command=self.xview)
        else:
            self.xscrollbar = None
            
        self._scroll_horizontally = scroll_horizontally

        self._jfraction=0.05
        self._startX = 0
        self._startY = 0       

        # Whenever the clipping window or scrolled frame change size,
        # update the scrollbars.
        self.innerframe.bind('<Configure>', self._on_configure)
        self._clipper.bind('<Configure>',  self._on_configure)
        
        self.innerframe.xview = self.xview
        self.innerframe.yview = self.yview

        Mousewheel_Support(self).add_support_to(self.innerframe, xscrollbar=self.xscrollbar, yscrollbar=self.yscrollbar)

    def update_viewport(self):
        # compute new height and width
        self.update()
        frameHeight = float(self.innerframe.winfo_reqheight())
        frameWidth = float(self.innerframe.winfo_reqwidth())
        
        if self._width is not None:
            width = min(self._width, frameWidth)
        else:
            width = self._frameWidth

        if self._height is not None:
            height = min(self._height, frameHeight)
        else:
            height = self._frameHeight
        
        self._clipper.configure(width=width, height=height)

    def _on_configure(self, event):
        self._frameHeight = float(self.innerframe.winfo_reqheight())
        self._frameWidth = float(self.innerframe.winfo_reqwidth())

        # resize the visible part
        if self._scroll_horizontally:
            self.xview("scroll", 0, "unit")
            
        if self._scroll_vertically:
            self.yview("scroll", 0, "unit")       

    def xview(self, mode = None, value = None, units = None):
        value = float(value)

        clipperWidth = self._clipper.winfo_width()
        frameWidth = self._frameWidth 
        
        _startX = self._startX

        if mode is None:
            return self.xscrollbar.get()
        elif mode == 'moveto':
            # absolute movement
#.........这里部分代码省略.........

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [as 别名]
    def create_gui_elements(self):
        top_frame = Frame(self)
        top_frame.grid(row=0, column=0, columnspan=9, rowspan=6)
        # top_frame.pack(fill=X)
        # image display
        photo2 = ImageTk.PhotoImage(Image.open('back.png'))
        image_display = Label(top_frame)
        image_display.configure(image=photo2)
        image_display.image = photo2
        image_display.grid(row=0, columnspan=9, column=1, rowspan=6)
        # image_lb.pack(side=TOP)
        self.add_gui_element(GUI_ELEMENT.IMAGE_DISPLAY_LABEL, image_display)
        close_button = Button(self, text='Close', command=close)
        close_button.grid(row=9, column=9)
        # close_button.pack(side=RIGHT, padx=5, pady=5)
        self.add_gui_element(GUI_ELEMENT.CLOSE_BTN, close_button)

        bottom_frame = Frame(self)
        bottom_frame.grid(row=5, column=0, columnspan=9, rowspan=3)
        # bottom_frame.pack(fill=X)
        config_frame = Frame(bottom_frame)
        config_frame.grid(row=5, column=6, columnspan=3, rowspan=3)
        # config_frame.pack(fill=X)

        list_box_frame = Frame(config_frame)
        list_box_frame.grid(row=5, column=6, columnspan=3, rowspan=3)
        # list_box_frame.pack(side=RIGHT)
        scrollbar = Scrollbar(list_box_frame)
        # scrollbar.pack(side=RIGHT, fill=Y)
        resolution_lb = Listbox(list_box_frame, selectmode=SINGLE, height=4, yscrollcommand=scrollbar.set)
        i = 0
        for resolution in ScreenPaper.get_resolution():
            resolution_lb.insert(i, '%dx%d' % (resolution[0], resolution[1]))
            i += 1
        scrollbar.grid(row=5, column=9, rowspan=9)
        resolution_lb.grid(row=5, column=6, rowspan=4, columnspan=3)
        scrollbar.config(command=resolution_lb.yview)
        # resolution_lb.pack(side=RIGHT)

        self.add_gui_element(GUI_ELEMENT.RESOLUTION_LB, resolution_lb)
        ok_btn = Button(self, text='Create', command=self.create_pape)
        ok_btn.grid(row=9, column=7)
        # ok_btn.pack(side=RIGHT)
        self.add_gui_element(GUI_ELEMENT.OK_BTN, ok_btn)
        save_btn = Button(self, text='Save', command=self.save_image_as)
        save_btn.grid(row=9, column=8)
        # save_btn.pack(side=RIGHT)
        self.add_gui_element(GUI_ELEMENT.SAVE_BTN, save_btn)

        checkbox_frame = Frame(config_frame)
        checkbox_frame.grid(row=5, column=0, rowspan=3, columnspan=6)
        auto_save_var = IntVar()
        auto_save_chk = Checkbutton(checkbox_frame, text="Save automatically", variable=auto_save_var, onvalue=1, offvalue=0)
        auto_save_chk.grid(row=5, column=1)
        # auto_save_chk.pack(side=BOTTOM)
        self.add_gui_element(GUI_ELEMENT.AUTOMATICALLY_SAVE_CK, {'element':auto_save_chk, 'var': auto_save_var})

        auto_upload_var = IntVar()
        auto_upload_chk = Checkbutton(checkbox_frame, text="Upload to imgur automatically", variable=auto_upload_var, onvalue=1, offvalue=0)
        auto_upload_chk.grid(row=6, column=1)
        # auto_upload_chk.pack(side=BOTTOM)
        self.add_gui_element(GUI_ELEMENT.AUTOMATICALLY_UPLOAD_CK, {'element': auto_upload_chk, 'var': auto_upload_var})
        # checkbox_frame.pack(side=RIGHT)
        message_lb = Label(self)
        message_lb.grid(row=7, column=1)
        # message_lb.pack(side=BOTTOM)
        self.add_gui_element(GUI_ELEMENT.MESSAGE_LABEL, message_lb)

# 需要导入模块: from ttk import Scrollbar [as 别名]
# 或者: from ttk.Scrollbar import config [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')
#.........这里部分代码省略.........