Пример #1
0
 def _create_buttons(self):
     frame = Frame(self)
     self._create_button(frame, self._left_button,
                         self._left_button_clicked)
     self._create_button(frame, self._right_button,
                         self._right_button_clicked)
     frame.pack()
Пример #2
0
    def _init_components(self):
        self.columnconfigure(0, weight=1)
        self.rowconfigure(0, weight=1)

        upper_pane = Frame(self)
        upper_pane.columnconfigure(0, weight=1)
        upper_pane.rowconfigure(0, weight=1)

        self.apex_list = ApexList(upper_pane, self._apex)
        self.apex_list.grid(row=0, column=0, sticky='nesw')

        self._scrollbar_x = Scrollbar(upper_pane, command=self.apex_list.xview,
            orient='horizontal')
        self._scrollbar_x.grid(row=1, column=0, sticky='ews')
        self.apex_list['xscrollcommand'] = self._scrollbar_x.set
        self._scrollbar_y = Scrollbar(upper_pane, command=self.apex_list.yview)
        self._scrollbar_y.grid(row=0, column=1, sticky='nse')
        self.apex_list['yscrollcommand'] = self._scrollbar_y.set

        buttons_pane = Frame(self)

        self._expand_button = Button(buttons_pane, text="Expand all",
            command=self.apex_list.expand_all)
        self._expand_button.pack(side='left', expand=True, fill='x')

        self._reset_button = Button(buttons_pane, text="Reset",
            command=self.apex_list.reset)
        self._reset_button.pack()

        upper_pane.grid(sticky='nesw')
        buttons_pane.grid(row=1, sticky='nesw')
Пример #3
0
    def __init__( self, net, parent=None, width=4 ):
        Frame.__init__( self, parent )
        self.top = self.winfo_toplevel()
        self.top.title( 'Mininet' )
        self.net = net
        self.menubar = self.createMenuBar()
        cframe = self.cframe = Frame( self )
        self.consoles = {}  # consoles themselves
        titles = {
            'hosts': 'Host',
            'switches': 'Switch',
            'controllers': 'Controller'
        }
        for name in titles:
            nodes = getattr( net, name )
            frame, consoles = self.createConsoles(
                cframe, nodes, width, titles[ name ] )
            self.consoles[ name ] = Object( frame=frame, consoles=consoles )
        self.selected = None
        self.select( 'hosts' )
        self.cframe.pack( expand=True, fill='both' )
        cleanUpScreens()
        # Close window gracefully
        Wm.wm_protocol( self.top, name='WM_DELETE_WINDOW', func=self.quit )

        # Initialize graph
        graph = Graph( cframe )
        self.consoles[ 'graph' ] = Object( frame=graph, consoles=[ graph ] )
        self.graph = graph
        self.graphVisible = False
        self.updates = 0
        self.hostCount = len( self.consoles[ 'hosts' ].consoles )
        self.bw = 0

        self.pack( expand=True, fill='both' )
class App:
	def __init__(self,parent):
		# Create frame, buttons, etc
		self.f = Frame(parent)
		self.f.pack(padx=15,pady=15)
    
   		self.entry = Entry(self.f,text="Enter the search term")
		self.entry.pack(side= TOP,padx=10,pady=12)
		self.entry.bind("<Key>", self.key)
		self.entry.focus_set()
		
		self.exit = Button(self.f, text="Exit", command=self.f.quit)
		self.exit.pack(side=BOTTOM,padx=10,pady=10)

		self.button = Button(self.f, text="Search",command=self.search)
		self.button.pack(side=BOTTOM,padx=10,pady=10)

	def key(self, event):
		# If ENTER was pressed, search
		if event.char == '\r':
			self.search()

	def search(self):
		# If there's something to search, search!
		if self.entry.get() != '':
			self.button.config(text='Searching...', state=DISABLED)

			th = SearchThread(self, self.entry.get())
			th.start()
		else:
			tkMessageBox.showinfo('Hey', 'You should type something in the search. That\'s the point, really...')
Пример #5
0
    def __init__( self, parent, net, node, height=10, width=32, title='Node' ):
        Frame.__init__( self, parent )

        self.net = net
        self.node = node
        self.prompt = node.name + '# '
        self.height, self.width, self.title = height, width, title

        # Initialize widget styles
        self.buttonStyle = { 'font': 'Monaco 7' }
        self.textStyle = {
            'font': 'Monaco 7',
            'bg': 'black',
            'fg': 'green',
            'width': self.width,
            'height': self.height,
            'relief': 'sunken',
            'insertbackground': 'green',
            'highlightcolor': 'green',
            'selectforeground': 'black',
            'selectbackground': 'green'
        }

        # Set up widgets
        self.text = self.makeWidgets( )
        self.bindEvents()
        self.sendCmd( 'export TERM=dumb' )

        self.outputHook = None
Пример #6
0
Файл: ui.py Проект: g3rg/nPhoto
 def __init__(self, parent, title=None):
     Toplevel.__init__(self, parent)
     self.transient(parent)
     
     if title:
         self.title(title)
         
     self.parent = parent
     self.result = None
     
     body = Frame(self)
     self.initial_focus = self.body(body)
     body.pack(padx=5, pady=5)
     
     self.buttonbox()
     self.grab_set()
     if not self.initial_focus:
         self.initial_focus = self
         
     self.protocol("WM_DELETE_WINDOW", self.cancel)
     
     self.geometry("+%d+%d" % (parent.winfo_rootx()+50, parent.winfo_rooty()+50))
 
     self.initial_focus.focus_set()
     self.wait_window(self)
Пример #7
0
    def __init__(self, parent):

        # IMAGES #########
        self.NODE_IMG = [
            ImageTk.PhotoImage(Image.open("img/node1.png")),
            ImageTk.PhotoImage(Image.open("img/node2.png")),
            ImageTk.PhotoImage(Image.open("img/node3.png")),
            ImageTk.PhotoImage(Image.open("img/node4.png")),
        ]

        self.BG = ImageTk.PhotoImage(Image.open("img/map.png"))

        self.FLAG_AXIS = ImageTk.PhotoImage(Image.open("img/flag_axis.png"))
        self.FLAG_ALLY = ImageTk.PhotoImage(Image.open("img/flag_ally.png"))

        self.CANNON = ImageTk.PhotoImage(Image.open("img/cannon.png"))
        self.FORTRESS = ImageTk.PhotoImage(Image.open("img/fort.png"))
        #################

        Frame.__init__(self, parent)

        self.parent = parent
        self.init_ui()
        self.update_ui()
        self.update_menu()
Пример #8
0
    def __init__(self, parent, net, node, height=10, width=32, title="Node"):
        Frame.__init__(self, parent)

        self.net = net
        self.node = node
        self.prompt = node.name + "# "
        self.height, self.width, self.title = height, width, title

        # Initialize widget styles
        self.buttonStyle = {"font": "Monaco 7"}
        self.textStyle = {
            "font": "Monaco 7",
            "bg": "black",
            "fg": "green",
            "width": self.width,
            "height": self.height,
            "relief": "sunken",
            "insertbackground": "green",
            "highlightcolor": "green",
            "selectforeground": "black",
            "selectbackground": "green",
        }

        # Set up widgets
        self.text = self.makeWidgets()
        self.bindEvents()
        self.sendCmd("export TERM=dumb")

        self.outputHook = None
Пример #9
0
	def __init__ (self):
		self.app = Tk()
		self.app.title('Tic Tac Toe')
		#self.app.resizable(width=False, height=False)
		#width and hight of window
		w = 900
		h = 1100
		#width and hight of screen
		ws = self.app.winfo_screenwidth()
		hs = self.app.winfo_screenheight()
		#calculate position
		x = ws/2 - w/2
		y = hs/2 - h/2
		#place window -> pramaters(visina, dolzina, pozicija x, pozicija y)
		self.app.geometry("%dx%d+%d+%d" % (w,h, x, y))

		#======================================
		self.frame = Frame() #main frame
		self.frame.pack(fill = 'both', expand = True)
		self.label = Label(self.frame, text	= 'Tic Tac Toe', height = 4, bg = 'white', fg = 'blue')
		self.label.pack(fill='both', expand = True)
		#self.label2 = Label(self.frame, text	= 'here', height = 2, bg = 'white', fg = 'blue') odkomentiri samo za develop-------------
		#self.label2.pack(fill='both', expand = True)
		self.canvas = Canvas(self.frame, width = 900, height = 900)
		self.canvas.pack(fill = 'both', expand = True)
		self.framepod = Frame(self.frame)#sub frame
		self.framepod.pack(fill = 'both', expand = True)
		self.Single = Button(self.framepod, text = 'Start single player', height = 4, command = self.startsingle, bg = 'white', fg = 'blue')
		self.Single.pack(fill='both', expand = True, side=RIGHT)
		self.Multi = Button(self.framepod, text = 'Start double player', height = 4, command = self.double, bg = 'white', fg = 'blue')
		self.Multi.pack(fill='both', expand = True, side=RIGHT)
		self.board = AI()
		self.draw()
Пример #10
0
    def __init__(self, parent, scrollbar=True, **kw):

        parent = mx.get_master(parent)
        self.parent = parent
        
        frame = Frame(parent)
        frame.pack(fill='both', expand=True)
        
        # text widget
        if "wrap" not in kw:
            kw["wrap"] = "word"
        tk.Text.__init__(self, frame, **kw)
        #self.pack(side='left', fill='both', expand=True)
        mx.AllMixins.__init__(self, parent)
        
        # scrollbar
        if scrollbar:
            scrb = Scrollbar(frame, orient='vertical', command=self.yview) 
            self.config(yscrollcommand=scrb.set)
            scrb.pack(side='right', fill='y')
        
        # pop-up menu
        self.popup = Menu(self, tearoff=0)
        self.popup.add_command(label='Cut', command=self._cut)
        self.popup.add_command(label='Copy', command=self._copy)
        self.popup.add_command(label='Paste', command=self._paste)
        self.popup.add_separator()
        self.popup.add_command(label='Select All', command=self._select_all)
        self.popup.add_command(label='Clear All', command=self._clear_all)
        self.bind('<Button-3>', self._show_popup)

        # only allow mouse scroll when mouse inside text
        self.bind("<Leave>", lambda event: self.winfo_toplevel().focus_set(), "+")
        self.bind("<Enter>", lambda event: self.focus_set(), "+")
Пример #11
0
    def __init__(self, net, parent=None, width=4):
        Frame.__init__(self, parent)
        self.top = self.winfo_toplevel()
        self.top.title("Mininet")
        self.net = net
        self.menubar = self.createMenuBar()
        cframe = self.cframe = Frame(self)
        self.consoles = {}  # consoles themselves
        titles = {"hosts": "Host", "switches": "Switch", "controllers": "Controller"}
        for name in titles:
            nodes = getattr(net, name)
            frame, consoles = self.createConsoles(cframe, nodes, width, titles[name])
            self.consoles[name] = Object(frame=frame, consoles=consoles)
        self.selected = None
        self.select("hosts")
        self.cframe.pack(expand=True, fill="both")
        cleanUpScreens()
        # Close window gracefully
        Wm.wm_protocol(self.top, name="WM_DELETE_WINDOW", func=self.quit)

        # Initialize graph
        graph = Graph(cframe)
        self.consoles["graph"] = Object(frame=graph, consoles=[graph])
        self.graph = graph
        self.graphVisible = False
        self.updates = 0
        self.hostCount = len(self.consoles["hosts"].consoles)
        self.bw = 0

        self.pack(expand=True, fill="both")
Пример #12
0
    def __init__(self, parent, name="X"):
        """
        Initialisation

        parent : un oscilloscope
        name : nom du signal
        """
        Frame.__init__(self)
        self.configure(bd=1, relief="sunken")
        self.parent = parent
        self.name = name
        self.drawVar = IntVar()
        self.signal = None

        self.draw = Checkbutton(self,text="Afficher "+self.name, selectcolor=eval('self.parent.view.color_'+name), variable=self.drawVar, onvalue = 1, offvalue = 0, command=self.parent.plot_all)
        self.draw.pack()
        self.draw.select()

        self.scale_A = Scale(self, length=100, orient="horizontal",
                label=name + " Amplitude", showvalue=1, from_=0, to=10,
                tickinterval=1, command=self.update_signal)
        self.scale_A.pack(expand="yes", fill="both")

        self.scale_F = Scale(self, length=100, orient="horizontal",
                label=name + " Fréquence", showvalue=1, from_=1, to=10,
                tickinterval=1, command=self.update_signal)
        self.scale_F.pack(expand="yes", fill="both")

        self.scale_P = Scale(self, length=100, orient="horizontal",
                label=name + " Phase", showvalue=1, from_=0, to=10,
                tickinterval=1, command=self.update_signal)
        self.scale_P.pack(expand="yes", fill="both")

        
        self.bind("<Configure>",self.update_signal)
Пример #13
0
 def home(self):
     self.frame1 = Frame(self.root, width=750, height=350, padx=250, bg="black")
     self.frame2 = Frame(self.root, height=250, width=750, bg="black", padx=25)
     self.root.wm_minsize(width=750, height=666)
     self.root.configure(bg="black")
     self.frame1.pack_propagate(0)
     self.frame1.update()
     self.frame1.configure(pady=self.frame1.cget("height") / 2.5)
     logo = PhotoImage(file="Game_Logo.gif")
     starth = Button(self.frame1, text="Hard", bg="orange", padx=25, pady=5,
                     font=Font(family="comic sans MS", size=10),
                     command=lambda: self.callgame(40))
     startm = Button(self.frame1, text="Medium", bg="teal", padx=25, pady=5,
                     font=Font(family="comic sans MS", size=10),
                     command=lambda: self.callgame(60))
     starte = Button(self.frame1, text="Easy", bg="orange", padx=25, pady=5,
                     font=Font(family="comic sans MS", size=10),
                     command=lambda: self.callgame(75))
     self.frame2.pack_propagate(0)
     exp = """        This is a game in which
     the arrow keys are used
     to move the snake around
     and to get points"""
     exf = Font(family="comic sans MS", size=20)
     Label(self.frame2, image=logo, bg="black", text=exp, padx=10).pack(side="right")
     Label(self.frame2, fg="white", bg="black", text=exp, justify="left", font=exf).pack(side="left")
     starte.grid(row=0, columnspan=2)
     startm.grid(row=0, columnspan=2, column=4, padx=18)
     starth.grid(row=0, columnspan=2, column=8)
     head = Font(family="comic sans MS", size=30)
     self.H=Label(self.root, text="SNAKES", font=head, fg="orange", bg="black", pady=10)
     self.H.pack()
     self.frame2.pack(expand=True)
     self.frame1.pack(expand=True)
     self.root.mainloop()
Пример #14
0
 def __init__(self, master=None, title='', items=(('客户名称',36),('机构类型',10),('国别', 10),('营业执照编号',20),('注册资本',10)), next_func=None):
     Frame.__init__(self, master, relief=Tkinter.GROOVE )
     self.mutilistbox_items = items
     self.next_func = next_func
     self.next_func_button = None
     self.title = title
     self.create_widget()
Пример #15
0
    def __init__(self, parent):
        Frame.__init__(self, parent, background="white")
        self.parent = parent
        self.pack(fill=TkC.BOTH, expand=1)

        self.path = os.path.dirname(os.path.realpath(sys.argv[0]))
        self.initialize()
Пример #16
0
 def __init__(self):
     #Creating main window. And initializing components
     Tk.__init__(self)
     f = Frame(self, width=400, height=200)
     f.pack(expand=True)
     #Blank labels are added to make window alignment  better
     Label(f,text="").grid(row=0)
     #Blank labels are added to make window alignment  better
     Label(f,text="  ").grid(row=1,column=0)
     #Add label fileName
     Label(f,text="File Name").grid(row=1,column=1)
     #Adding text box
     self.textbox1=Entry(f,width=20)
     self.textbox1.grid(row=1,column=2)
     #Adding file Browse button. Set its even handler as openFileBrowser()
     Button(f,text="Choose File",command=self.openFileBrowser).grid(row=1,column=3)
     #Blank labels are added to make window alignment  better
     Label(f,text="  ").grid(row=1,column=4)
     #Blank labels are added to make window alignment  better
     Label(f,text="").grid(row=2)
     #Adding Summarize button. Set its even handler as summarize()
     Button(f,text="Summarize",command=self.summarize).grid(row=3,column=2)
     #Adding frame to window
     f.pack_propagate(0)
     #Set window title
     self.title("Auto Text Summarizer")
     self.mainloop()
Пример #17
0
    def __init__(self, parent):
        Frame.__init__(self, parent, background=Palette.background)
        self.parent = parent
        self.pack(fill=TkC.BOTH, expand=1)

        # init the clock
        clock_font = tkFont.Font(family='Droid Sans', size=52, weight='bold')
        self.clock = Label(self, text="??:??", fg=Palette.primary, bg=Palette.background, font=clock_font)
        self.clock.place(x=0, y=0)

        # init the calendar
        calendar_font = tkFont.Font(family='Droid Sans', size=12)
        self.calendar = Label(self, text="?? ?????, ???", fg=Palette.secondary, bg=Palette.background, font=calendar_font)
        self.calendar.place(x=4, y=70)

        # init the weather
        self.weather = Weather(self, 320, 82)
        self.weather.place(x=0, y=(240 - 82))

        # init the temperature
        temperature_font = tkFont.Font(family='Droid Sans', size=12)
        self.temperature = Label(self, text="?? °C", fg=Palette.secondary, bg=Palette.background, font=temperature_font)
        self.temperature.place(x=240, y=50)

        # print tkFont.families()
        # ('Century Schoolbook L', 'Droid Sans Mono', 'Droid Sans Ethiopic', 'Droid Sans Thai', 'DejaVu Sans Mono', 'URW Palladio L', 'Droid Arabic Naskh', 'URW Gothic L', 'Dingbats', 'URW Chancery L', 'FreeSerif', 'DejaVu Sans', 'Droid Sans Japanese', 'Droid Sans Georgian', 'Nimbus Sans L', 'Droid Serif', 'Droid Sans Hebrew', 'Droid Sans Fallback', 'Standard Symbols L', 'Nimbus Mono L', 'Nimbus Roman No9 L', 'FreeSans', 'DejaVu Serif', 'Droid Sans Armenian', 'FreeMono', 'URW Bookman L', 'Droid Sans')

        # start working
        self.update_clock()
        self.update_temperature()
        self.fetch_weather_thread()
