Python Frame.grid方法代码示例

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
class RadioButtonList:  # Widget class
    def __init__(self, frm, name, ch1, ch2, st, i):
        self.frame = Frame(frm.frame)
        self.frame.grid()
        self.ch1 = ch1
        self.ch2 = ch2
        self.i = i
        self.st = st
        v = IntVar()
        self.v = v
        self.shuu = name
        self.length = len(name)
        self.rb = {}
        r = 0
        self.r = r
        for txt, val in name:
            self.rb[r] = Radiobutton(frm.frame, text=txt, padx=20, variable=v, value=val, command=self.onclick)
            self.rb[r].grid(row=i + r, column=0, sticky=W, pady=2)
            r = r + 1
        self.r = r

    def onclick(self):
        if self.ch1 == 1:
            if self.v.get() == self.ch2:
                self.st.set_text("true")
                # v.add(self.st,self.i+self.r+1)
            else:
                self.st.set_text("false")
                # v.add(self.st,self.i+self.r+1)
        else:
            self.st.set_text("Your choice:" + self.shuu[self.v.get() - 1][0])

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
    def startVid(self):
        gobject.threads_init()
        video = Frame(self, background='black')
        video.grid(row=0, column=0, columnspan=8, rowspan=4, padx=2, sticky=E+W+S+N)
        window_id = video.winfo_id()
     
        self.buf = gst.Buffer()

        self.bin = gst.Bin("my-bin")
        timeoverlay = gst.element_factory_make("timeoverlay", "overlay")
        self.bin.add(timeoverlay)
        pad = timeoverlay.get_pad("video_sink")
        ghostpad = gst.GhostPad("sink", pad)
        self.bin.add_pad(ghostpad)
        videosink = gst.element_factory_make("ximagesink")
        self.bin.add(videosink)
        gst.element_link_many(timeoverlay, videosink)
    
        self.player.set_property('video-sink', self.bin)
        self.player.set_property('uri', 'file://%s' % (os.path.abspath(self.project.videoPath)))

        bus = self.player.get_bus()
        bus.add_signal_watch()
        bus.enable_sync_message_emission()

        bus.connect("message", self.on_message, window_id)
        bus.connect('sync-message::element', self.on_sync_message, window_id)

        self.play.configure(command=lambda: self.play_video())

        self.back.configure(command=self.play_back)

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

        self.control_panel = MainControlFrame(self, sequencer)
        self.control_panel.grid(row=0, column=0, sticky='ns')

        self.instrument_panel = Frame(self)
        self.instrument_panel.grid(row=0, column=1)

        self.rythm_track_frames = []

        for id, instrument in enumerate(sequencer.instruments):
            instrument_frame = get_instrument_frame(self.instrument_panel, instrument)
            instrument_frame.grid(row=id, column=0, sticky="NSEW")

            instrument_track_frame = Frame(self.instrument_panel)
            instrument_track_frame.grid(row=id, column=1, sticky="NSEW", padx=3, pady=3)

            tracks = [track for track in sequencer.tracks if track.instrument_id == id]
            for row, track in enumerate(tracks):
                rt_frame = RhythmTrackFrame(instrument_track_frame, track, sequencer)
                rt_frame.grid(row=row, column=0, sticky="EW")
                self.rythm_track_frames.append(rt_frame)

        self.events = []
        sequencer.add_observer(self)

        self.running = True
        self.consume()

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
    def insert_frame(self, name, parent_frame_name, idx, frame_type=None, **kwargs):
        parent_frame = self.frames[parent_frame_name]
        frame = Frame(parent_frame)

        # add frame to list of frames
        self.frames[name] = frame

        # pre-fill the frame
        if frame_type is None:
            pass
        elif frame_type == 'plot':
            # generate canvas
            dim = kwargs['shape']
            f = Figure(figsize=dim, dpi=113  )
            a = f.add_subplot(111)
            canvas = FigureCanvasTkAgg(f, master=frame)
            
            # Commit the canvas to the gui
            canvas.get_tk_widget().pack()

            # save canvas data for later access
            self.mpl_data[name] = {}
            self.frame_data['plot'] = {'mpl_canvas':canvas}

        # commit the frame to workspace
        frame.grid(row=idx[0], column=idx[1])

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
 def _create_treeview(self, parent):
     f = Frame(parent)
     #f.pack(side=TOP, fill=BOTH, expand=Y)
     f.grid(row=0, column=0, sticky=NSEW, columnspan=3)
     
     # create the tree and scrollbars
     self.dataCols = ('fullpath', 'type', 'status')       
     self.tree = Treeview(columns=self.dataCols,
                              displaycolumns='status')
     
     ysb = Scrollbar(orient=VERTICAL, command= self.tree.yview)
     xsb = Scrollbar(orient=HORIZONTAL, command= self.tree.xview)
     self.tree['yscroll'] = ysb.set
     self.tree['xscroll'] = xsb.set
     
     # setup column headings
     self.tree.heading('#0', text='Directory Structure', anchor=W)
     self.tree.heading('status', text='Status', anchor=W)
     self.tree.column('status', stretch=0, width=100)
     
     # add tree and scrollbars to frame
     self.tree.grid(in_=f, row=0, column=0, sticky=NSEW)
     ysb.grid(in_=f, row=0, column=1, sticky=NS)
     xsb.grid(in_=f, row=1, column=0, sticky=EW)
     
     # set frame resizing priorities
     f.rowconfigure(0, weight=1)
     f.columnconfigure(0, weight=1)
     
     # action to perform when a node is expanded
     self.tree.bind('<<TreeviewOpen>>', self._update_tree)
     
     self.tree.bind("<Double-1>", self.OnDoubleClick)

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
class FileDialog(Frame):
    def __init__(self, parent, text):
        self.sukh = parent
        self.text = text
        self.frame = Frame(parent.frame)
        self.frame.grid()

    def get_value(self):
        ftypes = [(self.text, "*.jpg")]
        dlg = tkFileDialog.Open(filetypes=ftypes)
        fl = dlg.show()
        return fl

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
 def _create_panel(self):
     
     panel = Frame(self, name='elastic')
     #panel.pack(side=TOP, fill=BOTH, expand=Y)
     panel.grid(row=0, column=0, sticky=NSEW) 
     nb = Notebook(panel, name='notebook')
     
     nb.enable_traversal()
     #nb.pack(fill=BOTH, expand=Y, padx=2, pady=3)
     nb.grid(row=0, column=0, sticky=NSEW)
     self._create_setup_tab(nb)
     self._create_analyze_tab(nb)

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
    def create_frame(self, name, idx, frame_type=None, **kwargs):
        """Creates a gridded frame inside the window.
        ARGS:
          * name: name of the frame
          * idx: tuple containing the (r,c) designation of the frame
          within the grid. r=row. c=column."""
        # create the frame
        frame = Frame(self.window)

        # add frame to list of frames
        self.frames[name] = frame

        # pre-fill the frame
        if frame_type is None:
            pass
        elif frame_type == 'plot':
            # determine initialization variables
            dim = kwargs.get('shape', None)
            ylim = kwargs.get('ylim', None)
            xlim = kwargs.get('xlim', None)
            xticks = kwargs.get('xticks', None)

            # generate the figure
            f = Figure(figsize=dim, dpi=113  )
            a = f.add_subplot(111)

            # generate canvas
            canvas = FigureCanvasTkAgg(f, master=frame)

            # set axes ticks
            if ylim is not None:
                a.set_ylim(*ylim)

            if xlim is not None:
                a.set_xlim(*xlim)

            if xticks is not None:
                a.set_xticks(xticks)

            # Commit the canvas to the gui
            canvas.get_tk_widget().pack()

            # save canvas data for later access
            self.mpl_data[name] = {'axes':a,
                                   'figure':f,
                                   'canvas':canvas}
                                   
            self.frame_data['plot'] = {'mpl_canvas':canvas}

        # commit the frame to workspace
        frame.grid(row=idx[0], column=idx[1])

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
class SequencerFrame(Frame):
    def __init__(self, master, sequencer):
        Frame.__init__(self, master)
        self.sequencer = sequencer

        self.control_panel = MainControlFrame(self, sequencer)
        self.control_panel.grid(row=0, column=0, sticky='ns')

        self.instrument_panel = Frame(self)
        self.instrument_panel.grid(row=0, column=1)

        self.rythm_track_frames = []

        for id, instrument in enumerate(sequencer.instruments):
            instrument_frame = get_instrument_frame(self.instrument_panel, instrument)
            instrument_frame.grid(row=id, column=0, sticky="NSEW")

            instrument_track_frame = Frame(self.instrument_panel)
            instrument_track_frame.grid(row=id, column=1, sticky="NSEW", padx=3, pady=3)

            tracks = [track for track in sequencer.tracks if track.instrument_id == id]
            for row, track in enumerate(tracks):
                rt_frame = RhythmTrackFrame(instrument_track_frame, track, sequencer)
                rt_frame.grid(row=row, column=0, sticky="EW")
                self.rythm_track_frames.append(rt_frame)

        self.events = []
        sequencer.add_observer(self)

        self.running = True
        self.consume()


    def consume(self):
        if not self.running:
            return
        while len(self.events) > 0:
            time = self.events.pop().time
            for rt in self.rythm_track_frames:
                rt.set_time(time)
        self.after(UPDATE_INTERVAL,self.consume)

    def notify(self, event):
        self.events.append(event)

    def destroy(self):
        self.running = False
        return Frame.destroy(self)

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
    def __init__(self, master=None, title=None, message=None, data = []):
        self.master = master
        self.value = None
        self.data = data
        
        self.modalPane = Toplevel(self.master)

        self.modalPane.transient(self.master)
        self.modalPane.grab_set()

        self.modalPane.bind("<Return>", self._choose)
        self.modalPane.bind("<Escape>", self._cancel)
        
        self.modalPane.columnconfigure(0, pad = 5, weight = 1)
        
        self.modalPane.rowconfigure(0, pad = 5)
        self.modalPane.rowconfigure(1, pad = 5, weight = 1)
        self.modalPane.rowconfigure(2, pad = 5)

        if title:
            self.modalPane.title(title)

        if message:
            Label(self.modalPane, text=message).grid(row = 0, column = 0, padx = 10, sticky = W+E)

        listFrame = Frame(self.modalPane)
        listFrame.grid(row = 1, column = 0, sticky = W+E)
        
        scrollBar = Scrollbar(listFrame)
        scrollBar.pack(side=RIGHT, fill=Y)
        self.listBox = Listbox(listFrame, selectmode = SINGLE)
        self.listBox.pack(side = LEFT, fill = BOTH, expand = True)
        scrollBar.config(command = self.listBox.yview)
        self.listBox.config(yscrollcommand=scrollBar.set)
        for item in self.data:
            self.listBox.insert(END, item)

        buttonFrame = Frame(self.modalPane)
        buttonFrame.grid(row = 2, column = 0, sticky = W+E)

        chooseButton = Button(buttonFrame, text="Choose", command=self._choose)
        chooseButton.pack(padx=5, pady=5, side = LEFT)

        cancelButton = Button(buttonFrame, text="Cancel", command=self._cancel)
        cancelButton.pack(padx=5, pady=5, side=RIGHT)

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
class GeneralActionModulation(Frame):
    def __init__(self,parent):
        Frame.__init__(self,parent)
        self.parent = parent
        self.initUI()
        
    def initUI(self):
        self.frame = Frame(self.parent, relief=RAISED,borderwidth=1)
        self.frame_text = Frame(self.frame, relief=RAISED,borderwidth=1)
        self.frame_text.grid(row=0 , column=0)
        self.area = Text(self.frame_text)
        self.area.grid(row=0, column=0, columnspan=1, rowspan=1, 
            padx=5)
        
    def getFrame(self):
        return self.frame
    
    def getText(self):
        return self.area.get('1.0', 'end')

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
        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')
            self.log.pack(fill=BOTH, expand=True)

            # attach text box to scrollbar
            self.log.config(yscrollcommand=self.scrollbar.set)
            self.scrollbar.config(command=self.log.yview)

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
    def __init__(self, master):
        self.master = master
        master.title("Convert SPC files")

        mf = Frame(master, padding="10")
        mf.grid(column=0, row=0, sticky=(N, W, E, S))
        mf.columnconfigure(0, weight=1)
        mf.rowconfigure(0, weight=1)
        self.message = "Enter folder containing *.SPC files"
        self.label_text = StringVar()
        self.folder = StringVar()
        self.output_fmt = StringVar()

        self.label_text.set(self.message)

        self.label = Label(mf, textvariable=self.label_text)
        self.folder_label = Label(mf, text="Folder")
        self.output_fmt_label = Label(mf, text="Output Format")

        self.fmt_txt = Radiobutton(mf, text="TXT", variable=self.output_fmt, value='txt')
        self.fmt_csv = Radiobutton(mf, text="CSV", variable=self.output_fmt, value='csv')
        self.folder_entry = Entry(mf, textvariable=self.folder)

        self.sel_foler = Button(mf, text="Browse", command=self.ask_dir)
        self.convert_btn = Button(mf, text="Convert", command=self.convert)

        # map on grid
        self.label.grid(row=0, column=0, columnspan=4, sticky=W + E)
        self.folder_label.grid(row=1, column=0, sticky=E)
        self.output_fmt_label.grid(row=2, column=0, sticky=E)
        self.folder_entry.grid(row=1, column=1, columnspan=2, sticky=W + E)
        self.fmt_txt.grid(row=2, column=1, sticky=W)
        self.fmt_csv.grid(row=2, column=2, sticky=W)
        self.sel_foler.grid(row=1, column=3, sticky=W)
        self.convert_btn.grid(row=3, column=1, columnspan=2, sticky=W + E)

        for child in mf.winfo_children():
            child.grid_configure(padx=5, pady=5)

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

    def initUI(self):
        self.parent.title("Test")
        self.frameTab = Frame(self, relief=RAISED, borderwidth=1)
        self.frameTab.grid(row=3, column=0, columnspan=4)
        self.grid(row=0, column=0)
        self.frameTab.grid(row=0, column=0)
        self.note_book = Notebook(self.frameTab)
        self.specific_actions = ActionModulation.ActionModulation(self.note_book)
        self.note_book.add(self.specific_actions.getFrame(), text="specific actions")
        self.general_actions = GeneralActionModulation.GeneralActionModulation(self.note_book)
        self.note_book.add(self.general_actions.getFrame(), text="general actions")
        self.note_book.grid(row=0, column=0)

        self.frameButtons = Frame(self, relief=RAISED, borderwidth=1)
        self.frameButtons.grid(row=3, column=0, columnspan=4)
        self.buttonReset = Button(self.frameButtons, text="Reset")
        self.buttonReset.grid(row=0, column=0)
        self.buttonAbort = Button(self.frameButtons, text="Abort")
        self.buttonAbort.grid(row=0, column=1)
        self.buttonStop = Button(self.frameButtons, text="Stop")
        self.buttonStop.grid(row=0, column=2)
        self.buttonSendAction = Button(self.frameButtons, text="Send Action")
        self.buttonSendAction.grid(row=0, column=4)
        self.buttonSendEmotion = Button(self.frameButtons, text="Send Emotion")
        self.buttonSendEmotion.grid(row=0, column=5)

    def getCurrentTab(self):
        return self.note_book.index(self.note_book.select())

    def getFirstTab(self):
        return self.specific_actions

    def getSecondTab(self):
        return self.general_actions

    def getButtonSendAction(self):
        return self.buttonSendAction

    def getButtonSendEmotion(self):
        return self.buttonSendEmotion

    def getButtonReset(self):
        return self.buttonReset

    def getButtonAbort(self):
        return self.buttonAbort

    def getButtonStop(self):
        return self.buttonStop