Пример #18
0
    def __init__(self, parent, child):

        Frame.__init__(self, parent)
        self.parent = parent
        # create window
        self.create_window()
        self.create_menu(child)
Пример #19
0
 def __init__(self, parent, width):
     '''
     Constructor
     '''
     Frame.__init__(self, parent)
     self.pack(expand=YES, fill=BOTH)
     self.makeWidgets(width)
Пример #20
0
    def __init__(self, parent):
        Frame.__init__(self,parent, background= "white")

        self.parent = parent
        self.parent.title("Centered Window")
        self.pack(fill=BOTH, expand=1)
        self.centerWindow()
Пример #21
0
 def __init__(self, parent,theta,m,attr):
     Frame.__init__(self, parent)   
     self.theta=theta
     self.m=m
     self.attr=attr
     self.parent = parent        
     self.initUI()
    def __init__(self, master=None, iter=None):
        
        self.master = master
        self.iter = iter

        self.frame_o = Frame(height=50, relief=GROOVE, bd=2)
        self.frame_o.pack(fill=BOTH, expand=1)

        self.but_update_plot = Button(master=self.frame_o,
                                      text='Start Animation',
                                      command=self.iter.start_animation)
        self.but_update_plot.pack(fill=BOTH, expand=1)
        
        self.figure = Figure(figsize=(6, 7), dpi=100)
        
        # a tk.DrawingArea
        self.frame_c = Frame(relief = GROOVE, bd = 2)
        self.frame_c.pack(fill=BOTH, expand=1,)
        self.canvas = FigureCanvasTkAgg(self.figure, master=self.frame_c)
        self.canvas.show()
        self.canvas.get_tk_widget().pack(fill=BOTH, expand=1)

        self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.frame_c)
        self.toolbar.update()
        self.canvas._tkcanvas.pack( fill=BOTH, expand=1)
        self.ini_plot()
Пример #23
0
class Example(Frame):
  
    def __init__(self, parent):
        Frame.__init__(self, parent)   
         
        self.parent = parent        
        self.initUI()
        
        
    def initUI(self):
      
        self.parent.title("Color chooser")      
        self.pack(fill=BOTH, expand=1)
        
        self.btn = Button(self, text="Choose Color", 
            command=self.onChoose)
        self.btn.place(x=30, y=30)
        
        self.frame = Frame(self, border=1, 
            relief=SUNKEN, width=100, height=100)
        self.frame.place(x=160, y=30)


    def onChoose(self):
      
        (rgb, hx) = tkColorChooser.askcolor()
        self.frame.config(bg=hx)
Пример #24
0
 def __init__(self, parent, scrollbar=True, **kw):
     
     self.parent = parent
     
     frame = Frame(parent)
     frame.pack(fill='both', expand=True)
     
     # text widget
     Text.__init__(self, frame, **kw)
     self.pack(side='left', fill='both', expand=True)
     
     # scrollbar
     if scrollbar:
         scrb = Scrollbar(frame, orient='vertical', command=self.yview) 
         self.config(yscrollcommand=scrb.set)
         scrb.pack(side='right', fill='y')
     
     # pop-up menu
     self.popup = Menu(self, tearoff=0)
     self.popup.add_command(label='Cut', command=self._cut)
     self.popup.add_command(label='Copy', command=self._copy)
     self.popup.add_command(label='Paste', command=self._paste)
     self.popup.add_separator()
     self.popup.add_command(label='Select All', command=self._select_all)
     self.popup.add_command(label='Clear All', command=self._clear_all)
     self.bind('<Button-3>', self._show_popup)
Пример #25
0
def show_source_tree(head):
    root = Tk()
    frame = Frame(root)
    frame.pack(fill = 'both')
    tree = ttk.Treeview(frame)
    
    #insert root subroutine
    # @type head Node
    parent_id = tree.insert('', 'end', '', text = head.name)
    for child in head.children:
        child.insert_to_tree(tree, parent_id)



    
    #add scrollbar
    v_scrollbar = Scrollbar(frame, orient = VERTICAL, command = tree.yview)
    h_scrollbar = Scrollbar(frame, orient = HORIZONTAL, command = tree.xview)
    tree.configure(yscrollcommand = v_scrollbar.set, xscrollcommand = h_scrollbar.set)
    
    v_scrollbar.pack(side = 'right', fill = 'y')
    h_scrollbar.pack(side = 'bottom', fill = 'x')


    tree.pack(fill = 'both')
    root.geometry("600x600")
    root.mainloop()
Пример #26
0
    def __init__(self, master, width=0, height=0, family=None, size=None,*args, **kwargs):
        
        Frame.__init__(self, master, width = width, height= height)
        self.pack_propagate(False)

        self._min_width = width
        self._min_height = height

        self._textarea = Text(self, *args, **kwargs)
        self._textarea.pack(expand=True, fill='both')

        if family != None and size != None:
            self._font = tkFont.Font(family=family,size=size)
        else:
            self._font = tkFont.Font(family=self._textarea.cget("font"))

        self._textarea.config(font=self._font)

        # I want to insert a tag just in front of the class tag
        # It's not necesseary to guive to this tag extra priority including it at the beginning
        # For this reason I am making this search
        self._autoresize_text_tag = "autoresize_text_"+str(id(self))
        list_of_bind_tags = list(self._textarea.bindtags())
        list_of_bind_tags.insert(list_of_bind_tags.index('Text'), self._autoresize_text_tag)

        self._textarea.bindtags(tuple(list_of_bind_tags))
        self._textarea.bind_class(self._autoresize_text_tag, "<KeyPress>",self._on_keypress)
Пример #27
0
 def __init__(self,master=None):
     # We begin by calling the base class's constructor first
     Frame.__init__(self,master)
 
     # We now have an empty window!
     
     # This command sets up a grid structure in the window
     self.grid()
     
     # This loop generates rows and columns in the grid
     for i in range(13):
         self.rowconfigure(i,minsize=10)
     for i in range(3):
         self.columnconfigure(i,minsize=30)
     
     # These are methods which appear below the constructor
     self.defineUnits() # this sets up the units I'll be using in the converter
     self.createWidgets() # this places the elements (or widgets) in the grid
     
     # This command "binds" the user's click to a method (varChoice)
     # This method will determine which variable the user wants (Distance, Mass, Time)
     self.inputlist.bind("<Button-1>",self.__varChoice)
 
     # This is a similar command for the selection of unit
     self.unitlist.bind("<Button-1>",self.__unitChoice)
 
     # Finally, this bind reads in whatever value is in the text box when the user hits return
     # and carries out the unit conversion
     
     self.inputfield.bind("<Return>",self.__calcConversion)
Пример #28
0
    def __init__(self, parent, langton_ant):
        Frame.__init__(self, parent)
        self.parent = parent
        self.pack(fill=BOTH, expand=1)

        self.title = self.parent.title()

        self.rows = 101
        self.columns = 82
        self.cell_width = 6
        self.cell_height = 6

        self.canvas = Canvas(self, width=self.cell_width * self.columns, height=self.cell_height * self.rows,
                             borderwidth=0, highlightthickness=0)
        self.canvas.pack(side="top", fill="both", expand="true")

        self.rect = {}
        for column in range(self.columns):
            for row in range(self.rows):
                x1 = column * self.cell_width
                y1 = row * self.cell_height
                x2 = x1 + self.cell_width
                y2 = y1 + self.cell_height
                self.rect[row, column] = self.canvas.create_rectangle(x1, y1, x2, y2, fill="white", tags="rect",
                                                                      outline="black")

        self.langton_ant = langton_ant
        self.draw_result(500)
Пример #29
0
 def __init__(self, parent):
     Frame.__init__(self, parent)
     self.parent = parent
     
     open_button = Button(self, text = 'Calculate', relief = 'raised',
                          command=self._on_calculate, width = 23)
     open_button.pack()
Пример #30
0
 def __init__(self, package_name, base_class, display_base_class=False):
     self.__package_name = package_name
     self.__base_class = base_class
     self.__display_base_class = display_base_class
     self.__window = window = Toplevel()
     window.title('Class Selector')
     self.__selected_class_name = ''
     self.__selected_module_name = ''
     
     self.__tree = tree = ScrolledTree(window)
     tree.pack()
     classes = self.load_modules()
     for package in classes:
         packageNode = tree.insert('', END, text=package)
         for class_name in classes[package]:
             tree.insert(packageNode, END, text=class_name, values=package)
             
     button_frame = Frame(window)
     button_frame.pack()
     def _on_click(module_name, class_name):
         self.__selected_module_name   = module_name
         self.__selected_class_name    = class_name
         window.destroy()
     cancel_button = Button(button_frame, text='Cancel', command=lambda: _on_click('', ''))
     cancel_button.pack(side=RIGHT)
     ok_button     = Button(
         button_frame, 
         text='OK', 
         command=lambda: _on_click(
             tree.item(tree.selection(), 'values')[0],
             tree.item(tree.selection(), 'text')
         )
     )
     ok_button.pack(side=RIGHT)
Пример #31
0
    def init_gui(self):
        """init helper"""
        #setting up frames
        top_frame = Frame(self.root)
        mid_frame = Frame(self.root)
        radio_frame = Frame(self.root)
        res_frame = Frame(self.root)
        msg_frame = Frame(self.root)
        check_frame = Frame(self.root)
        history_frame = Frame(self.root)
        btn_frame = Frame(self.root)
        rating_frame = Frame(self.root)
        top_frame.pack(side=TOP, fill=X)
        mid_frame.pack(side=TOP, fill=X)
        history_frame.pack(side=TOP, fill=BOTH, expand=True)
        radio_frame.pack(side=TOP, fill=BOTH, expand=True)
        rating_frame.pack(side=TOP, fill=BOTH, expand=True)
        res_frame.pack(side=TOP, fill=BOTH, expand=True)
        check_frame.pack(side=TOP, fill=BOTH, expand=True)
        msg_frame.pack(side=TOP, fill=BOTH, expand=True)
        btn_frame.pack(side=TOP, fill=X)

        #Message ListBox
        rightscrollbar = Scrollbar(msg_frame)
        rightscrollbar.pack(side=RIGHT, fill=Y)
        bottomscrollbar = Scrollbar(msg_frame, orient=HORIZONTAL)
        bottomscrollbar.pack(side=BOTTOM, fill=X)
        self.lbMessages = Listbox(msg_frame,
                                  yscrollcommand=rightscrollbar.set,
                                  xscrollcommand=bottomscrollbar.set,
                                  bg="white")
        self.lbMessages.pack(expand=True, fill=BOTH)
        rightscrollbar.config(command=self.lbMessages.yview)
        bottomscrollbar.config(command=self.lbMessages.xview)

        #History ListBoxes
        rightscrollbar2 = Scrollbar(history_frame)
        rightscrollbar2.pack(side=RIGHT, fill=Y)
        bottomscrollbar2 = Scrollbar(history_frame, orient=HORIZONTAL)
        bottomscrollbar2.pack(side=BOTTOM, fill=X)
        self.showhistory = Listbox(history_frame,
                                   yscrollcommand=rightscrollbar2.set,
                                   xscrollcommand=bottomscrollbar2.set,
                                   bg="white")
        self.showhistory.pack(expand=True, fill=BOTH)
        rightscrollbar2.config(command=self.showhistory.yview)
        bottomscrollbar2.config(command=self.showhistory.xview)
        self.showhistory.bind('<Double-Button-1>', self.select_recent_file)
        self.set_history_window()

        #status bar
        self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W)
        self.status.pack(side=BOTTOM, fill=X)

        #labels
        self.lblRatingLabel = Label(rating_frame, text='Rating:')
        self.lblRatingLabel.pack(side=LEFT)
        self.lblRating = Label(rating_frame, textvariable=self.rating)
        self.lblRating.pack(side=LEFT)
        Label(mid_frame, text='Recently Used:').pack(side=LEFT)
        Label(top_frame, text='Module or package').pack(side=LEFT)

        #file textbox
        self.txtModule = Entry(top_frame, background='white')
        self.txtModule.bind('<Return>', self.run_lint)
        self.txtModule.pack(side=LEFT, expand=True, fill=X)

        #results box
        rightscrollbar = Scrollbar(res_frame)
        rightscrollbar.pack(side=RIGHT, fill=Y)
        bottomscrollbar = Scrollbar(res_frame, orient=HORIZONTAL)
        bottomscrollbar.pack(side=BOTTOM, fill=X)
        self.results = Listbox(res_frame,
                               yscrollcommand=rightscrollbar.set,
                               xscrollcommand=bottomscrollbar.set,
                               bg="white",
                               font="Courier")
        self.results.pack(expand=True, fill=BOTH, side=BOTTOM)
        rightscrollbar.config(command=self.results.yview)
        bottomscrollbar.config(command=self.results.xview)

        #buttons
        Button(top_frame, text='Open', command=self.file_open).pack(side=LEFT)
        Button(top_frame,
               text='Open Package',
               command=(lambda: self.file_open(package=True))).pack(side=LEFT)

        self.btnRun = Button(top_frame, text='Run', command=self.run_lint)
        self.btnRun.pack(side=LEFT)
        Button(btn_frame, text='Quit', command=self.quit).pack(side=BOTTOM)

        #radio buttons
        self.information_box = IntVar()
        self.convention_box = IntVar()
        self.refactor_box = IntVar()
        self.warning_box = IntVar()
        self.error_box = IntVar()
        self.fatal_box = IntVar()
        i = Checkbutton(check_frame,
                        text="Information",
                        fg=COLORS['(I)'],
                        variable=self.information_box,
                        command=self.refresh_msg_window)
        c = Checkbutton(check_frame,
                        text="Convention",
                        fg=COLORS['(C)'],
                        variable=self.convention_box,
                        command=self.refresh_msg_window)
        r = Checkbutton(check_frame,
                        text="Refactor",
                        fg=COLORS['(R)'],
                        variable=self.refactor_box,
                        command=self.refresh_msg_window)
        w = Checkbutton(check_frame,
                        text="Warning",
                        fg=COLORS['(W)'],
                        variable=self.warning_box,
                        command=self.refresh_msg_window)
        e = Checkbutton(check_frame,
                        text="Error",
                        fg=COLORS['(E)'],
                        variable=self.error_box,
                        command=self.refresh_msg_window)
        f = Checkbutton(check_frame,
                        text="Fatal",
                        fg=COLORS['(F)'],
                        variable=self.fatal_box,
                        command=self.refresh_msg_window)
        i.select()
        c.select()
        r.select()
        w.select()
        e.select()
        f.select()
        i.pack(side=LEFT)
        c.pack(side=LEFT)
        r.pack(side=LEFT)
        w.pack(side=LEFT)
        e.pack(side=LEFT)
        f.pack(side=LEFT)

        #check boxes
        self.box = StringVar()
        # XXX should be generated
        report = Radiobutton(radio_frame,
                             text="Report",
                             variable=self.box,
                             value="Report",
                             command=self.refresh_results_window)
        rawMet = Radiobutton(radio_frame,
                             text="Raw metrics",
                             variable=self.box,
                             value="Raw metrics",
                             command=self.refresh_results_window)
        dup = Radiobutton(radio_frame,
                          text="Duplication",
                          variable=self.box,
                          value="Duplication",
                          command=self.refresh_results_window)
        ext = Radiobutton(radio_frame,
                          text="External dependencies",
                          variable=self.box,
                          value="External dependencies",
                          command=self.refresh_results_window)
        stat = Radiobutton(radio_frame,
                           text="Statistics by type",
                           variable=self.box,
                           value="Statistics by type",
                           command=self.refresh_results_window)
        msgCat = Radiobutton(radio_frame,
                             text="Messages by category",
                             variable=self.box,
                             value="Messages by category",
                             command=self.refresh_results_window)
        msg = Radiobutton(radio_frame,
                          text="Messages",
                          variable=self.box,
                          value="Messages",
                          command=self.refresh_results_window)
        report.select()
        report.grid(column=0, row=0, sticky=W)
        rawMet.grid(column=1, row=0, sticky=W)
        dup.grid(column=2, row=0, sticky=W)
        msg.grid(column=3, row=0, sticky=E)
        stat.grid(column=0, row=1, sticky=W)
        msgCat.grid(column=1, row=1, sticky=W)
        ext.grid(column=2, row=1, columnspan=2, sticky=W)

        #dictionary for check boxes and associated error term
        self.msg_type_dict = {
            'I': lambda: self.information_box.get() == 1,
            'C': lambda: self.convention_box.get() == 1,
            'R': lambda: self.refactor_box.get() == 1,
            'E': lambda: self.error_box.get() == 1,
            'W': lambda: self.warning_box.get() == 1,
            'F': lambda: self.fatal_box.get() == 1
        }
        self.txtModule.focus_set()
Пример #32
0
 def showAll(self):
     Ventana2 = Toplevel(self.master)
     try:
         Poss = [0, 50]
         maxi = self.buscMax()
         if int(maxi) < Poss[1]:
             Poss[1] = int(maxi)
         Ventana2.configure(height=45, width=25, bg="#4a4a4a")
         Ventana2.resizable(0, 0)
         frameAux = Frame(Ventana2, bg="#4a4a4a", borderwidth=0)
         frameAux.pack(fill=BOTH)
         scrolly = Scrollbar(frameAux, orient=VERTICAL)
         self.listbox1 = Listbox(frameAux,
                                 width=90,
                                 background="#4a4a4a",
                                 borderwidth=0,
                                 fg="#FFFFFF",
                                 highlightcolor="#4d86a1",
                                 highlightbackground="#4d86a1",
                                 yscrollcommand=scrolly.set)
         self.listbox1.config(font=("", 11))
         self.listbox1.pack(side=LEFT)
         scrolly.pack(side=RIGHT, fill=Y)
         scrolly.configure(command=self.yview)
         self.load50(Poss)
         if sys.platform.startswith('win32'):
             ruta = "image\\GoBack.png"
             ruta2 = "image\\GoOn.png"
         elif sys.platform.startswith('linux') or sys.platform.startswith(
                 'darwin'):
             ruta = "image/GoBack.png"
             ruta2 = "image/GoOn.png"
         load = Image.open(ruta)
         render = ImageTk.PhotoImage(load)
         load2 = Image.open(ruta2)
         render2 = ImageTk.PhotoImage(load2)
         backbutton1 = Button(Ventana2,
                              image=render,
                              bg="#4a4a4a",
                              borderwidth=0,
                              activebackground="#4d86a1",
                              highlightcolor="#4d86a1",
                              highlightbackground="#4a4a4a",
                              command=lambda: self.load50(Poss, "-"))
         backbutton1.image = render
         backbutton1.pack(side=LEFT)
         backbutton2 = Button(Ventana2,
                              image=render2,
                              bg="#4a4a4a",
                              borderwidth=0,
                              activebackground="#4d86a1",
                              highlightcolor="#4d86a1",
                              highlightbackground="#4a4a4a",
                              command=lambda: self.load50(Poss, "+"))
         backbutton2.image = render2
         backbutton2.pack(side=LEFT)
         backbutton3 = Button(
             Ventana2,
             height=2,
             width=10,
             text="Back",
             command=lambda: self.Switch(self.master, Ventana2))
         backbutton3.pack(side=RIGHT)
     except Exception as e:
         print(e)
         Ventana2.destroy()
         self.Error("Se produjo un error al cargar")