# 需要导入模块: from ttk import Frame [as 别名]
# 或者: from ttk.Frame import grid [as 别名]
    def __init__(self, root):
        self.root=root  

        ###CANVAS###

        im = PIL.Image.open('field.jpg')
        self.canvas=tk.Canvas(root, width=1300, height=846)
        self.canvas.grid(row=0, column=0)

        self.canvas.image = ImageTk.PhotoImage(im)
        self.canvas.create_image(635,423,image = self.canvas.image)

        self.canvas.create_rectangle(0,843, 200, 846, fill="blue")
        self.canvas.create_rectangle(0,843, 3, 646, fill="red")

        self.canvas.create_text(200, 836, text="X", fill="blue")
        self.canvas.create_text(10, 646, text="Y", fill="red")

        ###FRAME###

        frame=Frame(self.root)
        frame.grid(row=0,column=1, sticky=W)

            ###ROBOT-COORDINATES###SMALL

        RobotCoordinates = Label(frame, text = "SMALL ROBOT")
        RobotCoordinates.grid(row = 1, column = 1)

        Coordinates = Label(frame, text="Robot Coordinates: ")
        Coordinates.grid(row = 6, column = 1, sticky=W)

        curX = Label(frame, text="X =")
        curX.grid(row=7, column=1, sticky=E)

        curY = Label(frame, text="Y =")
        curY.grid(row=8, column=1, sticky=E)

        curA = Label(frame, text="A =")
        curA.grid(row=9, column=1, sticky=E)

        self.curXValue = Text(frame, height=1, width=5)
        self.curXValue.grid(row=7, column=2, sticky=W)

        self.curYValue = Text(frame, height=1, width=5)
        self.curYValue.grid(row=8, column=2, sticky=W)

        self.curAValue = Text(frame, height=1, width=5)
        self.curAValue.grid(row=9, column=2, sticky=W)

            ###LIDAR-COORDINATES###

        CoordinatesL = Label(frame, text="Lidar Coordinates: ")
        CoordinatesL.grid(row = 10, column = 1, sticky=W)

        curXL = Label(frame, text="X =")
        curXL.grid(row=11, column=1, sticky=E)

        curYL = Label(frame, text="Y =")
        curYL.grid(row=12, column=1, sticky=E)

        curAL = Label(frame, text="A =")
        curAL.grid(row=13, column=1, sticky=E)

        self.curXLValue = Text(frame, height=1, width=5)
        self.curXLValue.grid(row=11, column=2, sticky=W)

        self.curYLValue = Text(frame, height=1, width=5)
        self.curYLValue.grid(row=12, column=2, sticky=W)

        self.curALValue = Text(frame, height=1, width=5)
        self.curALValue.grid(row=13, column=2, sticky=W)

            ###COLLISION AVOIDANCE###

        coll = Label(frame, text="Collision:")
        coll.grid(row = 14, column = 1)

        self.collValue = Text(frame, height=1, width=3)
        self.collValue.grid(row=14,column=2,sticky=W)

            ###ADC###

        ADC = Label(frame, text="Client Small: ")
        ADC.grid(row = 15, column = 1)
        self.ADCValue = Text(frame, height=10, width=10)
        self.ADCValue.grid(row=16, column=1)

        ###BIG ROBOT########
        ###BIG ROBOT###
        ###BIG ROBOT COORDINATES###

        RobotCoordinatesB = Label(frame, text = "BIG ROBOT")
        RobotCoordinatesB.grid(row = 1, column = 3)

        CoordinatesB = Label(frame, text="Robot Coordinates: ")
        CoordinatesB.grid(row = 6, column = 3, sticky=W)

        curXB = Label(frame, text="X =")
        curXB.grid(row=7, column=3, sticky=E)

#.........这里部分代码省略.........