Пример #33
0
    def __init__(self, parent, graphics):
        Frame.__init__(self)
        self.parent = parent
        self.graphics = graphics
        self.items = []
        self.config(bg=self.graphics.mainColor)
        self.font = tkFont.Font(family="Courier", size=12)

        #self.font = ('system', 10)
        Style().configure('green/black.TButton',
                          foreground='black',
                          background='black')
        Style().configure('white.TLabel',
                          foreground='black',
                          background='white')
        Style().configure("Red.TLabel", foreground="red")
        Style().configure("MyStyle.Vertical.TSeparator", background="black")

        self.frame = Frame(self, bg=self.graphics.mainColor)
        self.frame.grid(row=1, column=1)

        # Add the location to the list button
        self.adminLoginButton = Button(self.frame,
                                       text="Admin",
                                       bg=self.graphics.grey,
                                       fg="white",
                                       width=self.graphics.btnWidth2,
                                       command=lambda: self.adminLogin())
        self.adminLoginButton.grid(row=0, column=3, sticky='e')

        # Enter item ID
        itemIDLabel = Label(self.frame,
                            text="Enter Item ID",
                            bg=self.graphics.mainColor)
        itemIDLabel.grid(row=1, column=3, pady=10, sticky='s')
        self.itemIDField = Entry(self.frame, width=20)
        self.itemIDField.grid(row=2, column=3, sticky='n')
        self.itemIDField.bind("<Return>",
                              (lambda event: self.add(self.itemIDField.get())))

        self.outputLabel = Label(self.frame,
                                 text=" ",
                                 bg=self.graphics.mainColor)
        self.outputLabel.grid(row=3, column=3, sticky='n')
        self.outputLabel.config(fg="red")

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Add",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.add(self.itemIDField.get()))
        setLocB.grid(row=4, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Manual",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.manual(self.itemIDField))
        setLocB.grid(row=5, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Complete",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.complete(self.itemIDField))
        setLocB.grid(row=6, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Cancel",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.cancel(self.itemIDField))
        setLocB.grid(row=7, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Save",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.save())
        setLocB.grid(row=12, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Load",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.load())
        setLocB.grid(row=13, column=3)

        l = Label(self.frame, text="             ", bg=self.graphics.mainColor)
        l.grid(row=0, column=2, rowspan=8)

        sep = Separator(self.frame,
                        orient=VERTICAL,
                        style="MyStyle.Vertical.TSeparator")
        sep.grid(row=0, column=1, rowspan=20, sticky="ns", padx=3)

        # Make and fill listbox
        self.itemsListBox = Listbox(self.frame, height=24, font=self.font)
        self.itemsListBox.config(width=29)
        self.itemsListBox.grid(row=0, column=0, rowspan=20, pady=6, padx=8)
        self.itemsListBox.bind(
            "<BackSpace>",
            (lambda event: self.remove(self.itemsListBox.curselection())))

        # Change location to the one selected
        removeLocB = Button(
            self.frame,
            text="Remove Item",
            width=self.graphics.btnWidth1,
            height=self.graphics.btnHeight1,
            font=("Helvetica", self.graphics.btnFontHeight1),
            command=lambda: self.remove(self.itemsListBox.curselection()))
        removeLocB.grid(row=18, column=3, pady=5, padx=5)

        self.grid_columnconfigure(0, weight=1)
        self.grid_columnconfigure(2, weight=1)
        self.grid_rowconfigure(0, weight=1)
        self.grid_rowconfigure(2, weight=1)
Пример #34
0
class ManageUsersWindow(Frame):
    def __init__(self, parent, graphics):
        Frame.__init__(self)
        self.parent = parent
        self.graphics = graphics
        self.items = []
        self.config(bg=self.graphics.mainColor)
        self.font = tkFont.Font(family="Courier", size=12)

        #self.font = ('system', 10)
        Style().configure('green/black.TButton',
                          foreground='black',
                          background='black')
        Style().configure('white.TLabel',
                          foreground='black',
                          background='white')
        Style().configure("Red.TLabel", foreground="red")
        Style().configure("MyStyle.Vertical.TSeparator", background="black")

        self.frame = Frame(self, bg=self.graphics.mainColor)
        self.frame.grid(row=1, column=1)

        # Add the location to the list button
        self.adminLoginButton = Button(self.frame,
                                       text="Admin",
                                       bg=self.graphics.grey,
                                       fg="white",
                                       width=self.graphics.btnWidth2,
                                       command=lambda: self.adminLogin())
        self.adminLoginButton.grid(row=0, column=3, sticky='e')

        # Enter item ID
        itemIDLabel = Label(self.frame,
                            text="Enter Item ID",
                            bg=self.graphics.mainColor)
        itemIDLabel.grid(row=1, column=3, pady=10, sticky='s')
        self.itemIDField = Entry(self.frame, width=20)
        self.itemIDField.grid(row=2, column=3, sticky='n')
        self.itemIDField.bind("<Return>",
                              (lambda event: self.add(self.itemIDField.get())))

        self.outputLabel = Label(self.frame,
                                 text=" ",
                                 bg=self.graphics.mainColor)
        self.outputLabel.grid(row=3, column=3, sticky='n')
        self.outputLabel.config(fg="red")

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Add",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.add(self.itemIDField.get()))
        setLocB.grid(row=4, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Manual",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.manual(self.itemIDField))
        setLocB.grid(row=5, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Complete",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.complete(self.itemIDField))
        setLocB.grid(row=6, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Cancel",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.cancel(self.itemIDField))
        setLocB.grid(row=7, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Save",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.save())
        setLocB.grid(row=12, column=3)

        # Add the location to the list button
        setLocB = Button(self.frame,
                         text="Load",
                         width=self.graphics.btnWidth1,
                         height=self.graphics.btnHeight1,
                         font=("Helvetica", self.graphics.btnFontHeight1),
                         command=lambda: self.load())
        setLocB.grid(row=13, column=3)

        l = Label(self.frame, text="             ", bg=self.graphics.mainColor)
        l.grid(row=0, column=2, rowspan=8)

        sep = Separator(self.frame,
                        orient=VERTICAL,
                        style="MyStyle.Vertical.TSeparator")
        sep.grid(row=0, column=1, rowspan=20, sticky="ns", padx=3)

        # Make and fill listbox
        self.itemsListBox = Listbox(self.frame, height=24, font=self.font)
        self.itemsListBox.config(width=29)
        self.itemsListBox.grid(row=0, column=0, rowspan=20, pady=6, padx=8)
        self.itemsListBox.bind(
            "<BackSpace>",
            (lambda event: self.remove(self.itemsListBox.curselection())))

        # Change location to the one selected
        removeLocB = Button(
            self.frame,
            text="Remove Item",
            width=self.graphics.btnWidth1,
            height=self.graphics.btnHeight1,
            font=("Helvetica", self.graphics.btnFontHeight1),
            command=lambda: self.remove(self.itemsListBox.curselection()))
        removeLocB.grid(row=18, column=3, pady=5, padx=5)

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

    def add(self, itemID):
        self.outputLabel.config(text=" ")
        if itemID != "":
            item = self.graphics.POS.queryDBForItem(itemID)
            if item != None:
                self.graphics.POS.addItemToTransaction(item)
                self.itemsListBox.insert(END, self.textFormatter(item, 24))
            else:
                self.outputLabel.config(text="Item Doesn't Exist")
        else:
            self.outputLabel.config(text="Nothing entered")
        self.itemIDField.delete(0, 'end')

    def remove(self, selection):
        self.outputLabel.config(text=" ")
        try:
            print "removing " + str(int(selection[0]))
            self.itemsListBox.delete(int(selection[0]))
        except:
            self.outputLabel.config(text="Nothing Selected")

    def manual(self, itemID):
        if self.graphics.POS.getCurrEmployee().getEmpType() == "Manager":
            self.outputLabel.config(text=" ")
            print "adding manually"

            color = self.graphics.mainColor

            # Create progress bar pop-up window
            self.adminWindow = Toplevel(self)
            self.adminWindow.configure(bg=color)
            self.adminWindow.geometry("270x165+550+150")

            #Title Label
            titleLabel = Label(self.adminWindow,
                               text="Enter Item Information",
                               bg=color)
            titleLabel.grid(row=0,
                            column=0,
                            columnspan=2,
                            sticky='ns',
                            padx=6,
                            pady=5)

            #Manual Enter Output
            self.manualEntryOutput = Label(self.adminWindow,
                                           text="",
                                           fg='red',
                                           bg=color)
            self.manualEntryOutput.grid(row=1,
                                        column=0,
                                        columnspan=2,
                                        sticky='ns',
                                        padx=6)

            #Item Name Label
            itemNameLabel = Label(self.adminWindow, text="Item Name", bg=color)
            itemNameLabel.grid(row=2, column=0, sticky='w', padx=6)

            #Item Name Field
            itemNameField = Entry(self.adminWindow, width=15)
            itemNameField.grid(row=2, column=1, sticky='e', padx=6)
            itemNameField.bind("<Return>", (lambda event: self.manualAdd(
                itemNameField, itemPriceField, itemSaleField)))

            #Item Price Label
            itemPriceLabel = Label(self.adminWindow,
                                   text="Item Price",
                                   bg=color)
            itemPriceLabel.grid(row=3, column=0, sticky='w', padx=6)

            #Item Price Field
            itemPriceField = Entry(self.adminWindow, width=15)
            itemPriceField.grid(row=3, column=1, sticky='e', padx=6)
            itemPriceField.bind("<Return>", (lambda event: self.manualAdd(
                itemNameField, itemPriceField, itemSaleField)))

            #Item Sale Label
            itemSaleLabel = Label(self.adminWindow,
                                  text="Percent Sale",
                                  bg=color)
            itemSaleLabel.grid(row=4, column=0, sticky='w', padx=6)

            #Item Sale Field
            itemSaleField = Entry(self.adminWindow, width=15)
            itemSaleField.grid(row=4, column=1, sticky='e', padx=6)
            itemSaleField.bind("<Return>", (lambda event: self.manualAdd(
                itemNameField, itemPriceField, itemSaleField)))

            #Add the Item
            itemAddButton = Button(
                self.adminWindow,
                text="Add Item",
                width=10,
                command=lambda: self.manualAdd(itemNameField, itemPriceField,
                                               itemSaleField))
            itemAddButton.grid(row=5, column=0, sticky='e', padx=5)

            #Cancel Adding the Item
            cancelButton = Button(self.adminWindow,
                                  text="Cancel",
                                  width=10,
                                  command=lambda: self.adminWindow.destroy())
            cancelButton.grid(row=5, column=1, pady=5, padx=5)
        else:
            self.outputLabel.config(text="Requires Manager")

    def manualAdd(self, name, price, sale):
        if name.get() == "" or price.get() == "":
            self.manualEntryOutput.config(text="incomplete information")
        else:
            if sale.get() == "":
                item = Item.Item(-1, name.get(), float(price.get()), 0)
            else:
                item = Item.Item(-1, name.get(), float(price.get()),
                                 float(sale.get()) / 100.00)
            self.graphics.POS.addItemToTransaction(item)
            self.itemsListBox.insert(END, self.textFormatter(item, 24))
            self.adminWindow.destroy()

    def complete(self, itemID):
        #		self.outputLabel.config(text=" ")
        #		self.itemIDField.delete(0, 'end')
        #		self.itemsListBox.delete(0, END)
        #		print "completing transaction"#

        #		#color = "#D1D1D1"
        #		color = "#e8e8e8"
        #		width=35#

        #		# Create progress bar pop-up window
        #		receiptWindow = Toplevel(self)
        #		receiptWindow.configure(bg=color)
        #		receiptWindow.geometry(str(int(7.35*width))+"x"+str(int(13.05*(len(self.graphics.POS.getTransactionReceipt().split('\n'))+5)))+"+150+50")#

        #		# Text Field Object, used in the submission function
        #		receiptText = Label(receiptWindow, text=self.graphics.POS.getTransactionReceipt(), style='white.TLabel',font=self.font)#self.graphics.POS.getTransactionReceipt()
        #		receiptText.pack(side="top")
        #		self.itemIDField.delete(0, 'end')
        #		self.graphics.liftLayer("main")
        self.itemIDField.delete(0, 'end')
        self.itemsListBox.delete(0, END)
        self.graphics.liftLayer("Rpayment")

    def cancel(self, itemID):
        self.outputLabel.config(text=" ")
        print "cancelling transaction"
        self.itemIDField.delete(0, 'end')
        self.graphics.liftLayer("main")

    def textFormatter(self, item, width):
        name = item.getName()
        price = item.getSalePrice()
        disc = item.getSaleValue()
        line = ""
        if disc != 0:
            length = len(name) + len("(" + str(int(disc * 100)) +
                                     "% off)") + len(
                                         "$" + str("{0:.2f}".format(price)))
        else:
            length = len(name) + len("$" + str("{0:.2f}".format(price)))

        if length + 2 <= width:
            overage = width - length
            if overage % 2 != 0:
                overage -= 1
                spacing = int(overage / 2)
                sp1 = spacing
                sp2 = spacing + 1
            else:
                spacing = int(overage / 2)
                sp1 = spacing
                sp2 = spacing
            if disc != 0:
                line = name + (sp1 * " ") + "(" + str(int(
                    disc * 100)) + "% off)" + (sp2 * " ") + "$" + str(
                        "{0:.2f}".format(price))
            else:
                line = name + (sp1 * " ") + (sp2 * " ") + "$" + str(
                    "{0:.2f}".format(price))
        else:
            overage = length + 2 - width
            name = name[:len(name) - overage]
            if disc != 0:
                line = name + " " + "(" + str(int(
                    disc * 100)) + "% off)" + " " + "$" + str(
                        "{0:.2f}".format(price))
            else:
                line = name + " " + " " + "$" + str("{0:.2f}".format(price))

        return line + "/day"

    def adminLogin(self):
        print "admin login"

        color = "#e8e8e8"

        # Create progress bar pop-up window
        self.adminWindow = Toplevel(self)
        self.adminWindow.configure(bg=color)
        self.adminWindow.geometry("480x220+550+150")

        #buffers
        buff = Label(self.adminWindow,
                     text="               ")  #,bg=self.color,padx=5)
        buff.grid(row=1, column=0, sticky='w')

        buff2 = Label(self.adminWindow,
                      text="               ")  #,bg=self.color,padx=5)
        buff2.grid(row=2, column=1, sticky='n')

        # Enter Username
        usernameLabel = Label(self.adminWindow,
                              text="username")  #, bg=self.color,padx=5)
        #usernameLabel = Label(self, text="username", bg=self.color,padx=5)
        usernameLabel.grid(row=3, column=1, sticky='s')
        usernameField = Entry(self.adminWindow, width=40)  #bd =0, width=40)
        #usernameField = Entry(self, width=40,bd =1)
        usernameField.grid(row=4, column=1, sticky='n')
        usernameField.bind(
            "<Return>",
            (lambda event: self.login(usernameField, passwordField)))

        # Enter Password
        passwordLabel = Label(self.adminWindow,
                              text="password")  #, bg=self.color,padx=5)
        #passwordLabel = Label(self, text="password", bg=self.color,padx=5)
        passwordLabel.grid(row=5, column=1, sticky='s')
        passwordField = Entry(self.adminWindow, show="*",
                              width=40)  #bd =0, width=40)
        #passwordField = Entry(self, show="*", width=40,bd =1)
        passwordField.grid(row=6, column=1, sticky='n')
        passwordField.bind(
            "<Return>",
            (lambda event: self.login(usernameField, passwordField)))

        #output
        self.adminOutputLabel = Label(
            self.adminWindow, text="",
            style="Red.TLabel")  #,bg=self.color,padx=5)
        self.adminOutputLabel.grid(row=7, column=1, sticky='s')

        # Attempt to login
        loginButton = Button(
            self.adminWindow,
            text="Enter",
            width=15,
            style='green/black.TButton',
            command=lambda: self.login(usernameField, passwordField))
        #loginButton = Button(self, text="Enter", width=15, command=lambda: self.login(usernameField, passwordField))
        loginButton.grid(row=8, column=1, pady=10)

    def login(self, username, password, event=None):
        self.graphics.POS.logOut()
        if self.graphics.POS.login(username.get(), password.get()) == True:
            print "logged in!"
            self.adminWindow.destroy()
        else:
            if self.graphics.POS.login(username.get(), password.get()) != None:
                self.adminOutputLabel.config(text="Incorrect Login")
Пример #35
0
    def __init__(self, ncffile, options):
        try:
            from Tkinter import Checkbutton, Frame, Label, Scrollbar, Listbox, Button, IntVar, Tk, VERTICAL, EXTENDED, END, N, S, SINGLE, Entry, StringVar, Text, DISABLED, PhotoImage, LEFT, E, W
        except:
            try:
                from tkinter import Checkbutton, Frame, Label, Scrollbar, Listbox, Button, IntVar, Tk, VERTICAL, EXTENDED, END, N, S, SINGLE, Entry, StringVar, Text, DISABLED, PhotoImage, LEFT, E, W
            except:
                warn('tkinter unavailable')

        master = self.root = Tk()
        self.ncffile = ncffile
        self.options = options
        self.plotted_variables = set()
        frame = Frame(master)
        frame.grid(row=0)
        codeframe = Frame(master)
        codeframe.grid(row=1)
        metaframe = Frame(master)
        metaframe.grid(row=2)
        goframe = Frame(frame)
        goframe.grid(column=3, row=1)

        var_label = Label(frame, text='Select Variable')
        var_label.grid(column=0, row=0)
        var_scrollbar = Scrollbar(frame, orient=VERTICAL)
        var_scrollbar.grid(column=1, row=1, sticky=N + S)
        self.var = Listbox(frame,
                           selectmode=EXTENDED,
                           exportselection=0,
                           yscrollcommand=var_scrollbar.set)
        self.var.grid(column=0, row=1)
        var_scrollbar.config(command=self.var.yview)

        what_to_do = Label(frame, text='Execute')
        what_to_do.grid(column=2, row=0)
        self.method_list = Listbox(frame, selectmode=SINGLE, exportselection=0)
        self.method_list.grid(column=2, row=1)
        self.pre_txt = StringVar()
        pre_label = Label(codeframe, text='Before any figures, execute code')
        self.pre_txt.set(_pre_code)
        pre_label.grid(row=2, sticky='W')
        self.pre = Entry(codeframe, width=120, textvariable=self.pre_txt)
        self.pre.grid(row=3, sticky='E')

        self.before_txt = StringVar()
        self.before_txt.set(_before_code)
        before_label = Label(codeframe,
                             text='Before each figure, execute code')
        before_label.grid(row=4, sticky='W')
        self.before = Entry(codeframe, width=120, textvariable=self.before_txt)
        self.before.grid(row=5, sticky='E')

        self.after_txt = StringVar()
        self.after_txt.set(_after_code)
        after_label = Label(codeframe, text='After each figure, execute code')
        after_label.grid(row=6, sticky='W')
        self.after = Entry(codeframe, width=120, textvariable=self.after_txt)
        self.after.grid(row=7, sticky='E')

        self.post_txt = StringVar()
        self.post_txt.set(_post_code)
        post_label = Label(codeframe, text='After all figures, execute code')
        post_label.grid(row=8, sticky='W')
        self.post = Entry(codeframe, width=120, textvariable=self.post_txt)
        self.post.grid(row=9, sticky='E')

        options_label = Label(goframe, text='Options:')
        options_label.grid(column=0, row=1, sticky='W')
        self.logscale = IntVar()
        self.logscale.set(0)
        c = Checkbutton(goframe, text="log-scale?", variable=self.logscale)
        c.grid(column=0, row=2, sticky='W')

        self.coastlines = IntVar()
        self.coastlines.set(_coastlines_opt)
        coastlines = Checkbutton(goframe,
                                 text="coastlines?",
                                 variable=self.coastlines,
                                 justify=LEFT)
        coastlines.grid(column=0, row=3, sticky='W')

        self.countries = IntVar()
        self.countries.set(_countries_opt)
        countries = Checkbutton(goframe,
                                text="countries?",
                                variable=self.countries,
                                justify=LEFT)
        countries.grid(column=0, row=4, sticky='W')

        self.states = IntVar()
        self.states.set(_states_opt)
        states = Checkbutton(goframe,
                             text="states?",
                             variable=self.states,
                             justify=LEFT)
        states.grid(column=0, row=5, sticky='W')

        self.counties = IntVar()
        self.counties.set(_counties_opt)
        counties = Checkbutton(goframe,
                               text="counties?",
                               variable=self.counties,
                               justify=LEFT)
        counties.grid(column=0, row=6, sticky='W')

        self.execute_button = Button(goframe,
                                     text="Make Figure",
                                     command=self.execute)
        self.execute_button.grid(row=0, column=0, sticky='W')

        self.methods = [
            'mapplot', 'presslat', 'presslon', 'time-lat', 'profile',
            'timeseries', 'pressx', 'tileplot', 'plot'
        ]
        method_labels = [
            'lat-lon', 'press-lat', 'press-lon', 'time-lat',
            'Vertical Profile', 'Time Series', 'press-? (2-D)',
            'Tile Plot (2-D)', 'Plot (1-D)'
        ]
        for method in method_labels:
            self.method_list.insert(END, method)

        var_keys = [
            k for k, v in self.ncffile.variables.items()
            if k not in ('time', 'latitude', 'longitude', 'latitude_bounds',
                         'longitude_bounds', 'time_bounds', 'tau0', 'tau1',
                         'TFLAG')
        ]
        var_keys.sort()
        self.vars = []
        for spc in var_keys:
            self.var.insert(END, spc)
            self.vars.append(spc)

        meta_label = Label(metaframe, text='Common Data Language Header:')
        meta_label.grid(column=0, row=0, sticky='W')
        meta_scrollbar = Scrollbar(metaframe, orient=VERTICAL)
        meta_scrollbar.grid(column=1, row=1, sticky=N + S)
        self.meta = Text(metaframe,
                         height=10,
                         width=118,
                         bg='white',
                         relief='flat',
                         yscrollcommand=meta_scrollbar.set)
        self.meta.grid(column=0, row=1, sticky='W')
        from PseudoNetCDF.pncdump import pncdump
        try:
            from StringIO import StringIO
        except ImportError:
            from io import StringIO
        pdump = StringIO("")
        try:
            name = ', '.join(options.ifile)
        except:
            name = 'ifile'
        pncdump(
            self.ncffile,
            header=True,
            outfile=pdump,
        )
        pdump.seek(0, 0)
        self.meta.insert(END, pdump.read())
        self.meta.config(state=DISABLED)
        help = Button(goframe, text='Help', command=self.help)
        help.grid(column=0, row=7)
        quit = Button(goframe, text='Quit', command=self.quit)
        quit.grid(column=0, row=8)
        master.mainloop()
Пример #36
0
    def __init__(self, cfg, doit):
        """ create the GUI panel widgets
            cfg -- parameter values (input and output)
            doit -- method to call to run simulations
            """

        # gather the basic parameters
        self.cfg = cfg
        self.doit = doit

        self.root = Tk()
        self.root.title('Data Reliability Model')
        t = Frame(self.root, bd=2 * self.BORDER)
        # w.iconbitmap(default='inktank.ico')   # ? windows only ?

        # left stack (DISK)
        f = Frame(t, bd=self.BORDER, relief=RIDGE)
        r = 1
        Label(f, text="Disk Type").grid(row=r)
        self.disk_type = StringVar(f)
        self.disk_type.set(self.diskTypes[0])
        OptionMenu(f, self.disk_type, *self.diskTypes,
                   command=self.diskchoice).grid(row=r + 1)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Size (GiB)").grid(row=r)
        self.disk_size = Entry(f, width=self.long_wid)
        self.disk_size.delete(0, END)
        self.disk_size.insert(0, self.long_fmt % (cfg.disk_size / GiB))
        self.disk_size.grid(row=r + 1)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Primary FITs").grid(row=r)
        self.disk_fit = Entry(f, width=self.long_wid)
        self.disk_fit.grid(row=r + 1)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Secondary FITs").grid(row=r)
        self.disk_fit2 = Entry(f, width=self.long_wid)
        self.disk_fit2.grid(row=r + 1)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="NRE rate").grid(row=r)
        self.disk_nre = Spinbox(f, width=self.long_wid, values=self.nre_rates)
        self.disk_nre.grid(row=r + 1)
        Label(f).grid(row=r + 2)
        r += 3
        while r < self.ROWS:
            Label(f).grid(row=r)
            r += 1
        Button(f, text="RELIABILITY", command=self.do_disk).grid(row=r)
        f.grid(column=1, row=1)
        self.diskchoice(self.diskTypes[0])  # set default disk type

        # second stack (RAID)
        f = Frame(t, bd=self.BORDER, relief=RIDGE)
        r = 1
        Label(f, text="RAID Type").grid(row=r)
        self.raid_type = StringVar(f)
        self.raid_type.set("RAID-1")
        OptionMenu(f, self.raid_type, *self.raidTypes,
                   command=self.raidchoice).grid(row=r + 1)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Replace (hours)").grid(row=r)
        self.raid_rplc = Spinbox(f,
                                 width=self.short_wid,
                                 values=self.replace_times)
        self.raid_rplc.grid(row=r + 1)
        self.raid_rplc.delete(0, END)
        self.raid_rplc.insert(0, "%d" % cfg.raid_replace)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Rebuild (MiB/s)").grid(row=r)
        self.raid_speed = Spinbox(f,
                                  width=self.med_wid,
                                  values=self.rebuild_speeds)
        self.raid_speed.grid(row=r + 1)
        self.raid_speed.delete(0, END)
        self.raid_speed.insert(0, "%d" % (cfg.raid_recover / MiB))
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Volumes").grid(row=r)
        self.raid_vols = Spinbox(f, from_=1, to=10, width=self.short_wid)
        self.raid_vols.grid(row=r + 1)
        Label(f).grid(row=r + 2)
        self.raidchoice("RAID-1")  # set default number of volumes
        r += 3
        while r < self.ROWS:
            Label(f).grid(row=r)
            r += 1
        Button(f, text="RELIABILITY", command=self.do_raid).grid(row=r)
        f.grid(column=2, row=1)

        # third stack (RADOS)
        f = Frame(t, bd=self.BORDER, relief=RIDGE)
        r = 1
        Label(f, text="RADOS copies").grid(row=r)
        self.rados_cpys = Spinbox(f,
                                  values=(1, 2, 3, 4, 5, 6),
                                  width=self.short_wid)
        self.rados_cpys.grid(row=r + 1)
        self.rados_cpys.delete(0, END)
        self.rados_cpys.insert(0, "%d" % cfg.rados_copies)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Mark-out (min)").grid(row=r)
        self.rados_down = Spinbox(f,
                                  values=self.markout_times,
                                  width=self.short_wid)
        self.rados_down.grid(row=r + 1)
        self.rados_down.delete(0, END)
        self.rados_down.insert(0, "%d" % (cfg.rados_markout * 60))
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Recovery (MiB/s)").grid(row=r)
        self.rados_speed = Spinbox(f,
                                   width=self.med_wid,
                                   values=self.rebuild_speeds)
        self.rados_speed.grid(row=r + 1)
        self.rados_speed.delete(0, END)
        self.rados_speed.insert(0, "%d" % (cfg.rados_recover / MiB))
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Space Usage (%)").grid(row=r)
        self.rados_fullness = Spinbox(f,
                                      values=self.fullness,
                                      width=self.med_wid)
        self.rados_fullness.grid(row=r + 1)
        self.rados_fullness.delete(0, END)
        self.rados_fullness.insert(0, "%d" % (cfg.rados_fullness * 100))
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Declustering (pg)").grid(row=r)
        self.rados_pgs = Entry(f, width=self.med_wid)
        self.rados_pgs.delete(0, END)
        self.rados_pgs.insert(0, self.med_fmt % cfg.rados_decluster)
        self.rados_pgs.grid(row=r + 1)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Stripe Length").grid(row=r)
        self.stripe_length = Entry(f, width=self.med_wid)
        self.stripe_length.delete(0, END)
        self.stripe_length.insert(0, self.med_fmt % cfg.stripe_length)
        self.stripe_length.grid(row=r + 1)
        Label(f).grid(row=r + 2)
        r += 3
        while r < self.ROWS:
            Label(f).grid(row=r)
            r += 1
        Button(f, text="RELIABILITY", command=self.do_rados).grid(row=r)
        f.grid(column=3, row=1)

        # fourth stack (remote site)
        r = 1
        f = Frame(t, bd=self.BORDER, relief=RIDGE)
        Label(f, text="RADOS Sites").grid(row=r)
        self.site_num = Spinbox(f,
                                values=self.site_count,
                                width=self.short_wid)
        self.site_num.grid(row=r + 1)
        self.site_num.delete(0, END)
        self.site_num.insert(0, "%d" % cfg.remote_sites)
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Rep Latency (s)").grid(row=r)
        self.remote_latency = Spinbox(f,
                                      values=self.async_latencies,
                                      width=self.long_wid)
        self.remote_latency.grid(row=r + 1)
        self.remote_latency.delete(0, END)
        self.remote_latency.insert(0, "%d" % (cfg.remote_latency * 60 * 60))
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Recovery (MiB/s)").grid(row=r)
        self.remote_speed = Spinbox(f,
                                    values=self.remote_speeds,
                                    width=self.med_wid)
        self.remote_speed.grid(row=r + 1)
        self.remote_speed.delete(0, END)
        self.remote_speed.insert(0, "%d" % (cfg.remote_recover / MiB))
        Label(f).grid(row=r + 2)
        r += 3
        Label(f, text="Disaster (years)").grid(row=r)
        self.remote_fail = Spinbox(f,
                                   values=self.site_destroy,
                                   width=self.long_wid)
        self.remote_fail.grid(row=r + 1)
        self.remote_fail.delete(0, END)
        self.remote_fail.insert(0, "1000")
        # FIX - get this from cfg ... but translate from FITS
        Label(f).grid(column=2, row=r + 2)
        r += 3
        Label(f, text="Site Recover (days)").grid(row=r)
        self.remote_avail = Spinbox(f,
                                    values=self.site_recover,
                                    width=self.long_wid)
        self.remote_avail.grid(row=r + 1)
        self.remote_avail.delete(0, END)
        self.remote_avail.insert(0, "30")
        # FIX - get this from cfg ... but translate from FITS
        Label(f).grid(row=r + 2)
        r += 3
        while r < self.ROWS:
            Label(f).grid(row=r)
            r += 1
        Button(f, text="RELIABILITY", command=self.do_sites).grid(row=r)
        f.grid(column=4, row=1)

        # and the control panel
        r = 2
        c = 1
        Label(t).grid(column=c, row=r)
        Label(t, text="NRE model").grid(column=c, row=r + 1)
        self.nre_model = StringVar(t)
        self.nre_model.set(self.cfg.nre_model)
        OptionMenu(t, self.nre_model, *self.nreTypes).grid(column=c, row=r + 2)

        c = 2
        Label(t).grid(column=c, row=r)
        Label(t, text="Period (years)").grid(column=c, row=r + 1)
        self.period = Spinbox(t, from_=1, to=10, width=self.short_wid)
        self.period.grid(column=c, row=r + 2)

        c = 3
        Label(t).grid(column=c, row=r)
        Label(t, text="Object size").grid(column=c, row=r + 1)
        # generate object sizes dynamically from parameters
        os = self.min_obj_size
        while os <= self.max_obj_size:
            if os < MB:
                s = "%dKB" % (os / KB)
            elif os < GB:
                s = "%dMB" % (os / MB)
            elif os < TB:
                s = "%dGB" % (os / GB)
            else:
                s = "%dTB" % (os / TB)
            self.object_sizes.append(s)
            os *= self.step_obj_size
        self.obj_size = Spinbox(t,
                                values=self.object_sizes,
                                width=self.long_wid)
        self.obj_size.grid(column=c, row=r + 2)
        self.obj_size.delete(0, END)
        self.obj_size.insert(0, self.object_sizes[0])

        c = 4
        Label(t).grid(column=c, row=r)
        Label(t, text="Verbosity").grid(column=c, row=r + 1)
        self.verbosity = StringVar(t)
        self.verbosity.set(cfg.verbose)
        OptionMenu(t, self.verbosity, *self.verbosities).grid(column=c,
                                                              row=r + 2)

        # and then finalize everything
        t.grid()
Пример #37
0
    def __init__(self, parent):
        Frame.__init__(self, parent)

        self.parent = parent

        self.startUI()
Пример #38
0
class Table(Frame):
    def __init__(self,
                 master,
                 columns,
                 column_weights=None,
                 column_minwidths=None,
                 height=500,
                 minwidth=20,
                 minheight=20,
                 padx=5,
                 pady=5,
                 cell_font=None,
                 cell_foreground="black",
                 cell_background="white",
                 cell_anchor=W,
                 header_font=None,
                 header_background="white",
                 header_foreground="black",
                 header_anchor=CENTER,
                 bordercolor="#999999",
                 innerborder=True,
                 outerborder=True,
                 stripped_rows=("#EEEEEE", "white"),
                 on_change_data=None,
                 mousewheel_speed=2,
                 scroll_horizontally=False,
                 scroll_vertically=True):
        outerborder_width = 1 if outerborder else 0

        Frame.__init__(self, master, bd=0)

        self._cell_background = cell_background
        self._cell_foreground = cell_foreground
        self._cell_font = cell_font
        self._cell_anchor = cell_anchor

        self._stripped_rows = stripped_rows

        self._padx = padx
        self._pady = pady

        self._bordercolor = bordercolor
        self._innerborder_width = 1 if innerborder else 0

        self._data_vars = []

        self._columns = columns

        self._number_of_rows = 0
        self._number_of_columns = len(columns)

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

        self._head = Frame(self,
                           highlightbackground=bordercolor,
                           highlightcolor=bordercolor,
                           highlightthickness=outerborder_width,
                           bd=0)
        self._head.grid(row=0, column=0, sticky=E + W)

        header_separator = False if outerborder else True

        for j in range(len(columns)):
            column_name = columns[j]

            header_cell = Header_Cell(self._head,
                                      text=column_name,
                                      borderwidth=self._innerborder_width,
                                      font=header_font,
                                      background=header_background,
                                      foreground=header_foreground,
                                      padx=padx,
                                      pady=pady,
                                      bordercolor=bordercolor,
                                      anchor=header_anchor,
                                      separator=header_separator)
            header_cell.grid(row=0, column=j, sticky=N + E + W + S)

        add_scrollbars = scroll_horizontally or scroll_vertically
        if add_scrollbars:
            if scroll_horizontally:
                xscrollbar = Scrollbar(self, orient=HORIZONTAL)
                xscrollbar.grid(row=2, column=0, sticky=E + W)
            else:
                xscrollbar = None

            if scroll_vertically:
                yscrollbar = Scrollbar(self, orient=VERTICAL)
                yscrollbar.grid(row=1, column=1, sticky=N + S)
            else:
                yscrollbar = None

            scrolling_area = Scrolling_Area(
                self,
                width=self._head.winfo_reqwidth(),
                height=height,
                scroll_horizontally=scroll_horizontally,
                xscrollbar=xscrollbar,
                scroll_vertically=scroll_vertically,
                yscrollbar=yscrollbar)
            scrolling_area.grid(row=1, column=0, sticky=E + W)

            self._body = Frame(scrolling_area.innerframe,
                               highlightbackground=bordercolor,
                               highlightcolor=bordercolor,
                               highlightthickness=outerborder_width,
                               bd=0)
            self._body.pack()

            def on_change_data():
                scrolling_area.update_viewport()

        else:
            self._body = Frame(self,
                               height=height,
                               highlightbackground=bordercolor,
                               highlightcolor=bordercolor,
                               highlightthickness=outerborder_width,
                               bd=0)
            self._body.grid(row=1, column=0, sticky=N + E + W + S)

        if column_weights is None:
            for j in range(len(columns)):
                self._body.grid_columnconfigure(j, weight=1)
        else:
            for j, weight in enumerate(column_weights):
                self._body.grid_columnconfigure(j, weight=weight)

        if column_minwidths is not None:
            for j, minwidth in enumerate(column_minwidths):
                if minwidth is None:
                    header_cell = self._head.grid_slaves(row=0, column=j)[0]
                    minwidth = header_cell.winfo_reqwidth()

                self._body.grid_columnconfigure(j, minsize=minwidth)
        else:
            for j in range(len(columns)):
                header_cell = self._head.grid_slaves(row=0, column=j)[0]
                minwidth = header_cell.winfo_reqwidth()

                self._body.grid_columnconfigure(j, minsize=minwidth)

        self._on_change_data = on_change_data

    def _append_n_rows(self, n):
        number_of_rows = self._number_of_rows
        number_of_columns = self._number_of_columns

        for i in range(number_of_rows, number_of_rows + n):
            list_of_vars = []
            for j in range(number_of_columns):
                var = StringVar()
                list_of_vars.append(var)

                if self._stripped_rows:
                    cell = Data_Cell(self._body,
                                     borderwidth=self._innerborder_width,
                                     variable=var,
                                     bordercolor=self._bordercolor,
                                     padx=self._padx,
                                     pady=self._pady,
                                     background=self._stripped_rows[i % 2],
                                     foreground=self._cell_foreground,
                                     font=self._cell_font,
                                     anchor=self._cell_anchor)
                else:
                    cell = Data_Cell(self._body,
                                     borderwidth=self._innerborder_width,
                                     variable=var,
                                     bordercolor=self._bordercolor,
                                     padx=self._padx,
                                     pady=self._pady,
                                     background=self._cell_background,
                                     foreground=self._cell_foreground,
                                     font=self._cell_font,
                                     anchor=self._cell_anchor)

                cell.grid(row=i, column=j, sticky=N + E + W + S)

            self._data_vars.append(list_of_vars)

        if number_of_rows == 0:
            for j in range(self.number_of_columns):
                header_cell = self._head.grid_slaves(row=0, column=j)[0]
                data_cell = self._body.grid_slaves(row=0, column=j)[0]
                data_cell.bind("<Configure>",
                               lambda event, header_cell=header_cell:
                               header_cell.configure(width=event.width),
                               add="+")

        self._number_of_rows += n

    def _pop_n_rows(self, n):
        number_of_rows = self._number_of_rows
        number_of_columns = self._number_of_columns

        for i in range(number_of_rows - n, number_of_rows):
            for j in range(number_of_columns):
                self._body.grid_slaves(row=i, column=j)[0].destroy()

            self._data_vars.pop()

        self._number_of_rows -= n

    def set_data(self, data):
        n = len(data)
        m = len(data[0])

        number_of_rows = self._number_of_rows

        if number_of_rows > n:
            self._pop_n_rows(number_of_rows - n)
        elif number_of_rows < n:
            self._append_n_rows(n - number_of_rows)

        for i in range(n):
            for j in range(m):
                self._data_vars[i][j].set(data[i][j])

        if self._on_change_data is not None: self._on_change_data()

    def get_data(self):
        number_of_rows = self._number_of_rows
        number_of_columns = self.number_of_columns

        data = []
        for i in range(number_of_rows):
            row = []
            row_of_vars = self._data_vars[i]
            for j in range(number_of_columns):
                cell_data = row_of_vars[j].get()
                row.append(cell_data)

            data.append(row)
        return data

    @property
    def number_of_rows(self):
        return self._number_of_rows

    @property
    def number_of_columns(self):
        return self._number_of_columns

    def row(self, index, data=None):
        if data is None:
            row = []
            row_of_vars = self._data_vars[index]

            for j in range(self.number_of_columns):
                row.append(row_of_vars[j].get())

            return row
        else:
            number_of_columns = self.number_of_columns

            if len(data) != number_of_columns:
                raise ValueError("Demo_programs has no %d elements: %s" %
                                 (number_of_columns, data))

            row_of_vars = self._data_vars[index]
            for j in range(number_of_columns):
                row_of_vars[index][j].set(data[j])

            if self._on_change_data is not None: self._on_change_data()

    def column(self, index, data=None):
        number_of_rows = self._number_of_rows

        if data is None:
            column = []

            for i in range(number_of_rows):
                column.append(self._data_vars[i][index].get())

            return column
        else:
            if len(data) != number_of_rows:
                raise ValueError("Demo_programs has no %d elements: %s" %
                                 (number_of_rows, data))

            for i in range(number_of_columns):
                self._data_vars[i][index].set(data[i])

            if self._on_change_data is not None: self._on_change_data()

    def clear(self):
        number_of_rows = self._number_of_rows
        number_of_columns = self._number_of_columns

        for i in range(number_of_rows):
            for j in range(number_of_columns):
                self._data_vars[i][j].set("")

        if self._on_change_data is not None: self._on_change_data()

    def delete_row(self, index):
        i = index
        while i < self._number_of_rows:
            row_of_vars_1 = self._data_vars[i]
            row_of_vars_2 = self._data_vars[i + 1]

            j = 0
            while j < self.number_of_columns:
                row_of_vars_1[j].set(row_of_vars_2[j])

            i += 1

        self._pop_n_rows(1)

        if self._on_change_data is not None: self._on_change_data()

    def insert_row(self, data, index=END):
        self._append_n_rows(1)

        if index == END:
            index = self._number_of_rows - 1

        i = self._number_of_rows - 1
        while i > index:
            row_of_vars_1 = self._data_vars[i - 1]
            row_of_vars_2 = self._data_vars[i]

            j = 0
            while j < self.number_of_columns:
                row_of_vars_2[j].set(row_of_vars_1[j])
                j += 1
            i -= 1

        list_of_cell_vars = self._data_vars[index]
        for cell_var, cell_data in zip(list_of_cell_vars, data):
            cell_var.set(cell_data)

        if self._on_change_data is not None: self._on_change_data()

    def cell(self, row, column, data=None):
        """Get the value of a table cell"""
        if data is None:
            return self._data_vars[row][column].get()
        else:
            self._data_vars[row][column].set(data)
            if self._on_change_data is not None: self._on_change_data()

    def __getitem__(self, index):
        if isinstance(index, tuple):
            row, column = index
            return self.cell(row, column)
        else:
            raise Exception("Row and column indices are required")

    def __setitem__(self, index, value):
        if isinstance(index, tuple):
            row, column = index
            self.cell(row, column, value)
        else:
            raise Exception("Row and column indices are required")

    def on_change_data(self, callback):
        self._on_change_data = callback
Пример #39
0
class CollocationsView:
    _BACKGROUND_COLOUR='#FFF' #white

    def __init__(self):
        self.model = CollocationsModel()
        self.model.add_listener(self)
        self.top = Tk()
        self._init_top(self.top)
        self._init_menubar()
        self._init_widgets(self.top)
        self._bind_event_handlers()
        self.load_corpus(self.model.DEFAULT_CORPUS)

    def _init_top(self, top):
        top.geometry('550x650+50+50')
        top.title('NLTK Collocations List')
        top.bind('<Control-q>', self.destroy)
        top.minsize(550,650)

    def _init_widgets(self, parent):
        self.main_frame = Frame(parent, dict(background=self._BACKGROUND_COLOUR, padx=1, pady=1, border=1))
        self._init_corpus_select(self.main_frame)
        self._init_results_box(self.main_frame)
        self._init_paging(self.main_frame)
        self._init_status(self.main_frame)
        self.main_frame.pack(fill='both', expand=True)

    def _init_corpus_select(self, parent):
        innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
        self.var = StringVar(innerframe)
        self.var.set(self.model.DEFAULT_CORPUS)
        Label(innerframe, justify=LEFT, text=' Corpus: ', background=self._BACKGROUND_COLOUR, padx = 2, pady = 1, border = 0).pack(side='left')

        other_corpora = self.model.CORPORA.keys().remove(self.model.DEFAULT_CORPUS)
        om = OptionMenu(innerframe, self.var, self.model.DEFAULT_CORPUS, command=self.corpus_selected, *self.model.non_default_corpora())
        om['borderwidth'] = 0
        om['highlightthickness'] = 1
        om.pack(side='left')
        innerframe.pack(side='top', fill='x', anchor='n')

    def _init_status(self, parent):
        self.status = Label(parent, justify=LEFT, relief=SUNKEN, background=self._BACKGROUND_COLOUR, border=0, padx = 1, pady = 0)
        self.status.pack(side='top', anchor='sw')

    def _init_menubar(self):
        self._result_size = IntVar(self.top)
        menubar = Menu(self.top)

        filemenu = Menu(menubar, tearoff=0, borderwidth=0)
        filemenu.add_command(label='Exit', underline=1,
                   command=self.destroy, accelerator='Ctrl-q')
        menubar.add_cascade(label='File', underline=0, menu=filemenu)

        editmenu = Menu(menubar, tearoff=0)
        rescntmenu = Menu(editmenu, tearoff=0)
        rescntmenu.add_radiobutton(label='20', variable=self._result_size,
                     underline=0, value=20, command=self.set_result_size)
        rescntmenu.add_radiobutton(label='50', variable=self._result_size,
                     underline=0, value=50, command=self.set_result_size)
        rescntmenu.add_radiobutton(label='100', variable=self._result_size,
                     underline=0, value=100, command=self.set_result_size)
        rescntmenu.invoke(1)
        editmenu.add_cascade(label='Result Count', underline=0, menu=rescntmenu)

        menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
        self.top.config(menu=menubar)

    def set_result_size(self, **kwargs):
        self.model.result_count = self._result_size.get()

    def _init_results_box(self, parent):
        innerframe = Frame(parent)
        i1 = Frame(innerframe)
        i2 = Frame(innerframe)
        vscrollbar = Scrollbar(i1, borderwidth=1)
        hscrollbar = Scrollbar(i2, borderwidth=1, orient='horiz')
        self.results_box = Text(i1,
                    font=tkFont.Font(family='courier', size='16'),
                    state='disabled', borderwidth=1,
                    yscrollcommand=vscrollbar.set,
                    xscrollcommand=hscrollbar.set, wrap='none', width='40', height = '20', exportselection=1)
        self.results_box.pack(side='left', fill='both', expand=True)
        vscrollbar.pack(side='left', fill='y', anchor='e')
        vscrollbar.config(command=self.results_box.yview)
        hscrollbar.pack(side='left', fill='x', expand=True, anchor='w')
        hscrollbar.config(command=self.results_box.xview)
        #there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
        Label(i2, text='   ', background=self._BACKGROUND_COLOUR).pack(side='left', anchor='e')
        i1.pack(side='top', fill='both', expand=True, anchor='n')
        i2.pack(side='bottom', fill='x', anchor='s')
        innerframe.pack(side='top', fill='both', expand=True)

    def _init_paging(self, parent):
        innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
        self.prev = prev = Button(innerframe, text='Previous', command=self.previous, width='10', borderwidth=1, highlightthickness=1, state='disabled')
        prev.pack(side='left', anchor='center')
        self.next = next = Button(innerframe, text='Next', command=self.next, width='10', borderwidth=1, highlightthickness=1, state='disabled')
        next.pack(side='right', anchor='center')
        innerframe.pack(side='top', fill='y')
        self.reset_current_page()

    def reset_current_page(self):
        self.current_page = -1

    def _bind_event_handlers(self):
        self.top.bind(CORPUS_LOADED_EVENT, self.handle_corpus_loaded)
        self.top.bind(ERROR_LOADING_CORPUS_EVENT, self.handle_error_loading_corpus)

    def handle_error_loading_corpus(self, event):
        self.status['text'] = 'Error in loading ' + self.var.get()
        self.unfreeze_editable()
        self.clear_results_box()
        self.freeze_editable()
        self.reset_current_page()

    def handle_corpus_loaded(self, event):
        self.status['text'] = self.var.get() + ' is loaded'
        self.unfreeze_editable()
        self.clear_results_box()
        self.reset_current_page()
        #self.next()
        collocations = self.model.next(self.current_page + 1)
        self.write_results(collocations)
        self.current_page += 1

    def corpus_selected(self, *args):
        new_selection = self.var.get()
        self.load_corpus(new_selection)

    def previous(self):
        self.freeze_editable()
        collocations = self.model.prev(self.current_page - 1)
        self.current_page= self.current_page - 1
        self.clear_results_box()
        self.write_results(collocations)
        self.unfreeze_editable()

    def next(self):
        self.freeze_editable()
        collocations = self.model.next(self.current_page + 1)
        self.clear_results_box()
        self.write_results(collocations)
        self.current_page += 1
        self.unfreeze_editable()

    def load_corpus(self, selection):
        if self.model.selected_corpus != selection:
            self.status['text'] = 'Loading ' + selection + '...'
            self.freeze_editable()
            self.model.load_corpus(selection)

    def freeze_editable(self):
        self.prev['state'] = 'disabled'
        self.next['state'] = 'disabled'

    def clear_results_box(self):
        self.results_box['state'] = 'normal'
        self.results_box.delete("1.0", END)
        self.results_box['state'] = 'disabled'

    def fire_event(self, event):
        #Firing an event so that rendering of widgets happen in the mainloop thread
        self.top.event_generate(event, when='tail')

    def destroy(self, *e):
        if self.top is None: return
        self.top.destroy()
        self.top = None

    def mainloop(self, *args, **kwargs):
        if in_idle(): return
        self.top.mainloop(*args, **kwargs)

    def unfreeze_editable(self):
        self.set_paging_button_states()

    def set_paging_button_states(self):
        if self.current_page == -1 or self.current_page == 0:
            self.prev['state'] = 'disabled'
        else:
            self.prev['state'] = 'normal'
        if self.model.is_last_page(self.current_page):
            self.next['state'] = 'disabled'
        else:
            self.next['state'] = 'normal'

    def write_results(self, results):
        self.results_box['state'] = 'normal'
        row = 1
        for each in results:
            self.results_box.insert(str(row) + '.0', each[0] + " " + each[1] + "\n")
            row += 1
        self.results_box['state'] = 'disabled'
Пример #40
0
    def __init__(self,
                 master,
                 columns,
                 column_weights=None,
                 column_minwidths=None,
                 height=500,
                 minwidth=20,
                 minheight=20,
                 padx=5,
                 pady=5,
                 cell_font=None,
                 cell_foreground="black",
                 cell_background="white",
                 cell_anchor=W,
                 header_font=None,
                 header_background="white",
                 header_foreground="black",
                 header_anchor=CENTER,
                 bordercolor="#999999",
                 innerborder=True,
                 outerborder=True,
                 stripped_rows=("#EEEEEE", "white"),
                 on_change_data=None,
                 mousewheel_speed=2,
                 scroll_horizontally=False,
                 scroll_vertically=True):
        outerborder_width = 1 if outerborder else 0

        Frame.__init__(self, master, bd=0)

        self._cell_background = cell_background
        self._cell_foreground = cell_foreground
        self._cell_font = cell_font
        self._cell_anchor = cell_anchor

        self._stripped_rows = stripped_rows

        self._padx = padx
        self._pady = pady

        self._bordercolor = bordercolor
        self._innerborder_width = 1 if innerborder else 0

        self._data_vars = []

        self._columns = columns

        self._number_of_rows = 0
        self._number_of_columns = len(columns)

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

        self._head = Frame(self,
                           highlightbackground=bordercolor,
                           highlightcolor=bordercolor,
                           highlightthickness=outerborder_width,
                           bd=0)
        self._head.grid(row=0, column=0, sticky=E + W)

        header_separator = False if outerborder else True

        for j in range(len(columns)):
            column_name = columns[j]

            header_cell = Header_Cell(self._head,
                                      text=column_name,
                                      borderwidth=self._innerborder_width,
                                      font=header_font,
                                      background=header_background,
                                      foreground=header_foreground,
                                      padx=padx,
                                      pady=pady,
                                      bordercolor=bordercolor,
                                      anchor=header_anchor,
                                      separator=header_separator)
            header_cell.grid(row=0, column=j, sticky=N + E + W + S)

        add_scrollbars = scroll_horizontally or scroll_vertically
        if add_scrollbars:
            if scroll_horizontally:
                xscrollbar = Scrollbar(self, orient=HORIZONTAL)
                xscrollbar.grid(row=2, column=0, sticky=E + W)
            else:
                xscrollbar = None

            if scroll_vertically:
                yscrollbar = Scrollbar(self, orient=VERTICAL)
                yscrollbar.grid(row=1, column=1, sticky=N + S)
            else:
                yscrollbar = None

            scrolling_area = Scrolling_Area(
                self,
                width=self._head.winfo_reqwidth(),
                height=height,
                scroll_horizontally=scroll_horizontally,
                xscrollbar=xscrollbar,
                scroll_vertically=scroll_vertically,
                yscrollbar=yscrollbar)
            scrolling_area.grid(row=1, column=0, sticky=E + W)

            self._body = Frame(scrolling_area.innerframe,
                               highlightbackground=bordercolor,
                               highlightcolor=bordercolor,
                               highlightthickness=outerborder_width,
                               bd=0)
            self._body.pack()

            def on_change_data():
                scrolling_area.update_viewport()

        else:
            self._body = Frame(self,
                               height=height,
                               highlightbackground=bordercolor,
                               highlightcolor=bordercolor,
                               highlightthickness=outerborder_width,
                               bd=0)
            self._body.grid(row=1, column=0, sticky=N + E + W + S)

        if column_weights is None:
            for j in range(len(columns)):
                self._body.grid_columnconfigure(j, weight=1)
        else:
            for j, weight in enumerate(column_weights):
                self._body.grid_columnconfigure(j, weight=weight)

        if column_minwidths is not None:
            for j, minwidth in enumerate(column_minwidths):
                if minwidth is None:
                    header_cell = self._head.grid_slaves(row=0, column=j)[0]
                    minwidth = header_cell.winfo_reqwidth()

                self._body.grid_columnconfigure(j, minsize=minwidth)
        else:
            for j in range(len(columns)):
                header_cell = self._head.grid_slaves(row=0, column=j)[0]
                minwidth = header_cell.winfo_reqwidth()

                self._body.grid_columnconfigure(j, minsize=minwidth)

        self._on_change_data = on_change_data
Пример #41
0
    def __init__(self, parent):
        Frame.__init__(self, parent)

        self.parent = parent
Пример #42
0
    def __init__(self,
                 master,
                 width=None,
                 anchor=N,
                 height=None,
                 mousewheel_speed=2,
                 scroll_horizontally=True,
                 xscrollbar=None,
                 scroll_vertically=True,
                 yscrollbar=None,
                 outer_background=None,
                 inner_frame=Frame,
                 **kw):
        Frame.__init__(self, master, class_=self.__class__)

        if outer_background:
            self.configure(background=outer_background)

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

        self._width = width
        self._height = height

        self.canvas = Canvas(self,
                             background=outer_background,
                             highlightthickness=0,
                             width=width,
                             height=height)
        self.canvas.grid(row=0, column=0, sticky=N + E + W + S)

        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.canvas.configure(yscrollcommand=self.yscrollbar.set)
            self.yscrollbar['command'] = self.canvas.yview
        else:
            self.yscrollbar = None

        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.canvas.configure(xscrollcommand=self.xscrollbar.set)
            self.xscrollbar['command'] = self.canvas.xview
        else:
            self.xscrollbar = None

        self.rowconfigure(0, weight=1)
        self.columnconfigure(0, weight=1)

        self.innerframe = inner_frame(self.canvas, **kw)
        self.innerframe.pack(anchor=anchor)

        self.canvas.create_window(0,
                                  0,
                                  window=self.innerframe,
                                  anchor='nw',
                                  tags="inner_frame")

        self.canvas.bind('<Configure>', self._on_canvas_configure)

        Mousewheel_Support(self).add_support_to(self.canvas,
                                                xscrollbar=self.xscrollbar,
                                                yscrollbar=self.yscrollbar)
Пример #43
0
from matplotlib.axes import Subplot
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg
from matplotlib.figure import Figure

from Tkconstants import TOP, BOTH, BOTTOM, LEFT, RIGHT, GROOVE
from Tkinter import Tk, Button, Frame
from math import radians, degrees, cos, sin, tan, atan, atan2, sqrt, pow, pi, atan
import sys

from clsPoint import PointClass
from clsEllipse import EllipseClass

if 1:
    master = Tk()
    figure = Figure(figsize=(8, 8), dpi=100)
    frame_c = Frame(relief=GROOVE, bd=2)
    frame_c.pack(
        fill=BOTH,
        expand=1,
    )
    canvas = FigureCanvasTkAgg(figure, master=frame_c)
    canvas.show()
    canvas.get_tk_widget().pack(fill=BOTH, expand=1)
    plot1 = figure.add_subplot(111)
    plot1.axis('equal')

    # Parameter der Ellipse
    el = EllipseClass(PointClass(0, 0), 200, 100, radians(30))
    polyline_step = 10  # PolyLine - Winkel-Schritt, in dem wir um die Ellipse sausen
    biarc_step = 35  # BiArc - Winkel-Schritt, in dem wir um die Ellipse sausen
Пример #44
0
 def _init_results_box(self, parent):
     innerframe = Frame(parent)
     i1 = Frame(innerframe)
     i2 = Frame(innerframe)
     vscrollbar = Scrollbar(i1, borderwidth=1)
     hscrollbar = Scrollbar(i2, borderwidth=1, orient='horiz')
     self.results_box = Text(i1,
                 font=tkFont.Font(family='courier', size='16'),
                 state='disabled', borderwidth=1,
                 yscrollcommand=vscrollbar.set,
                 xscrollcommand=hscrollbar.set, wrap='none', width='40', height = '20', exportselection=1)
     self.results_box.pack(side='left', fill='both', expand=True)
     vscrollbar.pack(side='left', fill='y', anchor='e')
     vscrollbar.config(command=self.results_box.yview)
     hscrollbar.pack(side='left', fill='x', expand=True, anchor='w')
     hscrollbar.config(command=self.results_box.xview)
     #there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
     Label(i2, text='   ', background=self._BACKGROUND_COLOUR).pack(side='left', anchor='e')
     i1.pack(side='top', fill='both', expand=True, anchor='n')
     i2.pack(side='bottom', fill='x', anchor='s')
     innerframe.pack(side='top', fill='both', expand=True)
Пример #45
0
 def __init__(self, parent):  # if not a frame
     Frame.__init__(self, parent)  # provide container
     self.pack(expand=YES, fill=BOTH)
     self.config(relief=RIDGE, border=2)  # reconfig to change
Пример #46
0
 def __init__(self, parent):
     Frame.__init__(self, parent, background='white')
     self.parent = parent
     self.init_ui()
Пример #47
0
"""gridmanager

This module ilustrates how widgets can be placed using the grid layout.
"""
import sys

if sys.version_info < (3, 0):
    from Tkinter import Tk, Label, SUNKEN, RAISED, Frame
else:
    from tkinter import Tk, Label, SUNKEN, RAISED, Frame

# Create mainwindow (root, a Tk instance)
mainwin = Tk()

# Create a Frame which will 'hold' various widgets in a grid layout
content = Frame(mainwin)

# Create the Label widgets with the container object (Frame) as the parent.
l1 = Label(content, text="Cell [0,0]", relief=RAISED, bg='red')
l2 = Label(content, text="Cell [0,1]", relief=SUNKEN)
l3 = Label(content, text="Cell [0,2]", relief=RAISED, bg='red')
l4 = Label(content, text="Cell [1,1]", relief=RAISED, bg='green')
l5 = Label(content, text="Cell [1,3]", relief=RAISED, bg='green')
l6 = Label(content, text="Cell [2,4]", relief=SUNKEN)
l7 = Label(content, text="Cell [3,0] to [3,3] (spanning 4 cols)",
           relief=RAISED, bg='red')

# Define the grid layout for these labels. The stick option helps place the
# widget along the edge of the cell (of the grid) to which it belongs. For
# example, sticky="nsew" will align the widget along top, bottom, right and
# left edges of the cell respectively.
Пример #48
0
    def __init__(self, master):

        #min and max size of window
        #master.minsize(width=410, height=700)
        #master.maxsize(width=410, height=700)
        #end

        #title of window
        master.title("Airvengers")
        #end

        #for scrolling the page

        #end

        #for the style of fonts
        self.customFont = tkFont.Font(family="Helvetica", size=15)
        self.myfont = tkFont.Font(family="Helvetica", size=12)
        self.myfont2 = tkFont.Font(family="Helvetica", size=10)
        #end

        #header frame
        self.frame_header = Frame(master, bg="lightsteelblue")
        self.frame_header.pack(fill=BOTH, side=TOP, expand=True)
        self.logo = PhotoImage(file="logoair.gif")
        Label(self.frame_header, image=self.logo).grid(row=0,
                                                       column=0,
                                                       sticky='sw',
                                                       columnspan=2)
        #end

        #content frame
        self.frame_content = Frame(master, bg="lightsteelblue")
        self.frame_content.pack(fill=BOTH, side=TOP, expand=True)

        Label(self.frame_content,
              text='Based on:',
              font=self.myfont,
              wraplength=200,
              bg="midnightblue",
              fg="firebrick").grid(row=0, column=0, padx=5, sticky='sw')
        Label(self.frame_content,
              text='GUI by Hitesh:',
              font=self.myfont,
              wraplength=200,
              padx=0,
              bg="midnightblue",
              fg="firebrick").grid(row=0, column=1, padx=5, sticky='sw')
        Label(self.frame_content,
              text='Aircrack-ng',
              font=self.myfont,
              wraplength=300,
              bg="midnightblue",
              fg="firebrick").grid(row=1, column=0, padx=5, sticky='sw')
        Label(self.frame_content,
              text='*****@*****.**',
              font=self.myfont2,
              wraplength=300,
              padx=0,
              bg="midnightblue",
              fg="firebrick").grid(row=1, column=1, padx=5, sticky='sw')

        #Label(self.frame_content, text = 'Comments:').grid(row = 2, column = 0, padx = 5, sticky = 'sw')

        #self.entry_name = Entry(self.frame_content, width = 24)
        #self.entry_email = Entry(self.frame_content, width = 24)
        #self.text_comments = Text(self.frame_content, width = 50, height = 10)

        #self.entry_name.grid(row = 1, column = 0, padx = 5)
        #self.entry_email.grid(row = 1, column = 1, padx = 5)
        #self.text_comments.grid(row = 3, column = 0, columnspan = 2, padx = 5)

        Button(self.frame_content,
               text='airmon-ng',
               command=AirmonNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=4, column=0, padx=5, pady=5)
        Button(self.frame_content,
               text='aircrack-ng',
               command=AircrackNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=4, column=1, padx=5, pady=5)
        Button(self.frame_content,
               text='airdecap-ng',
               command=AirdecapNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=5, column=0, padx=5, pady=5)
        Button(self.frame_content,
               text='airdecloak-ng',
               command=AirdecloakNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=5, column=1, padx=5, pady=5)
        Button(self.frame_content,
               text='airdrop-ng',
               command=AirdropNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=6, column=0, padx=5, pady=5)
        Button(self.frame_content,
               text='aireplay-ng',
               command=AireplayNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=6, column=1, padx=5, pady=5)
        Button(self.frame_content,
               text='airgraph-ng',
               command=AirgraphNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=7, column=0, padx=5, pady=5)
        Button(self.frame_content,
               text='airbase-ng',
               command=AirbaseNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=7, column=1, padx=5, pady=5)
        Button(self.frame_content,
               text='airodump-ng',
               command=AirodumpNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=8, column=0, padx=5, pady=5)
        Button(self.frame_content,
               text='airolib-ng',
               command=AirolibNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=8, column=1, padx=5, pady=5)
        Button(self.frame_content,
               text='airserv-ng ',
               command=AirservNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=9, column=0, padx=5, pady=5)
        Button(self.frame_content,
               text='airtun-ng ',
               command=AirtunNg,
               fg="cornflowerblue",
               height=2,
               width=15,
               font=self.customFont).grid(row=9, column=1, padx=5, pady=5)
Пример #49
0
 def __init__(self, parent):
     Frame.__init__(self, parent)
     self._set_no_image()
Пример #50
0
class ImportDialog(Toplevel):
    """
    Dialog window which prompts user for a selection of objects to import as well as
    showing a customizable list for displaying the data

    :param: root: root Tk widget, often Tk()
    :param: master: the main window, for access of polygonList
    """

    # This dialog should be a singleton, so the caller will ensure no other
    # windows are open by checking this variable
    singleton = False

    def __init__(self, root, master):
        ImportDialog.singleton = True  # creation of a pseudo singleton

        logger.info('Instantiating ImportDialog')
        Toplevel.__init__(self, root)
        self.transient(root)

        self.protocol('WM_DELETE_WINDOW', self.free)
        self.session = db.get_session()  # import window holds a session
        self.__internal_list = list()  # internal list of db objs
        self.__stack = collections.deque(maxlen=15)  # stack for searching
        self.__search_string = ''  # search string
        self.__master = master  # CALIPSO class
        self.__root = root
        self.title('Import from existing database')  # window title
        self.tree = None  # tree viewing class
        self.e = None  # entry box for searching
        self.top_frame = None  # top Tkinter frame
        self.bottom_frame = None  # bottom Tkinter frame
        self.bottom_button_frame = None  # bottom BUTTON Tkinter frame
        self.separator = None  # separator line
        self.filter_file = IntVar()  # int_var for filtering by file
        self.advance_dialog = False
        self.extract_dialog = False
        self.column_titles = [
            'name', 'plot', 'time range', 'latitude range', 'altitude range',
            'attributes', 'notes', 'last edited', 'file'
        ]

        self.plot_type = StringVar()
        self.beg_time = None
        self.end_time = None
        self.beg_lat = None
        self.end_lat = None
        self.beg_alt = None
        self.end_alt = None
        self.file = None

        center(self, (constants.IMPORTWIDTH, constants.IMPORTHEIGH))

        self.container = Frame(self)  # create center frame,
        self.container.pack(side=TOP, fill=BOTH, expand=True)  # place

        self.create_top_frame(
        )  # create the top frame and pack buttons / etc. on it
        self.create_bottom_frame()  # create the bottom frame and pack

    def create_top_frame(self):
        """
        Initialize the upper frame of the window in charge of buttons, in order:
        creates a top_frame, sets a 'Search' label and binds an entry box beside
        it, which calls ``refine_search`` upon a user releasing a key after pressing.
        Then binds the *delete* button to ``data_from_db``
        """
        logger.info('Creating top frame')
        self.top_frame = Frame(self.container)
        self.top_frame.pack(side=TOP, fill=X, expand=False)

        label = Label(self.top_frame, text='Search ')
        self.e = Entry(self.top_frame)
        create_tool_tip(self.e, 'Search in Name, Attributes, Notes')
        self.e.bind('<KeyRelease>', self.refine_search)
        label.grid(row=0, column=0, padx=5, pady=10)
        self.e.grid(row=0, column=1, padx=5, pady=10)

        check_button = Checkbutton(self.top_frame,
                                   text='Filter for this file',
                                   variable=self.filter_file,
                                   command=self.filter_by_current_file)
        check_button.grid(row=0, column=2, padx=5, pady=10)

        advanced_filter = Button(self.top_frame,
                                 text='Advanced',
                                 command=self.advanced_prompt)
        advanced_filter.grid(row=0, column=3, padx=5, pady=10)

        reset = Button(self.top_frame, text='Reset', command=self.reset)
        reset.grid(row=0, column=4, padx=5, pady=10)

        spacer = Label(self.top_frame, width=30)
        spacer.grid(row=0, column=5)
        self.top_frame.columnconfigure(5, weight=1)

        delete_button = Button(self.top_frame,
                               text='Delete',
                               command=self.delete_from_db,
                               width=10)
        delete_button.grid(row=0, column=6, padx=15)

    def create_bottom_frame(self):
        """
        Create and display database in listbox, also add lower button frame for import
        button
        """
        logger.info('Creating bottom frame')
        self.bottom_frame = Frame(self.container)  # create bottom frame
        self.bottom_frame.pack(side=BOTTOM, fill=BOTH, expand=True)
        self.separator = Frame(
            self.bottom_frame, relief=RIDGE, height=2,
            bg='gray')  # tiny separator splitting the top and bottom frame
        self.separator.pack(side=TOP, fill=X, expand=False)
        self.bottom_button_frame = Frame(
            self.bottom_frame)  # bottom frame for import button
        self.bottom_button_frame.pack(side=BOTTOM, fill=X, expand=False)

        self.tree = TreeListBox(self.bottom_frame, self.column_titles)

        for obj in self.session.query(DatabasePolygon).all():
            self.__internal_list.append(
                obj)  # insert JSON obj representation into internal list

        self.__display_all()

        Label(self.bottom_button_frame, width=35).grid(row=0, column=0)

        Button(self.bottom_button_frame,
               text='Import',
               width=30,
               command=self.import_selection).grid(row=0,
                                                   column=1,
                                                   padx=10,
                                                   pady=10)

        Button(self.bottom_button_frame,
               text='Extract Column Contents',
               width=25,
               command=self.extract_columns_dialog).grid(row=0,
                                                         column=2,
                                                         padx=10,
                                                         pady=10)

    def filter_by_current_file(self):
        """
        Command function for the check button located beside the entry box in Import Dialog.
        Lists all shapes given by only the current file when checked. If unchecked displays
        all entries.
        """
        if self.filter_file.get():
            fn = self.__master.get_file().rpartition('/')[2]
            lst = self.get_current_file_shapes()
            logger.info('Displaying %d shapes contained in %s' %
                        (len(lst), fn))
            # Only return list of objects in the current view, otherwise we would
            # just append lst
            lst = [x for x in lst if x in self.tree.info]
            self.__stack.append(self.tree.info)
            self.tree.info = lst
            self.tree.update()
        else:
            self.tree.info = self.__stack.pop()
            self.tree.update()

    def get_current_file_shapes(self):
        """
        Return a list of all shapes contained in the current file, queries the
        database looking for all entries with the column *tag* that match the
        file returned by the rpartitioned ``Calipso.get_file()`` function

        :rtype: list
        """
        fn = self.__master.get_file().rpartition('/')[2]
        lst = list()
        for obj in self.session.query(DatabasePolygon).filter_by(hdf=fn):
            time_range = '%s - %s' % (obj.begin_time.strftime(DATEFORMAT),
                                      obj.end_time.strftime('%H:%M:%S'))
            altitude_range = '%.3f - %.3f' % (obj.begin_alt, obj.end_alt)
            lat_range = '%.3f - %.3f' % (obj.begin_lat, obj.end_lat)
            lst.append((obj.tag, obj.plot, time_range, lat_range,
                        altitude_range, obj.attributes[1:-1], obj.notes,
                        obj.time_.strftime(DATEFORMAT), obj.hdf))
        if not lst:
            logger.warning('Query returned None, no shapes found')
        return lst

    def refine_search(self, event):
        """
        Function to dynamically narrow the results of a search while the
        user types into the search bar. Checks if the character is
        alpha numeric , and if so queries the database for the combined
        string. A backend stack keeps track of past searches, when the
        user enters the backspace code a previous instance is popped
        and reloaded.
        :param event: search box events
        """
        # append to search string
        self.__search_string += event.char
        # if the entry box is NOT empty
        if self.e.get() != '':
            # but If a backspace is entered that means we want to pop the stack
            if event.keysym == 'BackSpace':
                # remove one letter from search string and pop stack
                #new code should go here
                self.__search_string = self.__search_string[:-1]
                if self.__stack:
                    self.tree.info = self.__stack.pop()
                    self.tree.update()
            # else if the character is alphanumeric
            elif event.char.isalnum():
                # temporary variable to create new list
                lst = list()
                # for all objects in the database
                for obj in self.session.query(DatabasePolygon).filter(
                        or_(  # query the database for if search_string is contained in
                            # self.__search_string.strip() to remove leading and ending spaces
                            DatabasePolygon.tag.contains(
                                self.__search_string.strip()),
                            DatabasePolygon.attributes.contains(
                                self.__search_string.strip()),
                            DatabasePolygon.notes.contains(
                                self.__search_string.strip()))):
                    time_range = '%s - %s' % (obj.begin_time.strftime(
                        DATEFORMAT), obj.end_time.strftime('%H:%M:%S'))
                    altitude_range = '%.3f - %.3f' % (obj.begin_alt,
                                                      obj.end_alt)
                    lat_range = '%.3f - %.3f' % (obj.begin_lat, obj.end_lat)
                    lst.append(  # append any objects that were returned by the query
                        (obj.tag, obj.plot, time_range, lat_range,
                         altitude_range, obj.attributes[1:-1], obj.notes,
                         obj.time_.strftime(DATEFORMAT), obj.hdf))
                # push new query onto the stack and set display to list
                if self.filter_file.get():
                    sub_list = set(self.get_current_file_shapes())
                    lst = [x for x in lst if x in sub_list]
                self.__stack.append(self.tree.info)
                self.tree.info = lst
                self.tree.update()
        else:
            if self.filter_file.get():
                sub_list = set(self.get_current_file_shapes())
                self.__search_string = ''
                self.tree.info = sub_list
                self.tree.update()
            else:
                self.__search_string = ''
                self.__display_all()
        logger.info('Displaying refined search')

    def import_selection(self):
        """
        Import selected objects from internal_list into program
        """
        items = self.tree.tree.selection()
        logger.info('Parsing selection')
        # For all selected items in window
        skip = False
        for tag in items:
            # Find those items in internal list and import them
            tag = self.tree.tree.item(tag, option='values')
            fname = tag[-1]
            cfname = self.__master.get_file().rpartition('/')[2]
            if fname[-25:-4] != cfname[-25:-4]:
                skip = not tkMessageBox.\
                    askyesno('Unmatched files',
                             '%s is from a different file than currently'
                             % tag[0] +
                             ' loaded, proceed anyways? \ncurrent:%s \nloaded:%s'
                             % (tag[-1], cfname))
            if not skip:
                logger.info('Encoding \'%s\' to JSON' % tag[0])
                names = [x.tag for x in self.__internal_list]
                logger.info('Forwarding JSON to be read')
                self.__master.get_shapemanager().read_plot(read_from_str=str(
                    self.__internal_list[names.index(tag[0])]))
            else:
                logger.info('skipping loading for %s' % tag[0])
        self.free()

    def delete_from_db(self):
        """
        Delete selected objects from database
        """
        items = self.tree.tree.selection()
        if tkMessageBox.askyesno('Delete?',
                                 'Really delete these items?',
                                 parent=self):
            for tag in items:
                tag = self.tree.tree.item(tag, option='values')
                idx = self.__internal_list[[
                    x.tag for x in self.__internal_list
                ].index(tag[0])].id
                logger.info(
                    'Notifying db of deletion for \'%s\' from selection' %
                    tag[0])
                db.delete_item(idx)
            self.__display_all()

    def advanced_prompt(self):
        logger.info('Opening advanced search window')
        if (not AdvancedSearchDialog.singleton):
            AdvancedSearchDialog(self, self.__root). \
                wm_iconbitmap(ICO)
        else:
            logger.warning('Found existing advanced search window, canceling')

    def extract_columns_dialog(self):
        if not self.extract_dialog:
            ExtractColumnsDialog(self, self.__root)
            self.extract_dialog = True
        else:
            pass

    def __display_all(self):
        """
        Helper function to simply display all objects in the database
        """
        logger.info('Refreshing dialog view')
        lst = list()
        # Push previous display to stack
        if self.tree.info:
            self.__stack.append(self.tree.info)
        for obj in self.session.query(DatabasePolygon).all():
            time_range = '%s - %s' % (obj.begin_time.strftime(DATEFORMAT),
                                      obj.end_time.strftime('%H:%M:%S'))
            altitude_range = '%.3f - %.3f' % (obj.begin_alt, obj.end_alt)
            lat_range = '%.3f - %.3f' % (obj.begin_lat, obj.end_lat)
            lst.append(  # user see's this list
                (obj.tag, obj.plot, time_range, lat_range,
                 altitude_range, obj.attributes[1:-1], obj.notes,
                 obj.time_.strftime(DATEFORMAT), obj.hdf))

        self.tree.info = lst
        self.tree.update()

    def reset(self):
        """
        Reset the view of the tree within the import window, clears the stack as well
        """
        logger.info('Resetting tree view & stack')
        self.__display_all()
        self.__stack.clear()

    def receive_advanced_search(self, observer):
        """
        Receiving method called internally by an observer. When AdvancedSearchDialog is
        opened an observer is attached to this class, and upon the new ranges being updated
        this method is procd. The new ranges to query by are given by the dict received, so
        we can display the advanced search items. Below is a list of all items within the
        dictionary, with the format Key -> Format -> Type -> Desc

        date  -> '0000-00-00' -> y-m-d  -> The outer date of the time range
        btime -> '00-00-00'   -> hr-m-s -> Beginning time range (*btime* -> *etime*)
        etime -> '00-00-00'   -> hr-m-s -> Ending time range
        blat  -> '0.0'        -> float  -> Beginning latitude range (*blat* -> *elat*)
        elat  -> '0.0'        -> float  -> Ending latitude range
        balt  -> '0.0'        -> float  -> Beginning altitude range (*balt* -> *ealt*)
        ealt  -> '0.0'        -> float  -> Ending altitude range
        plot  -> PLOTS        -> string -> Type of plot ('backscattered' etc..)
        ampm  -> 'am'/'pm'    -> string -> Whether the time range is AM or PM
        file  -> '.....hdf'   -> string -> File name

        :param observer: An ``advancedsearchdialog.Query`` object
        """
        if 'free' in observer.ranges:
            self.advance_dialog = False
            return

        rng = observer.ranges

        # TODO: Fix this implementation

        query_result = self.session.query(DatabasePolygon)

        if rng['plot']:
            query_result = query_result.filter(
                DatabasePolygon.plot.is_(rng['plot']))

        if rng['file']:
            query_result = query_result.filter(
                DatabasePolygon.hdf.is_(rng['file']))

        if rng['blat']:
            query_result = query_result.filter(
                DatabasePolygon.begin_lat >= rng['blat'])

        if rng['elat']:
            query_result = query_result.filter(
                DatabasePolygon.end_lat <= rng['elat'])

        if rng['balt']:
            query_result = query_result.filter(
                DatabasePolygon.begin_alt >= rng['balt'])

        if rng['ealt']:
            query_result = query_result.filter(
                DatabasePolygon.end_alt <= rng['ealt'])

        lazy_list = list()

        for obj in query_result:
            time_range = '%s - %s' % (obj.begin_time.strftime(DATEFORMAT),
                                      obj.end_time.strftime('%H:%M:%S'))
            altitude_range = '%.3f - %.3f' % (obj.begin_alt, obj.end_alt)
            lat_range = '%.3f - %.3f' % (obj.begin_lat, obj.end_lat)
            # If we're parsing a date, we can't just filter as we must transform
            # coordinates into time_range first, so we need to manually check and
            # skip which is PROBABLY not the best solution.
            if rng['date'] and rng['date'] not in time_range:
                continue

            if rng['btime'] and obj.begin_time.time() < datetime.strptime(
                    rng['btime'], '%H:%M:%S').time():
                continue

            if rng['etime'] and obj.end_time.time() > datetime.strptime(
                    rng['etime'], '%H:%M:%S').time():
                continue

            lazy_list.append((obj.tag, obj.plot, time_range, lat_range,
                              altitude_range, obj.attributes[1:-1], obj.notes,
                              obj.time_.strftime(DATEFORMAT), obj.hdf))

        self.tree.info = lazy_list
        self.tree.update()

    def receive_extract_columns(self, observer):
        """
        Receiving method called internally by an observer bound to an ``ExtractColumnsDialog``
        instance. Upon the creation of a ``ExtractColumnDialog`` instance an observer is attached
        to the `ImportDialog`. Once the user finalizes the extraction details this function will
        be called with a dictionary of value .

        :param observer: An ``extractcolumnsdialog.ExtractionList`` object
        """
        if 'free' in observer.data:
            self.extract_dialog = False
            return

        columns_to_extract = [
            x for x in observer.data
            if observer.data[x] == 1 and x in self.column_titles
        ]
        filetype = observer.data['filetype']
        dataset = [[
            self.tree.tree.set(child, x)
            for child in self.tree.tree.get_children('')
        ] for x in columns_to_extract]

        if len(columns_to_extract) == 0:
            logger.error('No columns selected for extraction')
            tkMessageBox.showerror('Extract Columns',
                                   'No columns selected for extraction')
            return

        if filetype == TXT:
            f = tkFileDialog.\
                asksaveasfilename(defaultextension='.txt',
                                  filetypes=[('text files', '*.txt'), ('All files', '*')])
            if f == '':
                logger.info('canceling export column data as txt')
                return
            with open(f, 'w+') as outfile:
                outfile.write(' '.join(columns_to_extract) + '\n')
                for i in range(0, len(dataset[0])):
                    for j in range(0, len(dataset)):
                        outfile.write(str(dataset[j][i]) + ' ')
                    outfile.write('\n')
        if filetype == CSV:
            f = tkFileDialog.\
                asksaveasfilename(defaultextension='.csv',
                                  filetypes=[('csv files', '*.csv'), ('All files', '*')])
            if f == '':
                logger.info('canceling export column data as csv')
                return
            logger.info('Writing to .csv')
            dataset.insert(0, columns_to_extract)
            with open(f, 'w+') as outfile:
                for i in range(len(dataset[0])):
                    if i == len(dataset[0]) - 1:
                        outfile.write(str(dataset[0][i]))
                    else:
                        outfile.write(str(dataset[0][i]) + ',')
                outfile.write('\n')
                for i in range(len(dataset[1])):
                    for j in range(1, len(dataset)):
                        if j == len(dataset) - 1:
                            outfile.write(str(dataset[j][i]))
                        else:
                            outfile.write(str(dataset[j][i]) + ',')
                    outfile.write('\n')

    def free(self):
        """
        Commit the session, destroy the window and ensure the session is
        closed correctly
        """
        # Singleton no longer exists, so set it to false
        ImportDialog.singleton = False
        logger.info('Closing ImportDialog')
        self.session.commit()
        self.session.close()
        self.destroy()
 def __init__(self,master,extraPO=None,**params):
     tk.TkParameterized.__init__(self,master,extraPO=extraPO,**params)
     Frame.__init__(self,master)
     self.boocount=0
Пример #52
0
    def __init__(self, parent):
        Frame.__init__(self, parent)

        self.parent = parent  # this is in the Sudoku tutorial as well
        self.initUI()  # same as in Sudoku tutorial
Пример #53
0
    def __init__(self, master):

        self.SCROLL_GAP = 20
        self.SCROLL_BIG_GAP = 100

        self.left_scroller_position = (app.winfo_screenwidth()*0.25 , app.winfo_screenheight()/2);
        self.right_scroller_position = (app.winfo_screenwidth()*0.75 , app.winfo_screenheight()/2);

        layer0 = Frame(master)
        layer0.pack(fill=X)

        self.go_to_up = IntVar()
        self.go_to_up_check_button = Checkbutton(layer0, text="Backward [1]", variable=self.go_to_up)
        self.go_to_up_check_button.pack(side=LEFT, padx=1, pady=5)

        self.focus_left = IntVar()
        self.focus_left_check_button = Checkbutton(layer0, text="Focus on left [2]", variable=self.focus_left)
        self.focus_left_check_button.pack(side=LEFT, padx=25, pady=5)

        self.focus_right = IntVar()
        self.focus_right_check_button = Checkbutton(layer0, text="Focus on right [3]", variable=self.focus_right)
        self.focus_right_check_button.pack(side=LEFT, padx=25, pady=5)
        
        self.big_gap = IntVar()
        self.big_gap_check_button = Checkbutton(layer0, text="100 [4]", variable=self.big_gap)
        self.big_gap_check_button.pack(side=LEFT, padx=25, pady=5)

        # layer1 = Frame(master)
        # layer1.pack(fill=Y)

        self.right_scroller_label_var = StringVar()
        self.right_scroller_label = Label(layer0, textvariable=self.right_scroller_label_var)
        self.right_scroller_label_var.set(str(self.right_scroller_position))
        self.right_scroller_label.pack(side=RIGHT, padx=15, pady=5)

        self.left_scroller_label_var = StringVar()
        self.left_scroller_label = Label(layer0, textvariable=self.left_scroller_label_var)
        self.left_scroller_label_var.set(str(self.left_scroller_position))
        self.left_scroller_label.pack(side=RIGHT, padx=15, pady=5)
        # self.left_scroller_button = Button(layer0, text="Set left scroller(8)", command=self.set_left_scroller_position)
        # self.left_scroller_button.pack(side=RIGHT, padx=15, pady=5)

        # layer2 = Frame(master)
        # layer2.pack(fill=X)

        # self.right_scroller_button = Button(layer0, text="Set right scroller(9)", command=self.set_right_scroller_position)
        # self.right_scroller_button.pack(side=RIGHT, padx=5, pady=5)

        master.bind('8', self.set_left_scroller_position)
        master.bind('9', self.set_right_scroller_position)
        
        master.bind('<Up>', self.scroll_up)
        master.bind('<Down>', self.scroll_down)

        master.bind('<Right>', self.scroll_right)
        master.bind('<Left>', self.scroll_left)

        master.bind('1', self.toggle_up_to_go)
        master.bind('2', self.toggle_focus_left)
        master.bind('3', self.toggle_focus_righ)
        master.bind('4', self.toggle_big_gap)

        master.bind('<j>', self.scroll_up)
        master.bind('<k>', self.scroll_down)
        master.bind('<h>', self.scroll_left)
        master.bind('<l>', self.scroll_right)

        master.bind("<MouseWheel>", self.mouse_wheel)
Пример #54
0
    def infoaboveall(self):

        frame2 = Frame(self, relief=RAISED, borderwidth=5, background="linen")
        frame2.pack(fill=X)
        lbinfo = Label(frame2,
                       text="Состояние кассы:\n",
                       font="Arial 24",
                       background="linen")
        lbinfo.pack(side=TOP)

        #Проверяем на наличие интернет соединения:

        param = "time="
        res = Popen("ping -c 1 8.8.8.8", shell=True, stdout=PIPE)
        out = str(res.communicate()[0].decode("CP866"))
        print(out)
        if out.find(str(param)) == -1:
            lbnoping = Label(
                frame2,
                text="1.Интернет отсутствует! Вытащите и вставьте модем!",
                font="Arial 22",
                fg="red",
                background="linen")
            lbnoping.pack()
        else:
            lbyesping = Label(frame2,
                              text="1.Интернет есть!",
                              font="Arial 22",
                              fg="green",
                              background="linen")
            lbyesping.pack()

#Проверка на работоспособность УТМ

        param1 = "FSRAR-RSA"
        commandaCurl = "curl -X GET localhost:8082 | grep \"FSRAR-RSA\""
        res1 = Popen(commandaCurl, shell=True, stdout=PIPE)
        out1 = str(res1.communicate()[0].decode("CP866"))
        print(out1)
        if out1.find(str(param1)) == -1:
            lbnoUTM = Label(
                frame2,
                text="2.ЕГАИС НЕ работает! Нажмите Кнопку:Реанимация ЕГАИС",
                font="Arial 24",
                fg="red",
                background="linen")
            lbnoUTM.pack()
        else:
            lbyesUTM = Label(frame2,
                             text="2.ЕГАИС работает! ",
                             font="Arial 24",
                             fg="green",
                             background="linen")
            lbyesUTM.pack()
#Вывод информации о работоспособности Ключа
        var = "Ключ ЕГАИС работает"
        if self.Rutoken() == var:
            StatRutoken = Label(frame2,
                                text="3." + self.Rutoken(),
                                font="Arial 24",
                                fg="green")
            StatRutoken.pack()
        else:
            var1 = self.Rutoken()
            StatRutoken = Label(frame2,
                                text="3." + var1,
                                font="Arial 24",
                                fg="red")
            StatRutoken.pack()

#Кнопка обновления Tkinter:

        UpdateButton = Button(frame2,
                              font="Arial 24",
                              text="Обновить",
                              bd=2,
                              command=self.Update)
        UpdateButton.pack(side=RIGHT, pady=5)  #Координаты кнопки
Пример #55
0
class Notification(Toplevel):
    def __init__(self,
                 notification_manager,
                 builder,
                 index,
                 x,
                 y,
                 h,
                 v,
                 padx,
                 pady,
                 background=None,
                 on_hide=None):
        Toplevel.__init__(self)

        self._notification_manager = notification_manager

        self.index = index
        self.on_hide = on_hide

        # Removes the native window boarder.
        self.overrideredirect(True)

        # Disables resizing of the widget.
        self.resizable(False, False)

        # Places window above all other windows in the window stack.
        self.wm_attributes("-topmost", True)

        notification_frame = Frame(self)
        notification_frame.pack(expand=True, fill=BOTH, padx=padx, pady=pady)

        top_row = Frame(notification_frame)
        top_row.pack(fill=X)

        if not hasattr(notification_manager, "_close_icon"):
            notification_manager._close_icon = PhotoImage(
                data=
                "R0lGODlhEAAQAPeQAIsAAI0AAI4AAI8AAJIAAJUAAJQCApkAAJoAAJ4AAJkJCaAAAKYAAKcAAKcCAKcDA6cGAKgAAKsAAKsCAKwAAK0AAK8AAK4CAK8DAqUJAKULAKwLALAAALEAALIAALMAALMDALQAALUAALYAALcEALoAALsAALsCALwAAL8AALkJAL4NAL8NAKoTAKwbAbEQALMVAL0QAL0RAKsREaodHbkQELMsALg2ALk3ALs+ALE2FbgpKbA1Nbc1Nb44N8AAAMIWAMsvAMUgDMcxAKVABb9NBbVJErFYEq1iMrtoMr5kP8BKAMFLAMxKANBBANFCANJFANFEB9JKAMFcANFZANZcANpfAMJUEMZVEc5hAM5pAMluBdRsANR8AM9YOrdERMpIQs1UVMR5WNt8X8VgYMdlZcxtYtx4YNF/btp9eraNf9qXXNCCZsyLeNSLd8SSecySf82kd9qqc9uBgdyBgd+EhN6JgtSIiNuJieGHhOGLg+GKhOKamty1ste4sNO+ueenp+inp+HHrebGrefKuOPTzejWzera1O7b1vLb2/bl4vTu7fbw7ffx7vnz8f///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAJAALAAAAAAQABAAAAjUACEJHEiwYEEABniQKfNFgQCDkATQwAMokEU+PQgUFDAjjR09e/LUmUNnh8aBCcCgUeRmzBkzie6EeQBAoAAMXuA8ciRGCaJHfXzUMCAQgYooWN48anTokR8dQk4sELggBhQrU9Q8evSHiJQgLCIIfMDCSZUjhbYuQkLFCRAMAiOQGGLE0CNBcZYmaRIDLqQFGF60eTRoSxc5jwjhACFWIAgMLtgUocJFy5orL0IQRHAiQgsbRZYswbEhBIiCCH6EiJAhAwQMKU5DjHCi9gnZEHMTDAgAOw=="
            )

        close_button = Button(top_row,
                              image=notification_manager._close_icon,
                              highlightthickness=0,
                              borderwidth=0,
                              command=self.close)
        close_button.pack(side=RIGHT, anchor=E)

        self.interior = Frame(notification_frame)
        self.interior.pack(expand=True, fill=BOTH)

        if builder:
            builder(self.interior)

        if background is not None:
            top_row.config(background=background)
            notification_frame.config(background=background)
            self.config(background=background)
            self.interior.config(background=background)
            close_button.config(background=background)

        self.place(x, y, h, v)

    @property
    def x(self):
        return self._offset_x

    @property
    def y(self):
        return self._offset_y

    @property
    def h(self):
        return self._h

    @property
    def v(self):
        return self._v

    def place(self, x, y, h, v):
        ''' The windows overall position on the screen  '''
        self.wm_geometry("{h}{x}{v}{y}".format(x=x, y=y, h=h, v=v))

        self._offset_x = x
        self._offset_y = y
        self._h = h
        self._v = v

    def start_animation(self, easing_function, ticks, duration, start_time=0):
        self._tick = 0
        self._total_ticks = float(ticks)
        self._easing_function = easing_function
        self._duration = duration

        self._interval_time = int(duration * 1000 / self._total_ticks)

        if start_time != 0:
            self.after(int(start_time * 1000), self._animate)
        else:
            self._animate()

    def _animate(self):
        t = self._tick / self._total_ticks
        # This changes the alpha value (How transparent the window should be).
        # It ranges from 0.0 (completely transparent) to 1.0 (completely opaque).
        self.attributes("-alpha", self._easing_function(1 - t))

        self._tick += 1

        if self._tick <= self._total_ticks:
            self.after(self._interval_time, self._animate)
        else:
            self.after(self._interval_time, self.close)

    def close(self):
        self._notification_manager.delete(self)
Пример #56
0
def create_window():

    global my_objects, Variable_CB_0, Variable_CB_1, Variable_CB_2
    global SW, Var_G2, Var_G3, Flag_5
    Flag_5 = 0
    Row = 0
    Column = 0
    Variable_CB_0 = []
    Variable_CB_1 = []
    Variable_CB_2 = []
    SW = Tkinter.Toplevel()
    SW.geometry = ("1000x400")
    SW.wm_title("Select Variable")

    labelframe = LabelFrame(SW, text="Variables")
    labelframe.grid(sticky=W + E, row=0, column=0)
    frame = Frame(labelframe, bd=1)

    my_objects = []
    for i in range(len(List_Variables)):
        my_objects.append(MyClass(i))

    k = 0
    Row = 0
    Column = 0
    for i in List_Variables:
        Var_G = IntVar()
        my_objects[k] = Checkbutton(frame, text=i, variable=Var_G)
        my_objects[k].grid(sticky=W, row=Row, column=Column)
        Column = Column + 1
        if Column > 5:
            Row = Row + 1
            Column = 0
        Variable_CB_0.append(Var_G)
        k = k + 1
    frame.grid(sticky=W, row=0, column=0)

    k = 0
    Row = 0
    Column = 0
    labelframe2 = LabelFrame(SW, text="Genero")
    labelframe2.grid(sticky=W + E, row=1, column=0)
    frame2 = Frame(labelframe2, bd=1)

    my_objects_1 = []
    for i in range(len(List_Gender)):
        my_objects_1.append(MyClass(i))

    Var_G2 = IntVar()
    for i in List_Gender:
        my_objects_1[k] = Radiobutton(frame2, text=i, variable=Var_G2, value=k)
        my_objects_1[k].grid(sticky=W, row=Row, column=Column)
        Column = Column + 1
        if Column > 5:
            Row = Row + 1
            Column = 0
        k = k + 1
    frame2.grid(sticky=W + E, row=0, column=0)

    k = 0
    Row = 0
    Column = 0
    labelframe3 = LabelFrame(SW, text="Parametro")
    labelframe3.grid(sticky=W + E, row=2, column=0)
    frame3 = Frame(labelframe3, bd=1)

    my_objects_2 = []
    for i in range(len(List_Var)):
        my_objects_2.append(MyClass(i))

    Var_G3 = IntVar()
    for i in List_Var:
        my_objects_2[k] = Radiobutton(frame3, text=i, variable=Var_G3, value=k)
        my_objects_2[k].grid(sticky=W, row=Row, column=Column)
        Column = Column + 1
        if Column > 5:
            Row = Row + 1
            Column = 0
        k = k + 1
    frame3.grid(sticky=W + E, row=0, column=0)

    labelframe4 = LabelFrame(SW, text="Opciones")
    labelframe4.grid(sticky=W, row=3, column=0)
    frame4 = Frame(labelframe4, bd=1)

    B_0 = Tkinter.Button(frame4, text="Cerrar", command=Close)
    B_1 = Tkinter.Button(frame4, text="Var_1 ", command=Toggle_0)
    B_2 = Tkinter.Button(frame4, text="Var_2 ", command=Toggle_1)
    B_3 = Tkinter.Button(frame4, text="Var_3 ", command=Toggle_2)
    B_4 = Tkinter.Button(frame4, text="Leyenda", command=Leyenda)

    k = 0
    for i in [B_0, B_1, B_2, B_3, B_4]:
        i.grid(row=0, column=k, padx=5)
        k = k + 1
    frame4.grid(sticky=W + E, row=0, column=0)
    SW.mainloop()
Пример #57
0
    def __init__(self, master, bordercolor=None, borderleft=0, bordertop=0, borderright=0, borderbottom=0, interiorwidget=Frame, **kwargs):
        Frame.__init__(self, master, background=bordercolor, bd=0, highlightthickness=0)

        self.interior = interiorwidget(self, **kwargs)
        self.interior.pack(padx=(borderleft, borderright), pady=(bordertop, borderbottom))
Пример #58
0
    def __init__(self,
                 notification_manager,
                 builder,
                 index,
                 x,
                 y,
                 h,
                 v,
                 padx,
                 pady,
                 background=None,
                 on_hide=None):
        Toplevel.__init__(self)

        self._notification_manager = notification_manager

        self.index = index
        self.on_hide = on_hide

        # Removes the native window boarder.
        self.overrideredirect(True)

        # Disables resizing of the widget.
        self.resizable(False, False)

        # Places window above all other windows in the window stack.
        self.wm_attributes("-topmost", True)

        notification_frame = Frame(self)
        notification_frame.pack(expand=True, fill=BOTH, padx=padx, pady=pady)

        top_row = Frame(notification_frame)
        top_row.pack(fill=X)

        if not hasattr(notification_manager, "_close_icon"):
            notification_manager._close_icon = PhotoImage(
                data=
                "R0lGODlhEAAQAPeQAIsAAI0AAI4AAI8AAJIAAJUAAJQCApkAAJoAAJ4AAJkJCaAAAKYAAKcAAKcCAKcDA6cGAKgAAKsAAKsCAKwAAK0AAK8AAK4CAK8DAqUJAKULAKwLALAAALEAALIAALMAALMDALQAALUAALYAALcEALoAALsAALsCALwAAL8AALkJAL4NAL8NAKoTAKwbAbEQALMVAL0QAL0RAKsREaodHbkQELMsALg2ALk3ALs+ALE2FbgpKbA1Nbc1Nb44N8AAAMIWAMsvAMUgDMcxAKVABb9NBbVJErFYEq1iMrtoMr5kP8BKAMFLAMxKANBBANFCANJFANFEB9JKAMFcANFZANZcANpfAMJUEMZVEc5hAM5pAMluBdRsANR8AM9YOrdERMpIQs1UVMR5WNt8X8VgYMdlZcxtYtx4YNF/btp9eraNf9qXXNCCZsyLeNSLd8SSecySf82kd9qqc9uBgdyBgd+EhN6JgtSIiNuJieGHhOGLg+GKhOKamty1ste4sNO+ueenp+inp+HHrebGrefKuOPTzejWzera1O7b1vLb2/bl4vTu7fbw7ffx7vnz8f///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAJAALAAAAAAQABAAAAjUACEJHEiwYEEABniQKfNFgQCDkATQwAMokEU+PQgUFDAjjR09e/LUmUNnh8aBCcCgUeRmzBkzie6EeQBAoAAMXuA8ciRGCaJHfXzUMCAQgYooWN48anTokR8dQk4sELggBhQrU9Q8evSHiJQgLCIIfMDCSZUjhbYuQkLFCRAMAiOQGGLE0CNBcZYmaRIDLqQFGF60eTRoSxc5jwjhACFWIAgMLtgUocJFy5orL0IQRHAiQgsbRZYswbEhBIiCCH6EiJAhAwQMKU5DjHCi9gnZEHMTDAgAOw=="
            )

        close_button = Button(top_row,
                              image=notification_manager._close_icon,
                              highlightthickness=0,
                              borderwidth=0,
                              command=self.close)
        close_button.pack(side=RIGHT, anchor=E)

        self.interior = Frame(notification_frame)
        self.interior.pack(expand=True, fill=BOTH)

        if builder:
            builder(self.interior)

        if background is not None:
            top_row.config(background=background)
            notification_frame.config(background=background)
            self.config(background=background)
            self.interior.config(background=background)
            close_button.config(background=background)

        self.place(x, y, h, v)
# -*- coding: utf-8 -*-
from Tkinter import Tk, Frame, Canvas, Label, Button, Entry, END
import time, random

if __name__ == '__main__':
    window = Tk()
    window.title("Una ventana de prueba")

    frame = Frame(window)
    frame.pack()

    canvas = Canvas(frame, width=500, height=200, bg="green")
    id1 = canvas.create_oval(50, 20, 70, 40, fill="white")
    id2 = canvas.create_rectangle(100, 100, 125, 125, fill="red")
    canvas.pack()

    def click(event):
        print "raton en", event.x, event.y
        colors = ["green", "yellow", "red", "black", "white"]
        canvas.itemconfigure(id2,
                             fill=colors[random.randint(0,
                                                        len(colors) - 1)])
        o = canvas.coords(id1)
        print "origin", o, type(o)
        r = o[0:2] + map(lambda x: x + 4, o[-2:])
        print "result", r, type(r)
        canvas.coords(id1, r[0], r[1], r[2], r[3])

    canvas.bind("<Button-1>", click)

    def ejecucion_boton():
Пример #60
0
def getFrame(parent):
    frame = Frame(parent)
    frame["background"] = rootColor    # unclicked background
    frame["borderwidth"] = 0
    frame.grid(padx=5, pady=5, sticky=W) # padding
    return frame