def DataGrid(xValues, yValues):
    ## setup window
    dataGrid = Tk()
    dataGrid.wm_title("Data")

    ## setup frame
    frame = Frame(dataGrid)
    frame.pack()

    label = Label(dataGrid, text=("Showing %.0f data points" % len(xValues)), font=("Verdana", 12))
    label.pack(pady=5, padx=10)

    dataDict = {}

    ## iterate through time
    for i in range(0, len(xValues)):
        xVal = "%.2f" % float(xValues[i])
        yVal = "%.2f" % float(yValues[i])
        dataDict[xVal] = {"Time (s)": xVal, "Height (m)": yVal}

    model = TableModel()
    model.importDict(dataDict)
    model.moveColumn(model.getColumnIndex("Time (s)"), 0)

    table = TableCanvas(frame, model=model, editable=False)
    table.createTableFrame()

    ## order by time
    table.sortTable(columnName="Time (s)")

    dataGrid.mainloop()
Пример #2
0
def demo2(root):
    frame = Frame(root)
    frame.pack()
    model = TableModel()
    model.importDict(data)
    table = TableCanvas(frame, model=model)
    table.createTableFrame()
Пример #3
0
    def quitarListado(self,numero):
        voluntario = self.selectTable.model.getRecordAtRow(numero)
        modelNuevo = TableModel()

        modelNuevo.addColumn("nombre")
        modelNuevo.addColumn("apellidos")
        modelNuevo.addColumn("dni")
        modelNuevo.addColumn("direccion")
        modelNuevo.addColumn("correo_electronico")
        modelNuevo.addColumn("estudio")
        modelNuevo.addColumn("parroquial")
        modelNuevo.addColumn("proyecto")
        modelNuevo.addColumn("genero")
        modelNuevo.addColumn("fecha_nacimiento")
        modelNuevo.addColumn("telefono_1")
        modelNuevo.addColumn("telefono_2")

        print numero

        arrayListado = self.selectTable.getModel().data
        valores = {}
        i=1
        for values in arrayListado:
            if numero+1 != i:
                valores['row',i]=arrayListado['row',i]
            i+=1
        modelNuevo.importDict(valores)

        self.selectTable.updateModel(modelNuevo)
        self.selectTable.redrawTable()
def CreateTable(Main, Data):
    
    tframe = tk.Frame(Main,
                      bg ="blue",
                      highlightcolor = "blue") 
    tframe.place(x = 50, y =275,
                 height = 275, width =1100)
    
    rec, col = Data.shape
    aux = dict()
    data = dict()
    
    for i in range(rec):
        for j in range(col):
            aux [Data.columns[j]] = Data.values[i,j]
        data['rec'+str(i+1)] = aux.copy()
    
    model = TableModel()    
    table = TableCanvas(tframe, cellbackgr='white', 
    			thefont=('Arial',12, ), cellwidth = 100 ,
                rowheight=25, rowheaderwidth=30,
    			rowselectedcolor='yellow', editable=False,
                model = model)
    table.createTableFrame()
    model = table.model
    model.importDict(data)

    table.show()
    return table, model
Пример #5
0
def DataGrid(xValues, yValues):
    ## setup window
    dataGrid = Tk()
    dataGrid.wm_title("Data")

    ## setup frame
    frame = Frame(dataGrid)
    frame.pack()

    label = Label(dataGrid,
                  text=("Showing %.0f data points" % len(xValues)),
                  font=("Verdana", 12))
    label.pack(pady=5, padx=10)

    dataDict = {}

    ## iterate through time
    for i in range(0, len(xValues)):
        xVal = ("%.2f" % float(xValues[i]))
        yVal = ("%.2f" % float(yValues[i]))
        dataDict[xVal] = {"Time (s)": xVal, "Height (m)": yVal}

    model = TableModel()
    model.importDict(dataDict)
    model.moveColumn(model.getColumnIndex('Time (s)'), 0)

    table = TableCanvas(frame, model=model, editable=False)
    table.createTableFrame()

    ## order by time
    table.sortTable(columnName='Time (s)')

    dataGrid.mainloop()
Пример #6
0
def MenuAssignments():
    AssignmentsWindow = tk.Toplevel(window)
    AssignmentsWindow.title("Replenisher Assignments") 
    AssignmentsWindow.geometry('800x500')
    
    UserList = [
    "User Selection", 
    "User1",
    "User2",
    "User3" 
    ] 
    UserVariable = StringVar(AssignmentsWindow)
    UserVariable.set(UserList[0]) # default value 
    UserOptionMenu = tk.OptionMenu(AssignmentsWindow, UserVariable, *UserList)
    UserOptionMenu.pack()
    
    TaskList = [
    "Task Selection", 
    "Task1",
    "Task2",
    "Task3" 
    ] 
    TaskVariable = StringVar(AssignmentsWindow)
    TaskVariable.set(TaskList[0]) # default value 
    TaskOptionMenu = tk.OptionMenu(AssignmentsWindow, TaskVariable, *TaskList)
    TaskOptionMenu.pack()    
    
    def AddUserTask():
        tkMessageBox.showinfo('Add User and Task', "Added User: "******";  " + "Added Task: " + TaskVariable.get() )  
    
    AddUserTaskBT = tk.Button(AssignmentsWindow, text="Add User and Task", command=AddUserTask)
    AddUserTaskBT.pack()
    
    #Add a table 
    '''
    RowNum = 2
    ColNum = 2
    for i in range(RowNum): 
        for j in range(ColNum): 
            b = tk.Entry(AssignmentsWindow, text="")
            b.grid(row=i, column=j)
            b.pack()
    '''
    
    #To use tkintertable  
    tframe = tk.Frame(AssignmentsWindow)
    tframe.pack()  
    model = TableModel()
    table = TableCanvas(tframe, model=model)
    table.createTableFrame()
    
    model = table.model
    data = {'rec1': {'User': '******', 'Task': 'Task1', 'Status': 'Open', 'Rank': 1, 'Priority': 'High', 'Start Time': '05-19-2018 10:30', 'Finish Time': ''},  
            'rec2': {'User': '******', 'Task': 'Task2', 'Status': 'Open', 'Rank': 2, 'Priority': 'Low', 'Start Time': '05-19-2018 11:30', 'Finish Time': '05-19-2018 22:30'},
            'rec3': {'User': '******', 'Task': 'Task3', 'Status': 'Open', 'Rank': 3, 'Priority': 'Low', 'Start Time': '05-19-2018 12:30', 'Finish Time': '05-19-2018 22:45'}               
           }  
    model.importDict(data) #Import from a dictionary to populate model
    table.redrawTable()
    
    AssignmentsWindow.mainloop()
  def classify_handler(self):

    # Show Classification waiting window
    wdw = Tkinter.Toplevel()
    wdw.title('Classification Results ' + self.dropdown_value.get())
    Tkinter.Label(wdw, text="Classification in Progress... Please wait", font=("Helvetica", 12), width=50, fg="blue").pack()
    wdw.update()
    wdw.deiconify()
  
    # Predict and load results
    resultModel = TableModel()
    resultDict = speakerclassifier.classify_audio(self.currentFile, self.dropdown_value.get())
    if len(resultDict) > 0 :
      resultModel.importDict(resultDict)
    wdw.destroy()
  
    if len(resultDict) > 0 :
      # Show Classification results in modal table window
      wdw = Tkinter.Toplevel()
      wdw.geometry('350x200+200+200')
      wdw.title('Classification Results ' + self.dropdown_value.get())
      tframe = Tkinter.Frame(wdw)
      tframe.pack()
      
      table = TableCanvas(tframe, model=resultModel, editable=False)
      table.createTableFrame()
      table.sortTable(columnName='Score (%)', reverse=True)
      
      wdw.transient(self.root)
      wdw.grab_set()
      self.root.wait_window(wdw)
    else :
      tkMessageBox.showerror('Classification Results', 'There are currently no users in the System')
Пример #8
0
    def buscar(self,nombre,apellidos):

        modelCompleto = TableModel()
        modelNuevo = TableModel()

        modelNuevo.addColumn("nombre")
        modelNuevo.addColumn("apellidos")
        modelNuevo.addColumn("dni")
        modelNuevo.addColumn("direccion")
        modelNuevo.addColumn("correo_electronico")
        modelNuevo.addColumn("estudio")
        modelNuevo.addColumn("parroquial")
        modelNuevo.addColumn("proyecto")
        modelNuevo.addColumn("genero")
        modelNuevo.addColumn("fecha_nacimiento")
        modelNuevo.addColumn("telefono_1")
        modelNuevo.addColumn("telefono_2")

        self.listilla= queryAllVoluntarios()
        modelCompleto.importDict(self.listilla)
        searchterms = [('nombre', nombre, 'contains', 'AND'),('apellidos', apellidos, 'contains', 'AND')]
        result=modelCompleto.getDict(modelCompleto.columnNames, filters=searchterms)
        modelNuevo.importDict(result)
        self.listadoSeleccionado = result
        self.table.updateModel(modelNuevo)
        self.table.redrawTable()
Пример #9
0
def demo3(root):
    frame = Frame(root)
    frame.pack()
    model = TableModel()
    model.importDict(data)
    table = TableCanvas(frame, model=model)
    table.createTableFrame()
    table.model.data['rec2']['col2'] = 50
    table.redrawTable()
Пример #10
0
    def _drawMe(self,dir,openColumn):
       model = TableModel()
       for c in self.items.columnNames:
          model.addColumn(c)
       model.importDict(self.items.columnValues)

       self.table = ActionableTableCanvas(self, model=model, rowheaderwidth=140, showkeynamesinheader=True,height=125,openColumn=openColumn,dir=dir)
       self.table.updateModel(model)
       self.table.createTableFrame()
Пример #11
0
    def _drawMe(self):
       model = TableModel()
       for c in  self.items.getColumnNames(self.section):
          model.addColumn(c)
       model.importDict(self.items.toColumns(self.section))

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

       self.table = ActionableTableCanvas(self, model=model, rowheaderwidth=140, showkeynamesinheader=True,height=125)
       self.table.updateModel(model)
       self.table.createTableFrame()
Пример #12
0
def demo4(root):
    frame = Frame(root)
    frame.pack()
    model = TableModel()
    model.importDict(data)
    table = TableCanvas(frame,
                        model=model,
                        rowheaderwidth=0,
                        cellwidth=150,
                        rowheight=20,
                        editable=False,
                        rowselectedcolor='red',
                        reverseorder=1)
    table.createTableFrame()
Пример #13
0
 def importData(self, dataImport):
     data = dataImport
     model = TableModel()
     model.importDict(data)
     f = Frame(self.main)
     self.table = TableCanvas(f,
                              model,
                              cellwidth=60,
                              cellbackgr='white',
                              thefont=('Arial', 12),
                              rowheight=25,
                              rowheaderwidth=30,
                              rowselectedcolor='yellow',
                              editable=True)
     self.table.createTableFrame()
     self.table.show()
     f.grid(row=0, column=1, sticky="nsew")
Пример #14
0
def viewFreqOutput(event):
    top = Toplevel()
    analysis = {}
    f = open("frequency_output.txt")
    for line in f:
        record = {}
        tokens = line.rstrip('\n').split(' ')
        if tokens[0] not in analysis:
            record["Label"] = tokens[0]
            record["Frequency"] = tokens[1]
            analysis[tokens[0]] = record
    # print(analysis)
    model = TableModel()
    model.importDict(analysis)
    table = TableCanvas(top, model=model)
    table.createTableFrame()
    top.mainloop()
Пример #15
0
def MenuTask():
    TaskWindow = tk.Toplevel(window)
    TaskWindow.title("Add New Tasks") 
    TaskWindow.geometry('800x500')
    
    TaskList = [
    "Add Task"
    ] 
    TaskVariable = StringVar(TaskWindow)
    TaskVariable.set(TaskList[0]) # default value 
    TaskOptionMenu = tk.OptionMenu(TaskWindow, TaskVariable, *TaskList)
    TaskOptionMenu.pack()    
    
    def AddTask():
        tkMessageBox.showinfo('WLabs Replenisher', 'Successfully Add New Task')  
    
    AddTaskBT = tk.Button(TaskWindow, text="Add Task", command=AddTask)
    AddTaskBT.pack()
    
    #To use tkintertable  
    tframe = tk.Frame(TaskWindow)
    tframe.pack()  
    model = TableModel()
    table = TableCanvas(tframe, model=model)
    table.createTableFrame()
    
    model = table.model
    data = {'rec1': {'ID': 'Task1', 'Priority': 'High' },  
            'rec2': {'ID': 'Task2', 'Priority': 'Low'  },
            'rec3': {'ID': 'Task3', 'Priority': 'Low'  }               
           }  
    model.importDict(data) #Import from a dictionary to populate model
    table.redrawTable()
    
    #Add New Row button
    def AddRowButton():
        table.addRow() 
        table.redrawTable() 
    
    AddRowBTN = tk.Button(TaskWindow,text='Add New Row', command = AddRowButton)
    AddRowBTN.place(relx=0.9, rely=0.15, anchor=tk.CENTER)      
        
    TaskWindow.mainloop()
Пример #16
0
def MenuUser():
    UserWindow = tk.Toplevel(window)
    UserWindow.title("Add New User") 
    UserWindow.geometry('800x500')
    
    UserList = [
    "Add User"
    ] 
    UserVariable = StringVar(UserWindow)
    UserVariable.set(UserList[0]) # default value 
    UserOptionMenu = tk.OptionMenu(UserWindow, UserVariable, *UserList)
    UserOptionMenu.pack()
        
    def AddUser():
        tkMessageBox.showinfo('WLabs Replenisher', 'Successfully Add New User')  
    
    AddUserBT = tk.Button(UserWindow, text="Add User", command=AddUser)
    AddUserBT.pack()
    
    #To use tkintertable  
    tframe = tk.Frame(UserWindow)
    tframe.pack()  
    model = TableModel()
    table = TableCanvas(tframe, model=model)
    table.createTableFrame()
    
    model = table.model
    data = {'rec1': {'ID': 'User1', 'First Name': 'Tom', 'Last Name': 'Cross' },  
            'rec2': {'ID': 'User2', 'First Name': 'Jim', 'Last Name': 'Wood' },
            'rec3': {'ID': 'User3', 'First Name': 'Bryan', 'Last Name': 'Bush' }               
           }  
    model.importDict(data) #Import from a dictionary to populate model
    table.redrawTable()

    #Add New Row button
    def AddRowButton():
        table.addRow() 
        table.redrawTable() 
    
    AddRowBTN = tk.Button(UserWindow,text='Add New Row', command = AddRowButton)
    AddRowBTN.place(relx=0.9, rely=0.15, anchor=tk.CENTER)     
    
    UserWindow.mainloop()
Пример #17
0
    def classify_handler(self):

        # Show Classification waiting window
        wdw = Tkinter.Toplevel()
        wdw.title('Classification Results ' + self.dropdown_value.get())
        Tkinter.Label(wdw,
                      text="Classification in Progress... Please wait",
                      font=("Helvetica", 12),
                      width=50,
                      fg="blue").pack()
        wdw.update()
        wdw.deiconify()

        # Predict and load results
        resultModel = TableModel()
        resultDict = speakerclassifier.classify_audio(
            self.currentFile, self.dropdown_value.get())
        if len(resultDict) > 0:
            resultModel.importDict(resultDict)
        wdw.destroy()

        if len(resultDict) > 0:
            # Show Classification results in modal table window
            wdw = Tkinter.Toplevel()
            wdw.geometry('350x200+200+200')
            wdw.title('Classification Results ' + self.dropdown_value.get())
            tframe = Tkinter.Frame(wdw)
            tframe.pack()

            table = TableCanvas(tframe, model=resultModel, editable=False)
            table.createTableFrame()
            table.sortTable(columnName='Score (%)', reverse=True)

            wdw.transient(self.root)
            wdw.grab_set()
            self.root.wait_window(wdw)
        else:
            tkMessageBox.showerror(
                'Classification Results',
                'There are currently no users in the System')
Пример #18
0
def populateData(type):
    top = Toplevel()
    analysis = {}
    if type == "LDA":
        with open("./analysis/LDA_output.txt") as f:
            next(f)
            index = 0
            for line in f:
                tokens = line.rstrip('\n').split(':')
                topicWords = tokens[1].split('+')
                print(topicWords)
                for w in topicWords:
                    record = {}
                    tw = w.split('*')
                    record["Topic ID"] = tokens[0]
                    record["Probability"] = tw[0]
                    word = tw[1].replace('"', '').replace('"', '')
                    record["Word"] = word
                    analysis[index] = record
                    index = index + 1
    else:
        with open("./analysis/LSI_output.txt") as f:
            next(f)
            index = 0
            for line in f:
                record = {}
                tokens = line.rstrip('\n').split(':')
                record["Document Name"] = tokens[0]
                record["Document ID"] = tokens[1]
                record["Probability"] = tokens[2]
                analysis[index] = record
                index = index + 1
    model = TableModel()
    model.importDict(analysis)
    table = TableCanvas(top, model=model)
    table.createTableFrame()
    top.mainloop()
Пример #19
0
def submit(*value):
    print('_____________________________________________________________')

    model = TableModel()
    # load data
    data = load_data(name, value)
    # import data to tablemodel
    model.importDict(data)

    # Create table for records preview
    table = TableCanvas(recordsFrame,
                        name="tablica",
                        model=model,
                        width=420,
                        height=600,
                        cols=0,
                        rows=0,
                        cellwidth=50,
                        editable=False,
                        showkeynamesinheader=True,
                        reverseorder=0)
    table.grid(row=0, sticky=W + N + S)
    table.createTableFrame()
    table.redrawTable()
Пример #20
0
def startWindow():
	StartWindow = tk.Tk()
	StartWindow.title(programTitle)

	StartWindow.tk.call('wm', 'iconphoto', StartWindow._w, tk.PhotoImage(file=programIcon))

	AuxLabel1 = tk.Label(StartWindow,
						text=None)

	StartLabel = tk.Label(StartWindow,
							text="Main menu",
							font="Calibri 14")

	MainPacientLabel = tk.Label(StartWindow,
								text="The pacient is " + pacientName,
								font="Calibri 10")

	TableFrameStart = tk.Frame(StartWindow)

	#tabela = tk.Label(StartWindow,
	#					text="A tabela fica aqui!",
	#					bg="gray")

	#grafico = tk.Label(StartWindow,
	#					text="O grafico fica aqui!",
	#					bg="gray")
	
	AuxLabel1.pack(side=tk.TOP, pady=5)
	StartLabel.pack(side=tk.TOP, padx=100, pady=10)
	MainPacientLabel.pack(side=tk.TOP)

	#tabela.pack(side=tk.LEFT, padx=25, pady=25, ipadx=200, ipady=200)
	TableFrameStart.pack(side=tk.LEFT)
	#grafico.pack(side=tk.RIGHT, padx=25, pady=25, ipadx=200, ipady=200)

	data = {
		'r1':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r2':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r3':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r4':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r5':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r6':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r7':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r8':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r9':  {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r10': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r11': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
    	'r12': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0}
    }

	TableModelStart = TableModel()

	TableStart = TableCanvas(TableFrameStart,
							model=TableModelStart,
							cellwidth=120,
							columnheight=40,
							editable=False
							)
	TableModelStart.importDict(data)
	TableStart.setSelectedRow(-1)
	TableStart.show()

	#Changing values
	TableModelStart.setValueAt(5, 0, 0)
	TableStart.redrawTable()

	#Ploting a graph in the interface
	a.plot(vectorx,vectory)
	a.set_xlabel('X axis')
	a.set_ylabel('Y axis')
	canvas = FigureCanvasTkAgg(f, master= StartWindow)
	canvas.draw()
	canvas.get_tk_widget().pack(side = tk.RIGHT, expand = False, ipadx=2, ipady=2, padx=25, pady=25)

	#Calls the function to pdate the graph
	ani = animation.FuncAnimation(f, animate, interval=100, blit=False)	
	StartWindow.mainloop()
Пример #21
0
def BuildUI():
    root = Tk()

    #Get pc screen dimensions
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()

    #Width and height of GUI
    uiWidth = 1200
    uiHeight = 600

    sizex = uiWidth
    sizey = uiHeight

    #position of GUI on screen
    posx = (screen_width / 2) - uiWidth / 2
    posy = (screen_height / 2) - uiHeight / 2

    root.Enterbutton = Button(root, text="Enter", command=Enterwork)
    #root.Enterbutton.pack()

    root.wm_geometry("%dx%d+%d+%d" % (sizex, sizey, posx, posy))

    frame = LabelFrame(root)
    frame.grid(row=2, column=0, padx=10, pady=10)
    #frame.pack(fill = "both", expand="false", pady=50, padx=50,)

    #Make a listbox with names
    itemsforcode = []
    dates = []

    cursor.execute("select * from TijdVerantwoording")

    for row in cursor.fetchall():
        itemsforcode.append([row.Opmerking, row.Datum, row.Duur])

    cal = Calendar(font='Arial 14',
                   selecmode='day',
                   cursor="hand1",
                   year=2019,
                   month=1,
                   day=1)
    cal.grid(row=0, column=0, padx=10, pady=10)

    def datesel():
        print(cal.selection_get())

    dateselbut = ttk.Button(text="Select Date", command=datesel)
    dateselbut.grid(row=1, column=0)

    def set_textstart(text):
        entry1.delete(0, END)
        entry1.insert(0, text)
        tester = entry1.get()
        #print("test",tester)
        #print("type",type(tester))
        return

    def set_textend(text):
        entry2.delete(0, END)
        entry2.insert(0, text)
        return

    entry1 = tk.Entry(root, width=20)
    entry2 = tk.Entry(root, width=20)
    entry1.grid(row=0, column=1)
    entry2.grid(row=1, column=1)

    entry1.insert(0, "1-1-2019")
    entry2.insert(0, "1-5-2019")

    ButtonStartDate = Button(
        root,
        text="Start Date",
        command=lambda: set_textstart(cal.selection_get()))
    ButtonStartDate.grid(row=0, column=2)

    ButtonEndDate = Button(root,
                           text="End Date",
                           command=lambda: set_textend(cal.selection_get()))
    ButtonEndDate.grid(row=1, column=2)

    mycanvas = Canvas(frame, width=850, height=300, bg='red')
    mycanvas.pack(side=LEFT)

    yscrollbar = ttk.Scrollbar(frame,
                               orient="vertical",
                               command=mycanvas.yview)
    yscrollbar.pack(side=RIGHT, fill="y")

    mycanvas.configure(yscrollcommand=yscrollbar.set)
    mycanvas.bind(
        '<Configure>',
        lambda e: mycanvas.configure(scrollregion=mycanvas.bbox('all')))

    myframe = Frame(mycanvas)
    mycanvas.create_window((0, 0), window=myframe, anchor="n")

    #width = header column width
    ex = Excel(myframe, rows=100, columns=5, width=20)

    start_date = datetime.strptime(entry1.get(), '%d-%m-%Y')
    end_date = datetime.strptime(entry2.get(), '%d-%m-%Y')

    length = len(itemsforcode)

    for i in range(length):
        dates.append(itemsforcode[i][1])

    data = {
        'Record': {
            'Opmerking': itemsforcode[2][0],
            'Datum': str(itemsforcode[2][1]),
            'Aantal Uur': itemsforcode[2][2]
        },
    }

    testdata = {'Record': {'Column1': 'this is entry 1'}}

    tframe = Frame(root)
    tframe.grid(column=0, row=1)
    model = TableModel()
    model.importDict(testdata)

    table = TableCanvas(tframe,
                        model,
                        cellwidth=100,
                        cellbackgr='#e3f698',
                        thefont=('Arial', 12),
                        rowheight=25,
                        rowheaderwidth=100,
                        rowselectedcolor='yellow',
                        editable=True)
    table.show()

    #table.addRow(keyname,label=itemsforcode[0][0])
    #table.addRow(label=itemsforcode[0][1])
    #table = TableCanvas(frame, model=model,
    #		cellwidth=60, cellbackgr='#e3f698',
    #		thefont=('Arial',12),rowheight=18, rowheaderwidth=30,
    #		rowselectedcolor='yellow', editable=True)
    #table.show()

    #table = TableCanvas(tframe, model, cellwidth=60, cellbackgr='#e3f698',
    #	thefont=('Arial',12),rowheight=18,rowheaderwidth=3,
    #	rowselectedcolor='blue',editable=True)

    # for x in range(1000):
    #     if dates[x] >= start_date and dates[x] <= end_date:
    #         ex.make_entry(row=x, column=1, width=40, state = 'normal', text=itemsforcode[x][0])
    #         ex.make_entry(row=x, column=2, width=20, state = 'normal', text=itemsforcode[x][1])
    #         ex.make_entry(row=x, column=3, width=20, state = 'normal', text=itemsforcode[x][2])

    #     ex.pack(padx=10, pady=10)

    def redCircle():
        pass

    def yelCircle():
        root.update()

    #Right Frame and its contents
    rightFrame = LabelFrame(root, width=800, height=600)
    rightFrame.grid(row=5, column=0, padx=10, pady=10)

    btnFrame = LabelFrame(rightFrame, width=100, height=100)
    btnFrame.grid(row=5, column=0, padx=10, pady=2)

    redBtn = Button(btnFrame, text="Red", command=redCircle)
    redBtn.grid(row=5, column=0, padx=10, pady=2)

    yellowBtn = Button(btnFrame, text="Yellow", command=yelCircle)
    yellowBtn.grid(row=5, column=0, padx=10, pady=2)

    return
Пример #22
0
# tmodel.importDict(data)

table = TableCanvas(tframe,
                    tmodel,
                    cellwidth=140,
                    cellbackgr='#CCCCCC',
                    height=610,
                    width=1170,
                    col_positions=['col2', 'col1', 'label'],
                    thefont=('微软雅黑', 10),
                    rowheight=18,
                    rowheaderwidth=-5,
                    rows=30,
                    cols=30,
                    selectedcolor='#CCCCCC',
                    rowselectedcolor='#CCCCCC',
                    multipleselectioncolor='#FFCCCC',
                    autoresizecols=1,
                    read_only=0,
                    entrybackgr='#ff0000',
                    grid_color='#222222')
table.show()

# initialization
tmodel.columnNames.clear()
tmodel.data.clear()
tmodel.importDict({0: {'点击查询按钮查询': None}})
table.redraw()

w.mainloop()
class ResultSearchTab(Frame):
    def __init__(self, frame):

        #CARACTERÍSTICAS DEL PANEL
        width = frame.cget("width") * 3 / 5
        height = frame.cget("height")
        bgcolor1 = "#%02x%02x%02x" % (157, 168, 244)
        super().__init__(frame,
                         bg=bgcolor1,
                         highlightthickness=1,
                         highlightbackground="black")

        #TITULO DE VENTANA
        Label(self,
              text="DATOS DEL VEHÍCULO",
              font=("Verdana", 14, "bold"),
              bg=bgcolor1).place(relx=0.35, rely=0.04)

        #PANEL DE DATOS DEL VEHÍCULO
        dataVehicle = Frame(self, bg=bgcolor1, width=width, height=100)
        dataVehicle.place(relx=0.02, rely=0.1)
        bgcolor2 = "#%02x%02x%02x" % (198, 204, 249)

        Label(dataVehicle,
              text="Dominio",
              width=15,
              bg=bgcolor1,
              relief="groove",
              borderwidth=4,
              font=("Verdana", 11, "italic")).grid(row=1, column=1)
        Label(dataVehicle,
              text="Tipo",
              width=15,
              bg=bgcolor1,
              relief="groove",
              borderwidth=4,
              font=("Verdana", 11, "italic")).grid(row=1, column=3)
        Label(dataVehicle,
              text="N° de Motor",
              width=15,
              bg=bgcolor1,
              relief="groove",
              borderwidth=4,
              font=("Verdana", 11, "italic")).grid(row=1, column=5)
        Label(dataVehicle,
              text="Marca",
              width=15,
              bg=bgcolor1,
              relief="groove",
              borderwidth=4,
              font=("Verdana", 11, "italic")).grid(row=2, column=1)
        Label(dataVehicle,
              text="Modelo",
              width=15,
              bg=bgcolor1,
              relief="groove",
              borderwidth=4,
              font=("Verdana", 11, "italic")).grid(row=2, column=3)
        Label(dataVehicle,
              text="Año",
              width=15,
              bg=bgcolor1,
              relief="groove",
              borderwidth=4,
              font=("Verdana", 11, "italic")).grid(row=2, column=5)
        Label(dataVehicle,
              text="Titular",
              width=15,
              bg=bgcolor1,
              relief="groove",
              borderwidth=4,
              font=("Verdana", 11, "italic")).grid(row=3, column=1)
        Label(dataVehicle,
              text="DNI",
              width=15,
              bg=bgcolor1,
              relief="groove",
              borderwidth=4,
              font=("Verdana", 11, "italic")).grid(row=3, column=5)

        #DOMINIO
        self.domainLabel = Label(dataVehicle,
                                 font=("Verdana", 12, "italic"),
                                 width=15,
                                 bg=bgcolor2)
        self.domainLabel.grid(row=1, column=2)

        #TIPO DE VEHÍCULO
        self.kindLabel = Label(dataVehicle,
                               font=("Verdana", 12, "italic"),
                               width=15,
                               bg=bgcolor2)
        self.kindLabel.grid(row=1, column=4)

        #NÚMERO DE MOTOR
        self.engineLabel = Label(dataVehicle,
                                 font=("Verdana", 12, "italic"),
                                 width=20,
                                 bg=bgcolor2)
        self.engineLabel.grid(row=1, column=6)

        #MARCA
        self.brandLabel = Label(dataVehicle,
                                font=("Verdana", 12, "italic"),
                                width=15,
                                bg=bgcolor2)
        self.brandLabel.grid(row=2, column=2)

        #MODELO
        self.modelLabel = Label(dataVehicle,
                                font=("Verdana", 12, "italic"),
                                width=15,
                                bg=bgcolor2)
        self.modelLabel.grid(row=2, column=4)

        #AÑO
        self.yearLabel = Label(dataVehicle,
                               font=("Verdana", 12, "italic"),
                               width=20,
                               bg=bgcolor2)
        self.yearLabel.grid(row=2, column=6)

        #TITULAR
        self.titularLabel = Label(dataVehicle,
                                  font=("Verdana", 12, "italic"),
                                  anchor="w",
                                  width=45,
                                  bg=bgcolor2)
        self.titularLabel.grid(row=3, column=2, columnspan=3)

        #DNI DEL TITULAR
        self.dniLabel = Label(dataVehicle,
                              font=("Verdana", 12, "italic"),
                              width=20,
                              bg=bgcolor2)
        self.dniLabel.grid(row=3, column=6)

        #CREA TABLA DE INFRACCIONES
        self.tableFrame = Frame(self)
        self.model = TableModel()
        self.model.addColumn(colname="ID")
        self.model.columnwidths["ID"] = 80
        self.model.addColumn(colname="DNI RESPONSABLE")
        self.model.columnwidths["DNI RESPONSABLE"] = 90
        self.model.addColumn(colname="CAUSA")
        self.model.addColumn(colname="AGENTE")
        self.model.addColumn(colname="FECHA")
        self.model.addColumn(colname="LUGAR")
        self.model.addColumn(colname="MONTO")
        self.model.columnwidths["MONTO"] = 70
        self.model.addColumn(colname="PAGADO")
        self.model.columnwidths["PAGADO"] = 70
        self.infractionsTable = TableCanvas(self.tableFrame,
                                            model=self.model,
                                            width=938,
                                            thefont=("Arial", 10),
                                            read_only=True)
        self.infractionsTable.show()
        self.tableFrame.place(x="20", rely="0.35")

        #CREA MENSAJE DE ESTADO DE CUENTA
        self.message = StringVar()
        self.debtLabel = Label(self,
                               textvariable=self.message,
                               font=("Verdana", 12))
        self.debtLabel.place(x="30", rely="0.30")

    #FUNCIÓN QUE DEVUELVE LA FILA SELECCIONADA
    def getSelectedRow(self):
        return (self.infractionsTable.get_currentRecord())

    #FUNCIÓN QUE CARGA EL PANEL Y LA TABLA DE INFRACCIONES CON LOS DATOS CORRESPONDIENTES
    def showData(self, data):
        self.model.deleteRows()
        dataModel = {}

        if data != None:
            self.domainLabel.configure(text=data[0])
            self.kindLabel.configure(text=data[1])
            self.brandLabel.configure(text=data[2])
            self.modelLabel.configure(text=data[3])
            self.yearLabel.configure(text=data[4])
            self.engineLabel.configure(text=data[5])
            self.titularLabel.configure(text=data[7] + ", " + data[8])
            self.dniLabel.configure(text=data[6])

            infractions = DBManager().getInfractions(data[0])
            self.debt = 0.00
            for infraction in infractions:
                isPay = 'NO'
                if (infraction[8] == 1):
                    isPay = 'SI'
                dateandhour = "%02d-%02d-%4d %02d:%02d" % (
                    infraction[5].day, infraction[5].month, infraction[5].year,
                    infraction[5].hour, infraction[5].minute)
                dateandhourpaid = "-"
                if (infraction[9] != None):
                    dateandhourpaid = "%02d-%02d-%4d %02d:%02d" % (
                        infraction[9].day, infraction[9].month,
                        infraction[9].year, infraction[9].hour,
                        infraction[9].minute)
                dataModel[infraction[0]] = {
                    'ID': "%07d" % (infraction[0]),
                    'DNI RESPONSABLE': str(infraction[1]),
                    'CAUSA': str(infraction[3]),
                    'AGENTE': str(infraction[4]),
                    'FECHA': dateandhour,
                    'LUGAR': str(infraction[6]),
                    'MONTO': "%.2f" % (infraction[7]),
                    'PAGADO': isPay,
                    'FECHA PAGO': dateandhourpaid
                }
                if (infraction[8] == 0):
                    self.debt = self.debt + float(infraction[7])
            if (self.debt > 0):
                self.message.set("Presenta una deuda de $ " + str(self.debt))
            else:
                self.message.set("No presenta deudas.")
        #SI LA BÚSQUEDA NO ARROJA RESULTADOS, LOS CAMPOS SE MUESTRAN EN BLANCO
        else:
            self.domainLabel.configure(text="")
            self.kindLabel.configure(text="")
            self.brandLabel.configure(text="")
            self.modelLabel.configure(text="")
            self.yearLabel.configure(text="")
            self.engineLabel.configure(text="")
            self.titularLabel.configure(text="")
            self.dniLabel.configure(text="")
            self.message.set("")

        #ACTUALIZA EL CONTENIDO DE LA TABLA
        self.model.importDict(dataModel)
        self.infractionsTable.redraw()
        self.infractionsTable.autoResizeColumns()
Пример #24
0
class SalariesCalculator():
    def __init__(self, Salaries):
        date_var1 = tk.StringVar()
        date_var2 = tk.StringVar()
        self.Worker = "Francisco"
        self.window = Salaries
        Date = str(date.today().strftime("%d/%m/%Y"))
        if Date[0:2] <= '15':
            D1 = "01" + Date[2:]
            D2 = "15" + Date[2:]
        else:
            D1 = "16" + Date[2:]
            D2 = Date
        X = 50
        Y = 50

        Lb = tk.Label(self.window,
                      bg='skyblue',
                      font=("Arial", 12),
                      text="De:")
        Lb.place(x=X + 80, y=Y)
        self.Date1 = tk.Entry(self.window,
                              bg='white',
                              font=("Arial", 12),
                              textvariable=date_var1)
        date_var1.set(D1)
        self.Date1.place(x=X + 80, y=Y + 30)

        Lb = tk.Label(self.window,
                      bg='skyblue',
                      font=("Arial", 12),
                      text="Hasta:")
        Lb.place(x=X + 80, y=Y + 60)
        self.Date2 = tk.Entry(self.window,
                              bg='white',
                              font=("Arial", 12),
                              textvariable=date_var2)
        date_var2.set(D2)
        self.Date2.place(x=X + 80, y=Y + 90)

        Lb = tk.Label(self.window,
                      bg='skyblue',
                      font=("Arial", 12),
                      text="Concepto:")
        Lb.place(x=X + 335, y=Y)
        self.Worker_list = tk.Listbox(self.window,
                                      bg='white',
                                      fg='black',
                                      height=3,
                                      selectmode='SINGLE',
                                      width=25,
                                      font=("Arial", 12))
        Workers = ['Francisco', 'Guadalupe', 'Diego']
        for item in Workers:
            self.Worker_list.insert(tk.END, item)
        self.Worker_list.place(x=X + 335, y=Y + 30)
        self.Worker_list.bind("<ButtonRelease-1>", self.update_table)

        ###### Tabla de Salarios ######
        Lb = tk.Label(self.window,
                      bg='skyblue',
                      font=("Arial", 12),
                      text="Salarios:")
        Lb.place(x=X + 663, y=Y)
        Fecha = self.Date1.get()
        Fecha1 = Fecha[6:10] + "-" + Fecha[3:5] + "-" + Fecha[0:2]
        Fecha = self.Date2.get()
        Fecha2 = Fecha[6:10] + "-" + Fecha[3:5] + "-" + Fecha[0:2]
        try:
            SelectQuery = "SELECT Responsable, SUM(Monto) AS Salario FROM Transactions.dbo.Transactions \
                where Concepto = 'Sueldo' and Fecha between '"                                                              + Fecha1 \
                    + "' and '" + Fecha2 + "' GROUP BY Responsable;"
            Data = pd.read_sql(SelectQuery, conn)
        except:
            df = {
                'Responsable': ['Francisco', 'Guadalupe', 'Diego'],
                'Salario': ['', '', '']
            }
            Data = pd.DataFrame(df)

        tframe_sal = tk.Frame(self.window, bg="blue", highlightcolor="blue")
        tframe_sal.place(x=X + 663, y=Y + 30, height=130, width=318)
        rec, col = Data.shape
        aux = dict()
        data = dict()
        for i in range(rec):
            for j in range(col):
                aux[Data.columns[j]] = Data.values[i, j]
            data['rec' + str(i + 1)] = aux.copy()

        self.model_sal = TableModel()
        self.table_sal = TableCanvas(tframe_sal,
                                     cellbackgr='white',
                                     thefont=(
                                         'Arial',
                                         12,
                                     ),
                                     cellwidth=140,
                                     rowheight=25,
                                     rowheaderwidth=30,
                                     rowselectedcolor='yellow',
                                     editable=False,
                                     model=self.model_sal)
        self.table_sal.createTableFrame()
        self.model_sal = self.table_sal.model
        self.model_sal.importDict(data)
        self.table_sal.show()

        ###### Tabla de Actividades ######
        try:
            SelectQuery = "SELECT #, Fecha, Concepto, Monto, Responsable, Comentario FROM Transactions.dbo.Transactions \
                where Concepto = 'Sueldo' and Responsable = '"                                                               + self.Worker + "' and Fecha between '"+ Fecha1 \
                    + "' and '" + Fecha2 + "';"
            Data = pd.read_sql(SelectQuery, conn)
        except:
            df = {
                '#': [''],
                'Fecha': [''],
                'Concepto': [''],
                'Monto': [''],
                'Responsable': [''],
                'Comentario': ['']
            }
            Data = pd.DataFrame(df)

        tframe_act = tk.Frame(self.window, bg="blue", highlightcolor="blue")
        tframe_act.place(x=X + 80, y=Y + 135, height=350, width=900)
        rec, col = Data.shape
        aux = dict()
        data = dict()
        for i in range(rec):
            for j in range(col):
                aux[Data.columns[j]] = Data.values[i, j]
            data['rec' + str(i + 1)] = aux.copy()

        self.model_act = TableModel()
        self.table_act = TableCanvas(tframe_act,
                                     cellbackgr='white',
                                     thefont=(
                                         'Arial',
                                         12,
                                     ),
                                     cellwidth=140,
                                     rowheight=25,
                                     rowheaderwidth=30,
                                     rowselectedcolor='yellow',
                                     editable=False,
                                     model=self.model_act)
        self.table_act.createTableFrame()
        self.model_act = self.table_act.model
        self.model_act.importDict(data)
        self.table_act.show()

    def update_table(self, event):
        widget = event.widget
        selection = widget.curselection()
        self.Worker = widget.get(selection[0])
        Fecha = self.Date1.get()
        Fecha1 = Fecha[6:10] + "-" + Fecha[3:5] + "-" + Fecha[0:2]
        Fecha = self.Date2.get()
        Fecha2 = Fecha[6:10] + "-" + Fecha[3:5] + "-" + Fecha[0:2]

        try:
            SelectQuery = "SELECT #, Fecha, Concepto, Monto, Responsable, Comentario FROM Transactions.dbo.Transactions \
                where Concepto = 'Sueldo' and Responsable = '"                                                               + self.Worker + "' and Fecha between '"+ Fecha1 \
                    + "' and '" + Fecha2 + "';"
            Data = pd.read_sql(SelectQuery, conn)
        except:
            df = {
                '#': [''],
                'Fecha': [''],
                'Concepto': [''],
                'Monto': [''],
                'Responsable': [''],
                'Comentario': ['']
            }
            Data = pd.DataFrame(df)
        rec, col = Data.shape
        aux = dict()
        data = dict()

        for i in range(rec):
            for j in range(col):
                aux[Data.columns[j]] = Data.values[i, j]
            data['rec' + str(i + 1)] = aux.copy()
        self.model_act.deleteRows(range(0, self.model_act.getRowCount()))
        self.model_act.importDict(data)
        self.table_act.redraw()

        try:
            SelectQuery = "SELECT Responsable, SUM(Monto) AS Salario FROM Transactions.dbo.Transactions \
                where Concepto = 'Sueldo' and Fecha between '"                                                              + Fecha1 \
                    + "' and '" + Fecha2 + "' GROUP BY Responsable;"
            Data = pd.read_sql(SelectQuery, conn)
        except:
            df = {
                'Responsable': ['Francisco', 'Guadalupe', 'Diego'],
                'Salario': ['', '', '']
            }
            Data = pd.DataFrame(df)
        rec, col = Data.shape
        aux = dict()
        data = dict()

        for i in range(rec):
            for j in range(col):
                aux[Data.columns[j]] = Data.values[i, j]
            data['rec' + str(i + 1)] = aux.copy()
        self.model_sal.deleteRows(range(0, self.model_sal.getRowCount()))
        self.model_sal.importDict(data)
        self.table_sal.redraw()
Пример #25
0
class RRInterface(Frame):
    today = datetime.datetime.now().date()
    pieces = []

    def __init__(self, master=None):
        Frame.__init__(self, master)
        self.pack()
        self.configure(width=1250, height=500)

        self.frCal = Frame(self)
        self.frCal.place(relx=0, rely=0)
        self.frCal.configure(bd=1, relief=RAISED)
        self.calWidget = tkcalendar.Calendar(self.frCal,
                                             showweeknumbers=False,
                                             locale="ru_RU",
                                             maxdate=self.today)
        self.calWidget.pack()
        self.calWidget.bind('<<CalendarSelected>>', self.getDate)

        self.dayDataFrame = Frame(self)
        self.dayDataFrame.grid_propagate(0)
        self.dayDataFrame.place(relx=0, rely=1, anchor=SW)
        self.dayDataFrame.configure(width=1250,
                                    height=300,
                                    bd=1,
                                    relief=RAISED)

        self.tableModel = TableModel()
        self.table = TableCanvas(self.dayDataFrame,
                                 cellwidth=300,
                                 model=self.tableModel,
                                 rowheight=25)
        self.table.show()

        self.drawFrame = Frame(self)
        self.drawFrame.grid_propagate(0)
        self.drawFrame.place(relx=1, rely=0, anchor=NE)
        self.drawFrame.configure(width=966, height=200, bd=1, relief=RAISED)

        self.createCanvas()

        self.dateList = []
        self.hourUsed = [0 for i in range(24)]

        self.strInfo = StringVar()
        self.labelInfo = Label(self,
                               textvariable=self.strInfo,
                               width=30,
                               height=1,
                               bg='white',
                               bd=1,
                               relief=RAISED,
                               font='Arial 10')
        self.strInfo.set('Test')
        self.labelInfo.place(x=0, y=175)

        self.createFileList()
        self.createTable()
        self.readReportFile(self.today)

    def createCanvas(self):
        self.drawCanvas = Canvas(self.drawFrame, bg='white')
        self.drawCanvas.place(x=0, y=0)
        self.drawCanvas.configure(width=960, height=194)
        for i in range(24):
            self.drawCanvas.create_line((i + 1) * 40,
                                        0, (i + 1) * 40,
                                        180,
                                        fill='black')
            self.drawCanvas.create_text((i + 1) * 40 - 20,
                                        90,
                                        text=str(i),
                                        font="Verdana 14")
        self.drawCanvas.create_line(0, 180, 960, 180, fill='black')

    def getDate(self, event=None):
        date = self.calWidget.selection_get()
        self.readReportFile(date)

    def createFileList(self):
        fileList = glob.glob(reportFolder + "\\*.REP")
        for file in fileList:
            file = file.replace(reportFolder + "\\", "")
            if int(file[1:5]) < 2000:
                continue
            self.dateList.append(
                datetime.date(year=int(file[1:5]),
                              month=monthToInt.get(file[5:8]),
                              day=int(file[8:10])))
        self.dateList.sort()
        if len(self.dateList) > 0:
            self.calWidget.configure(mindate=self.dateList[0])
        else:
            self.calWidget.configure(mindate=datetime.datetime.now())

    def createTable(self):
        data = {
            'def': {
                'Program name': 'test',
                'Start': '00:00:00',
                'End': '23:59:59',
                'Time': '23:59:59',
                'Thickness': 99,
                'Pieces': 999,
                'Produced': 111,
                'Remained': 888,
                'State': 'Ok'
            }
        }
        self.tableModel.importDict(data)
        self.table.resizeColumn(1, 150)
        self.table.resizeColumn(2, 150)
        self.table.resizeColumn(3, 70)
        self.table.resizeColumn(4, 90)
        self.table.resizeColumn(5, 60)
        self.table.resizeColumn(6, 80)
        self.table.resizeColumn(7, 80)

    def readReportFile(self, date):
        # R1970Jan01.REP
        fileName = 'R' + str(date.year) + intToMonth[date.month]
        if date.day < 10:
            fileName = fileName + '0' + str(date.day)
        else:
            fileName = fileName + str(date.day)
        fileName = reportFolder + '\\' + fileName + '.REP'

        self.pieces.clear()
        self.drawCanvas.delete('piece')
        self.tableModel.deleteRows(range(self.tableModel.getRowCount()))
        self.table.redraw()
        if not os.path.exists(fileName):
            self.strInfo.set('File not exist')
            return

        with open(fileName, 'r', encoding="utf-8") as scannedFile:
            fileData = scannedFile.read()
            pieces = fileData.split('\n\n')
            for i in range(len(pieces)):
                lines = pieces[i].split('\n')
                lineDict = {}
                for line in lines:
                    ll = line.replace("\n", "").split('=')
                    if len(ll) < 2:
                        continue
                    lineDict[ll[0]] = ll[1]
                self.pieces.append(
                    PieceData(ID=len(self.pieces),
                              name=lineDict.get('PROGRAM NAME'),
                              start=lineDict.get('START'),
                              end=lineDict.get('END'),
                              time=lineDict.get('MACHINING TIME'),
                              thickness=lineDict.get('WORKPIECE THICKNESS'),
                              pieces=lineDict.get('NUMBER OF PIECES'),
                              produced=lineDict.get('NR OF PIECES PRODUCED'),
                              remained=lineDict.get('NR OF PIECES REMAINING'),
                              state=lineDict.get('STATE'),
                              date=date))
        counter = 0
        while counter < len(self.pieces):
            if self.pieces[counter].programName == '[ERROR]' and self.pieces[
                    counter].id > 0:
                self.pieces.pop(counter)
            else:
                counter += 1
        self.strInfo.set(str(date) + "\t Pieces: " + str(len(self.pieces)))
        self.addDayDataToCanvas()
        self.addDayDataToTable()

    def addDayDataToCanvas(self):
        for i in range(len(self.hourUsed)):
            self.hourUsed[i] = 0

        for piece in self.pieces:
            if piece.programName == '[ERROR]' and piece.id > 0:
                continue
            start = piece.startTime
            end = piece.endTime
            pieceColor = getRandomColor()
            sX = start.hour * 40
            sY = 180 - (start.minute + start.second / 60) * 3
            eX = sX + 40
            eY = 180 - (end.minute + end.second / 60) * 3
            if end.hour != start.hour:
                self.hourUsed[end.hour] += \
                    (end - end.replace(hour=end.hour, minute=0, second=0)).seconds
                currHour = start.hour + 1
                finalHour = end.hour
                if finalHour < currHour:
                    finalHour = 23
                for hH in range(currHour, finalHour):
                    self.drawCanvas.create_rectangle(hH * 40,
                                                     180, (hH + 1) * 40,
                                                     0,
                                                     fill=pieceColor,
                                                     tag="piece")
                    self.hourUsed[hH] += 3600
                tsX = finalHour * 40
                tsY = 180
                teX = tsX + 40
                teY = eY
                eY = 0
                self.drawCanvas.create_rectangle(tsX,
                                                 tsY,
                                                 teX,
                                                 teY,
                                                 fill=pieceColor,
                                                 tag="piece")
                if start.hour < 23:
                    self.hourUsed[start.hour] += (start.replace(
                        hour=start.hour + 1, minute=0, second=0) -
                                                  start).seconds
                else:
                    nextDay = start + datetime.timedelta(seconds=3600)
                    self.hourUsed[start.hour] += (
                        nextDay.replace(hour=0, minute=0, second=0) -
                        start).seconds
            else:
                self.hourUsed[start.hour] += (end - start).seconds

            self.drawCanvas.create_rectangle(sX,
                                             sY,
                                             eX,
                                             eY,
                                             fill=pieceColor,
                                             tag="piece")
        for i in range(24):
            used = toFixed(self.hourUsed[i] / 36, 2)
            tt = self.drawCanvas.create_text(i * 40 + 20,
                                             188,
                                             text=used,
                                             tag="piece")
            if tt > 100000:
                self.drawCanvas.delete('all')
                self.drawCanvas.destroy()
                self.createCanvas()
                self.addDayDataToCanvas()

    def addDayDataToTable(self):
        for piece in self.pieces:
            data = {
                piece.id: {
                    'Program name': piece.programName,
                    'Start': str(piece.startTime),
                    'End': str(piece.endTime),
                    'Time': str(piece.timeTime),
                    'Thickness': piece.thickness,
                    'Pieces': piece.pieces,
                    'Produced': piece.produced,
                    'Remained': piece.remained,
                    'State': piece.state
                }
            }
            self.tableModel.importDict(data)
        self.table.redraw()
Пример #26
0
class VehiclesTab(Frame):
    def __init__(self, notebook):

        super().__init__(notebook,
                         bg="#%02x%02x%02x" % (166, 185, 180),
                         highlightthickness=1,
                         highlightbackground="black")

        #TÍTULO DE LA PESTAÑA
        Label(self,
              text="LISTA DE VEHÍCULOS REGISTRADOS",
              font=("Verdana", 16, "bold"),
              bg="#%02x%02x%02x" % (166, 185, 180)).place(relx="0.05",
                                                          rely="0.05")

        #CREA TABLA DE VEHÍCULOS
        self.tableFrame = Frame(self)
        self.model = TableModel()
        self.model.addColumn(colname="DOMINIO")
        self.model.columnwidths["DOMINIO"] = 90
        self.model.addColumn(colname="TITULAR")
        self.model.columnwidths["TITULAR"] = 90
        self.model.addColumn(colname="TIPO")
        self.model.addColumn(colname="MARCA")
        self.model.addColumn(colname="MODELO")
        self.model.columnwidths["MODELO"] = 90
        self.model.addColumn(colname="AÑO")
        self.model.columnwidths["AÑO"] = 75
        self.model.addColumn(colname="VIN")
        self.model.columnwidths["VIN"] = 200
        self.vehiclesTable = TableCanvas(self.tableFrame,
                                         model=self.model,
                                         width=790,
                                         thefont=("Arial", 10),
                                         read_only=True)
        self.vehiclesTable.show()
        self.tableFrame.place(relx="0.10", rely="0.15")
        self.showVehicles()

        #BOTÓN PARA CERRAR LAS PESTAÑAS DE VEHÍCULO
        Button(self,
               text="Cerrar Menú",
               font=("Verdana", 12),
               command=lambda: self.close(notebook)).place(relx="0.85",
                                                           rely="0.05")

        #BOTÓN PARA AÑADIR REGISTRO
        Button(self,
               text='AÑADIR REGISTRO',
               width=20,
               font=("Verdana", 14),
               command=lambda: notebook.createAddVehicleTab()).place(relx=0.1,
                                                                     rely=0.7)

        #BOTÓN PARA MODIFICAR REGISTRO
        Button(self,
               text='MODIFICAR REGISTRO',
               width=20,
               font=("Verdana", 14),
               command=lambda: notebook.createModifyVehicleTab()).place(
                   relx=0.39, rely=0.7)

        #BOTÓN PARA ELIMINAR REGISTRO
        Button(self,
               text='ELIMINAR REGISTRO',
               width=20,
               font=("Verdana", 14),
               command=lambda: notebook.createDeleteVehicleToplevel()).place(
                   relx=0.68, rely=0.7)

    #FUNCIÓN PARA CARGAR LA TABLE DE VEHÍCULOS
    def showVehicles(self):
        vehicles = DBManager().getAllVehicles()
        self.model.deleteRows()
        dataModel = {}
        for vehicle in vehicles:
            dataModel[vehicle[0]] = {
                'DOMINIO': vehicle[0],
                'TITULAR': vehicle[6],
                'TIPO': vehicle[1],
                'MARCA': vehicle[2],
                'MODELO': vehicle[3],
                'AÑO': str(vehicle[4]),
                'VIN': vehicle[5]
            }
        self.model.importDict(dataModel)
        self.vehiclesTable.redraw()
        #self.vehiclesTable.adjustColumnWidths()

    #DEVUELVE LA FILA SELECCIONADA
    def getSelectedRow(self):
        return (self.vehiclesTable.get_currentRecord())

    #CIERRA EL PANEL ACTUAL Y REALIZA LOS CAMBIOS CORRESPONDIENTES.
    #PARA CERRAR EL PANEL, LOS PANELES DE CREACIÓN, MODIFICACIÓN Y ELIMINACIÓN DEBEN ESTAR CERRADOS
    def close(self, notebook):
        if notebook.addVehicleFlag == 0 and notebook.modifyVehicleFlag == 0 and notebook.deleteVehicleFlag == 0:
            notebook.container.vehiclesFlag = 0
            notebook.container.principalFrame.searchBox["state"] = "normal"
            notebook.container.principalFrame.search()
            notebook.destroy()
        else:
            messagebox.showwarning(
                "Advertencia",
                "Para poder cerrar el menú no debe haber ninguna pestaña abierta"
            )
            err_string = ( "Error occured in section " + str(fkt) + ".\n" )
            if fkt == "CHARACTER TABLE WRITE":
                err_string += ( "Row number: " + str(fkt_row) + "\n" )
                err_string += ( "Column: " + str(fkt_col) + "\n" )
            messagebox.showerror("ERROR", err_string)
            traceback.print_exc()
        
        
        sys.stdout.flush()    
        font_file.close()

char_dict = {'rec1': {'Character': None, 'Width': None, 'Height': None, 'PositionX': None, 'PositionY': None, 'Position Base': None, 'Is_special_char': None} } 
sp_char_dict = {'rec1': {'Special character': None, 'Width': None, 'Height': None, 'Position Base': None, 'Is_special_char': None, 'loop_string_all': None} } 

model = table.model
model.importDict(char_dict)  

model2 = table2.model
model2.importDict(sp_char_dict)  


try:
    table.resizeColumn(5, 130) #Position Base
    table.resizeColumn(6, 150) #Is_special_char
    table2.resizeColumn(0, 150) #Special character
    table2.resizeColumn(3, 150) #Position Base
    table2.resizeColumn(4, 150) #Is_special_char
    table2.resizeColumn(5, 550) #loop_string_all
except:
    print("Couldn't resize columns!")
table.redraw()
    def fill_table(self):
        # Update accumulated plans
        yr_current = date.today().year
        yr_accu = [0, 0]
        yr_last_1_accu = [0, 0]
        yr_last_2_accu = [0, 0]
        for uni in self.university_list:
            if yr_current in uni.plans:
                yr_accu[Class_Science_Index] += uni.plans[yr_current][
                    Class_Science_Index]
                yr_accu[Class_Art_Index] += uni.plans[yr_current][
                    Class_Art_Index]
                uni.update_accumulated_plan(yr_current,
                                            yr_accu[Class_Science_Index],
                                            yr_accu[Class_Art_Index])
            if (yr_current - 1) in uni.plans:
                yr_last_1_accu[Class_Science_Index] += uni.plans[
                    yr_current - 1][Class_Science_Index]
                yr_last_1_accu[Class_Art_Index] += uni.plans[
                    yr_current - 1][Class_Art_Index]
                uni.update_accumulated_plan(
                    yr_current - 1, yr_last_1_accu[Class_Science_Index],
                    yr_last_1_accu[Class_Art_Index])
            if (yr_current - 2) in uni.plans:
                yr_last_2_accu[Class_Science_Index] += uni.plans[
                    yr_current - 2][Class_Science_Index]
                yr_last_2_accu[Class_Art_Index] += uni.plans[
                    yr_current - 2][Class_Art_Index]
                uni.update_accumulated_plan(
                    yr_current - 2, yr_last_2_accu[Class_Science_Index],
                    yr_last_2_accu[Class_Art_Index])

        # Filter types for display
        self.candidates = []
        for uni in self.university_list:
            if ((self.type_985_value.get() and uni.type_985)
                    or (self.type_211_value.get() and uni.type_211)
                    or (self.type_lead_uni_value.get() and uni.type_lead_uni)
                    or (self.type_lead_sub_value.get() and uni.type_lead_sub)
                    or (self.type_others_value.get() and uni.type_985 == 0
                        and uni.type_211 == 0 and uni.type_lead_uni == 0
                        and uni.type_lead_sub == 0)
                    or self.type_all_value.get()):
                self.candidates.append(uni)
        print "Side of candidates: ", len(self.candidates)
        self.candidates.sort(key=lambda x: x.rank)

        print "update display based on class and types"
        data = {
            'rec1': {
                'col1': 99.88,
                'col2': 108.79,
                'label': 'rec1'
            },
            'rec2': {
                'col1': 99.88,
                'col2': 108.79,
                'label': 'rec2'
            }
        }
        model = TableModel(rows=20, columns=10)
        table = TableCanvas(self.table_list, model=model)
        table.pack(fill=Tk.BOTH, expand=True)
        table.cellbackgr = "white"
        table.selectedcolor = 'green'
        table.createTableFrame()

        model = table.model
        model.importDict(
            data)  # can import from a dictionary to populate model
        table.redrawTable()
        '''rows = len(self.candidates) + 1
Пример #29
0
def openfile():
    global table, time, x_angle, y_angle, day, month, year, root, embedFrame, recordsFrame, play

    name = tkFileDialog.askopenfilename(initialdir=".",
                                        title="Select file",
                                        filetypes=(("Text File", "*.txt"),
                                                   ("All Files", "*.*")))

    if name == "":
        # if file openning was cancelled then return
        return
    else:
        try:
            path = name.split('/')
            # get date from file name
            filename = path[len(path) - 1]
            day = filename[6:8]
            month = filename[4:6]
            year = filename[2:4]

            # create data
            model = TableModel()
            # load data
            data = load_data(name)
            # import data ti tablemodel
            model.importDict(data)
        except:
            tkMessageBox.showerror("Error", "File reading failed!")
            return

    # If another file is open already then close it
    if table != None:
        closefile()

    # Change App title to include currently open file
    root.title('Smart Egg 3D Visualisation ver.1.1 - ' + filename)

    # Create embed frame for pygame window
    embedFrame = tk.Frame(root, width=700, height=600)
    embedFrame.grid(row=0, column=0)
    # Create embed frame for table
    recordsFrame = tk.Frame(root, width=450, height=600)
    recordsFrame.grid(row=0, column=1)
    recordsFrame.pack_propagate(0)
    # Create table for records preview
    table = TableCanvas(recordsFrame,
                        name="tablica",
                        model=model,
                        width=420,
                        height=600,
                        cols=0,
                        rows=0,
                        cellwidth=50,
                        editable=False,
                        showkeynamesinheader=True,
                        reverseorder=0)
    table.grid(row=0, sticky=W + N + S)
    table.createTableFrame()
    # arrange columns width and order
    model.moveColumn(model.getColumnIndex('time'), 1)
    model.moveColumn(model.getColumnIndex('x'), 2)
    model.moveColumn(model.getColumnIndex('y'), 3)
    model.moveColumn(model.getColumnIndex('z'), 4)
    model.moveColumn(model.getColumnIndex('roll'), 5)
    model.moveColumn(model.getColumnIndex('pitch'), 6)
    model.columnwidths['time'] = 150

    table.redrawTable()

    # Initiate and embed pygame
    os.environ['SDL_WINDOWID'] = str(embedFrame.winfo_id())
    #os.environ['SDL_VIDEODRIVER'] = 'windib'
    screen = pygame.display.set_mode(SCREEN_SIZE,
                                     HWSURFACE | OPENGL | DOUBLEBUF)
    resize(*SCREEN_SIZE)
    pygame.init()
    pygame.display.init()

    #Bind keys and buttons events
    root.bind('<ButtonRelease-1>', handle_click)  #click release event
    root.bind_all("<Up>", handle_arrow_keys)  #press Up key event
    root.bind_all("<Down>", handle_arrow_keys)  #press Down key event
    root.bind_all("<Left>", handle_arrow_keys)  #press Left key event
    root.bind_all("<Right>", handle_arrow_keys)  #press Right key event

    # Initiate OpenGL
    init_opengl()

    # Create OpenGL object
    egg = Egg((0.7, 0.0, 0.0), (1, .95, .8))

    # Load first element
    values = get_record(0)
    if values != None:
        time = values[0] + ' ' + values[1]
        x_angle = values[2]
        y_angle = values[3]

    root.update()

    # loop control variable
    play = True

    while play:
        drawXYZCoordinate()
        # Draw XYZ axis labels
        drawText3D(-1.2, -1.0, -2.4, 'x')
        drawText3D(-2.2, -0.6, -2.4, 'y')
        drawText3D(-2.2, -1.0, -2.0, 'z')

        for event in pygame.event.get():
            if event.type == KEYUP:
                handle_arrow_keys(event.key)

        glPushMatrix()
        # rotate object
        glRotate(float(x_angle), 0, 0, 1)
        glRotate(float(y_angle), 1, 0, 0)
        # render object and text
        egg.render(pygame)
        glPopMatrix()
        drawText(0, 2, time)
        # refresh screen
        pygame.display.flip()
        root.update()
Пример #30
0
class Toplevel1:

    #Ab hier fängt die eigentliche GUI Logik an!

    nodeURL = 'https://wasp.servebeer.com:14267'  #'https://nodes.thetangle.org:443'
    targetAddress = ''
    fleetAddress = ''
    entered = False
    enteredEnemy = False
    targetRow = ''
    targetCol = ''
    shipCount = 5
    initialTime = ''
    incomingTime = []
    session = 1
    hitResponse = ''
    hitRow = ''
    hitCol = ''

    #Enter und Exit checken, ob die Maus im Enemy Fleet Frame ist. Ansonsten wird auch der Mouseclick im OurFleet Frame übernommen.

    def timer(self):
        now = datetime.datetime.now()
        dt_string = now.strftime("%d-%m-%Y,%H:%M:%S")
        return dt_string

    def enterOwn(self, event):
        self.entered = True

    def exitOwn(self, event):
        self.entered = False

    def enterEnemy(self, event):
        self.enteredEnemy = True

    def exitEnemy(self, event):
        self.enteredEnemy = False

    def updateLog(self, logEntry):
        self.Log.configure(state='normal')
        self.Log.insert(tk.INSERT, logEntry)
        self.Log.configure(state='disabled')
        self.Log.see("end")

    def checkStatus(self):
        today = datetime.datetime.now()
        todayCheck = today.strftime("%d-%m-%Y")
        initialTime = self.initialTime
        logEntry = 'Checking for incoming missiles...\n'
        self.updateLog(logEntry)
        txCommand = {
            "command": "findTransactions",
            "addresses": [self.fleetAddress]
        }
        findTx = json.dumps(txCommand)
        headers = {
            'content-type': 'application/json',
            'X-IOTA-API-Version': '1'
        }
        try:
            requestFindTx = requests.post(url=self.nodeURL,
                                          data=findTx,
                                          headers=headers)
            jsonDataTx = json.loads(requestFindTx.text)
            tryteCommand = {
                "command": "getTrytes",
                "hashes": jsonDataTx['hashes']
            }
        except:
            messagebox.showinfo("Error", "The address is invalid!")
        findTrytes = json.dumps(tryteCommand)
        requestTrytes = requests.post(url=self.nodeURL,
                                      data=findTrytes,
                                      headers=headers)
        jsonDataTrytes = json.loads(requestTrytes.content)
        for item in jsonDataTrytes['trytes']:
            tryteString = TryteString(item).decode(errors='ignore',
                                                   strip_padding=False)
            head = tryteString.split(';')
            content = head[0].split(',')
            for data in content:
                if data == todayCheck:
                    if datetime.datetime.strptime(
                            content[3],
                            '%H:%M:%S') >= datetime.datetime.strptime(
                                initialTime, '%H:%M:%S'):
                        self.incomingTime.append(content[3])
                        if len(self.incomingTime) > 1:
                            if len(set(self.incomingTime)) == self.session:
                                if datetime.datetime.strptime(
                                        content[3], '%H:%M:%S'
                                ) == datetime.datetime.strptime(
                                        max(set(self.incomingTime)),
                                        '%H:%M:%S'):
                                    self.session += 1
                                    self.displayIncoming(
                                        content[0], content[1])
                                    self.displayHitResponse(
                                        content[4], content[5], content[6])
                                    break
                        else:
                            self.session += 1
                            self.displayIncoming(content[0], content[1])

    def displayIncoming(self, row, col):
        if self.fleetDict[row][col] == 'S':
            mark = 'X'
            logEntry = 'An enemy projectile has struck your ship at ' + row + col + '!\n'
            self.updateLog(logEntry)
            self.setOwnFleetDict(row, col, mark)
            self.setHitDict(row, col, mark)
        else:
            mark = 'o'
            logEntry = 'An enemy projectile has dropped into the ocean at ' + row + col + '.\n'
            self.updateLog(logEntry)
            self.setOwnFleetDict(row, col, mark)
            self.setHitDict(row, col, mark)

    def displayHitResponse(self, row, col, mark):
        print(row + col + mark)
        if mark == 'X':
            logEntry = 'Your projectile fired at ' + row + col + ' has hit an enemy ship! \n'
            self.updateLog(logEntry)
            self.setEnemyFleetDict(row, col, mark)
        elif mark == 'o':
            logEntry = 'Your projectile has dropped into the ocean at ' + row + col + '.\n'
            self.updateLog(logEntry)
            self.setEnemyFleetDict(row, col, mark)
        else:
            return

    def saveConnectionSettings(self):
        if len(self.targetAddressEntry.get()) > 0:
            self.targetAddress = self.targetAddressEntry.get()
        if len(self.addressEntry.get()) > 0:
            self.fleetAddress = self.addressEntry.get()
        if len(self.nodeURLEntry.get()) > 0:
            self.nodeURL = self.nodeURLEntry.get()

    def click(self, event):
        try:
            row = str(int(self.table.get_row_clicked(event) + 1))
            colNum = int(self.table.get_col_clicked(event))
            col = ''
            if colNum == 0:
                col = 'A'
            elif colNum == 1:
                col = 'B'
            elif colNum == 2:
                col = 'C'
            elif colNum == 3:
                col = 'D'
            elif colNum == 4:
                col = 'E'
            if self.entered:
                self.fleetClick(row, col)
            elif self.enteredEnemy:
                self.lockTarget(row, col)
        except:
            print("Click not in main window")

    def fleetClick(self, row, col):
        while self.shipCount > 0:
            self.shipCount -= 1
            mark = 'S'
            logEntry = 'You have placed a ship at ' + row + col + '. ' + str(
                self.shipCount) + ' ships remain.\n'
            self.updateLog(logEntry)
            self.setOwnFleetDict(row, col, mark)
            return
        else:
            logEntry = 'You have no ships left to place.\n'
            self.updateLog(logEntry)
            return

    def setOwnFleetDict(self, row, col, mark):
        self.fleetDict[row][col] = mark
        self.iniFleet()

    def setEnemyFleetDict(self, row, col, mark):
        self.enemyFleetDict[row][col] = mark
        self.iniEnemyFleet()

    def setHitDict(self, row, col, mark):
        self.hitDict[row][col] = 'O'
        self.hitRow = row
        self.hitCol = col
        self.hitResponse = mark

    def lockTarget(self, row, col):
        self.ACoordinates.configure(state='normal')
        self.ACoordinates.delete("0", "end")
        self.ACoordinates.insert(tk.INSERT, row)
        self.NCoordinates.configure(state='normal')
        self.NCoordinates.delete("0", "end")
        self.NCoordinates.insert(tk.INSERT, col)
        self.targetRow = row
        self.targetCol = col

    def fire(self):
        row = self.targetRow
        col = str(self.targetCol)
        self.prepareShot(row, col)

    def prepareShot(self, row, col):
        try:
            #seed =  self.seed
            targetAddress = self.targetAddress
            api = Iota(self.nodeURL)
            closing = ';'
            fireTime = self.timer()
            hitRow = self.hitRow
            hitCol = self.hitCol
            hitResponse = self.hitResponse
            content = str(row + "," + col + "," + fireTime + "," + hitRow +
                          "," + hitCol + "," + hitResponse + closing)
            print(content)
            self.sendTransaction(targetAddress, content, api, row, col)
        except Exception as e:
            print("Error preparing TX")
            logEntry = str(e) + ' Transaction could not be created.\n'
            self.updateLog(logEntry)

    def sendTransaction(self, targetAddress, content, api, row, col):
        try:
            transaction = ProposedTransaction(
                address=Address(targetAddress),
                message=TryteString.from_unicode(content),
                tag=Tag(b'NODE9TEST'),
                value=0,
            )
            api.send_transfer([transaction])
            self.shotFired(row, col)
        except Exception as e:
            print("Error sending TX")
            print(e)
            logEntry = str(e) + ' Transaction could not be created.\n'
            self.updateLog(logEntry)

    def shotFired(self, row, col):
        mark = 'O'
        logEntry = 'You fired at ' + row + col + '!\n'
        self.updateLog(logEntry)
        self.setEnemyFleetDict(row, col, mark)

    tkFont = ["Arial", 18]
    fleetDict = {
        '1': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '2': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '3': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '4': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '5': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        }
    }

    enemyFleetDict = {
        '1': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '2': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '3': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '4': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '5': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        }
    }

    hitDict = {
        '1': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '2': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '3': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '4': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        },
        '5': {
            'A': '',
            'B': '',
            'C': '',
            'D': '',
            'E': '',
        }
    }

    def iniFleet(self):
        self.model = TableModel()
        self.table = TableCanvas(self.Fleet,
                                 model=self.model,
                                 cellwidth=105,
                                 cellbackgr='white',
                                 thefont=self.tkFont,
                                 rowheight=105,
                                 editable=True,
                                 rowselectedcolor="white",
                                 reverseorder=1,
                                 align='center')
        self.model.importDict(self.fleetDict)
        self.table.createTableFrame()
        self.table.autoResizeColumns()
        self.table.redrawTable

    def iniEnemyFleet(self):
        self.model = TableModel()
        self.table = TableCanvas(self.EnemyFleet,
                                 model=self.model,
                                 cellwidth=106,
                                 cellbackgr='white',
                                 thefont=self.tkFont,
                                 rowheight=106,
                                 editable=True,
                                 rowselectedcolor="white",
                                 reverseorder=1,
                                 align='center')
        self.model.importDict(self.enemyFleetDict)
        self.table.createTableFrame()
        self.table.autoResizeColumns()
        self.table.redrawTable

    def drawFleetTable(self):
        self.model = TableModel()
        self.table = TableCanvas(self.Fleet,
                                 model=self.model,
                                 cellwidth=50,
                                 cellbackgr='white',
                                 thefont=self.tkFont,
                                 rowheight=16,
                                 editable=True,
                                 rowselectedcolor='white',
                                 reverseorder=1)
        self.table.createTableFrame()
        self.table.model.columnNames = ['A', 'B', 'C', 'D', 'E']
        self.table.redrawTable
        self.iniFleet()

    def drawEnemyFleetTable(self):
        self.model = TableModel()
        self.table = TableCanvas(self.EnemyFleet,
                                 model=self.model,
                                 cellwidth=50,
                                 cellbackgr='white',
                                 thefont=self.tkFont,
                                 rowheight=16,
                                 editable=True,
                                 rowselectedcolor='white',
                                 reverseorder=1)
        self.table.createTableFrame()
        self.table.model.columnNames = ['A', 'B', 'C', 'D', 'E']
        self.table.redrawTable
        self.iniEnemyFleet()

    def __init__(self, top=None):
        '''This class configures and populates the toplevel window.
           top is the toplevel containing window.'''
        _bgcolor = '#d9d9d9'  # X11 color: 'gray85'
        _fgcolor = '#000000'  # X11 color: 'black'
        _compcolor = '#d9d9d9'  # X11 color: 'gray85'
        _ana1color = '#d9d9d9'  # X11 color: 'gray85'
        _ana2color = '#ececec'  # Closest X11 color: 'gray92'
        self.style = ttk.Style()
        if sys.platform == "win32":
            self.style.theme_use('winnative')
        self.style.configure('.', background=_bgcolor)
        self.style.configure('.', foreground=_fgcolor)
        self.style.configure('.', font="TkDefaultFont")
        self.style.map('.',
                       background=[('selected', _compcolor),
                                   ('active', _ana2color)])

        top.geometry("1342x872+287+110")
        top.minsize(120, 1)
        top.maxsize(5764, 1061)
        top.resizable(1, 1)
        top.title("BattleShip v0.9")
        top.configure(background="#d9d9d9")
        top.configure(highlightbackground="#404040")
        top.configure(highlightcolor="black")
        top.bind('<ButtonRelease-1>', self.click)

        self.style.configure('TNotebook.Tab', background=_bgcolor)
        self.style.configure('TNotebook.Tab', foreground=_fgcolor)
        self.style.map('TNotebook.Tab',
                       background=[('selected', _compcolor),
                                   ('active', _ana2color)])
        self.TNotebook1 = ttk.Notebook(top)
        self.TNotebook1.place(relx=-0.001,
                              rely=0.0,
                              relheight=0.982,
                              relwidth=0.995)
        self.TNotebook1.configure(takefocus="")
        self.TNotebook1_t1 = tk.Frame(self.TNotebook1)
        self.TNotebook1.add(self.TNotebook1_t1, padding=3)
        self.TNotebook1.tab(
            0,
            text="Bridge",
            compound="left",
            underline="-1",
        )
        self.TNotebook1_t1.configure(background="#d9d9d9")
        self.TNotebook1_t1.configure(highlightbackground="#150f4a")
        self.TNotebook1_t1.configure(highlightcolor="black")
        self.TNotebook1_t2 = tk.Frame(self.TNotebook1)
        self.TNotebook1.add(self.TNotebook1_t2, padding=3)
        self.TNotebook1.tab(
            1,
            text="Options",
            compound="left",
            underline="-1",
        )
        self.TNotebook1_t2.configure(background="#d9d9d9")
        self.TNotebook1_t2.configure(highlightbackground="#d9d9d9")
        self.TNotebook1_t2.configure(highlightcolor="black")

        self.Fleet = tk.LabelFrame(self.TNotebook1_t1)
        self.Fleet.place(relx=0.038,
                         rely=0.012,
                         relheight=0.723,
                         relwidth=0.451)
        self.Fleet.configure(relief='groove')
        self.Fleet.configure(foreground="black")
        self.Fleet.configure(text='''Our Fleet''')
        self.Fleet.configure(background="#d9d9d9")
        self.Fleet.configure(highlightbackground="#d9d9d9")
        self.Fleet.configure(highlightcolor="black")
        self.Fleet.bind('<Enter>', self.enterOwn)
        self.Fleet.bind('<Leave>', self.exitOwn)
        self.drawFleetTable()

        self.EnemyFleet = tk.LabelFrame(self.TNotebook1_t1)
        self.EnemyFleet.place(relx=0.518,
                              rely=0.012,
                              relheight=0.723,
                              relwidth=0.452)
        self.EnemyFleet.configure(relief='groove')
        self.EnemyFleet.configure(foreground="black")
        self.EnemyFleet.configure(text='''Enemy Fleet''')
        self.EnemyFleet.configure(background="#d9d9d9")
        self.EnemyFleet.configure(highlightbackground="#d9d9d9")
        self.EnemyFleet.configure(highlightcolor="black")
        self.EnemyFleet.bind('<Enter>', self.enterEnemy)
        self.EnemyFleet.bind('<Leave>', self.exitEnemy)
        self.drawEnemyFleetTable()

        self.Labelframe3 = tk.LabelFrame(self.TNotebook1_t1)
        self.Labelframe3.place(relx=0.038,
                               rely=0.747,
                               relheight=0.235,
                               relwidth=0.451)
        self.Labelframe3.configure(relief='groove')
        self.Labelframe3.configure(foreground="black")
        self.Labelframe3.configure(text='''Log''')
        self.Labelframe3.configure(background="#d9d9d9")
        self.Labelframe3.configure(highlightbackground="#d9d9d9")
        self.Labelframe3.configure(highlightcolor="black")

        self.Log = ScrolledText(self.Labelframe3)
        self.Log.place(relx=0.017,
                       rely=0.103,
                       relheight=0.846,
                       relwidth=0.975,
                       bordermode='ignore')
        self.Log.configure(background="white")
        self.Log.configure(state="disabled")
        self.Log.configure(font="TkTextFont")
        self.Log.configure(foreground="black")
        self.Log.configure(highlightbackground="#d9d9d9")
        self.Log.configure(highlightcolor="black")
        self.Log.configure(insertbackground="black")
        self.Log.configure(insertborderwidth="3")
        self.Log.configure(selectbackground="#c4c4c4")
        self.Log.configure(selectforeground="black")
        self.Log.configure(wrap="none")

        self.Labelframe4 = tk.LabelFrame(self.TNotebook1_t1)
        self.Labelframe4.place(relx=0.518,
                               rely=0.747,
                               relheight=0.235,
                               relwidth=0.452)
        self.Labelframe4.configure(relief='groove')
        self.Labelframe4.configure(foreground="black")
        self.Labelframe4.configure(text='''Command''')
        self.Labelframe4.configure(background="#d9d9d9")
        self.Labelframe4.configure(highlightbackground="#d9d9d9")
        self.Labelframe4.configure(highlightcolor="black")

        self.ACoordinates = tk.Entry(self.Labelframe4)
        self.ACoordinates.place(relx=0.116,
                                rely=0.41,
                                height=50,
                                relwidth=0.09,
                                bordermode='ignore')
        self.ACoordinates.configure(background="white")
        self.ACoordinates.configure(disabledforeground="#a3a3a3")
        self.ACoordinates.configure(font="-family {Arial} -size 16")
        self.ACoordinates.configure(foreground="#000000")
        self.ACoordinates.configure(highlightbackground="#d9d9d9")
        self.ACoordinates.configure(highlightcolor="black")
        self.ACoordinates.configure(insertbackground="black")
        self.ACoordinates.configure(justify='center')
        self.ACoordinates.configure(selectbackground="#c4c4c4")
        self.ACoordinates.configure(selectforeground="black")

        self.NCoordinates = tk.Entry(self.Labelframe4)
        self.NCoordinates.place(relx=0.266,
                                rely=0.41,
                                height=50,
                                relwidth=0.09,
                                bordermode='ignore')
        self.NCoordinates.configure(background="white")
        self.NCoordinates.configure(disabledforeground="#a3a3a3")
        self.NCoordinates.configure(font="-family {Arial} -size 16")
        self.NCoordinates.configure(foreground="#000000")
        self.NCoordinates.configure(highlightbackground="#d9d9d9")
        self.NCoordinates.configure(highlightcolor="black")
        self.NCoordinates.configure(insertbackground="black")
        self.NCoordinates.configure(justify='center')
        self.NCoordinates.configure(selectbackground="#c4c4c4")
        self.NCoordinates.configure(selectforeground="black")

        self.Fire = tk.Button(self.Labelframe4, command=self.fire)
        self.Fire.place(relx=0.698,
                        rely=0.256,
                        height=94,
                        width=157,
                        bordermode='ignore')
        self.Fire.configure(activebackground="#ececec")
        self.Fire.configure(activeforeground="#000000")
        self.Fire.configure(background="#d9d9d9")
        self.Fire.configure(disabledforeground="#a3a3a3")
        self.Fire.configure(font="-family {Arial} -size 21")
        self.Fire.configure(foreground="#000000")
        self.Fire.configure(highlightbackground="#d9d9d9")
        self.Fire.configure(highlightcolor="black")
        self.Fire.configure(pady="0")
        self.Fire.configure(text='''Fire!''')

        self.Coordinates = tk.Label(self.Labelframe4)
        self.Coordinates.place(relx=0.116,
                               rely=0.256,
                               height=21,
                               width=143,
                               bordermode='ignore')
        self.Coordinates.configure(activebackground="#f9f9f9")
        self.Coordinates.configure(activeforeground="black")
        self.Coordinates.configure(background="#d9d9d9")
        self.Coordinates.configure(disabledforeground="#a3a3a3")
        self.Coordinates.configure(foreground="#000000")
        self.Coordinates.configure(highlightbackground="#d9d9d9")
        self.Coordinates.configure(highlightcolor="black")
        self.Coordinates.configure(text='''Target Coordinates''')

        self.Check = tk.Button(self.Labelframe4, command=self.checkStatus)
        self.Check.place(relx=0.432,
                         rely=0.256,
                         height=94,
                         width=147,
                         bordermode='ignore')
        self.Check.configure(activebackground="#ececec")
        self.Check.configure(activeforeground="#000000")
        self.Check.configure(background="#d9d9d9")
        self.Check.configure(disabledforeground="#a3a3a3")
        self.Check.configure(foreground="#000000")
        self.Check.configure(highlightbackground="#d9d9d9")
        self.Check.configure(highlightcolor="black")
        self.Check.configure(pady="0")
        self.Check.configure(text='''Check''')

        self.seedEntry = tk.Entry(self.TNotebook1_t2)
        self.seedEntry.place(relx=0.09, rely=0.145, height=30, relwidth=0.424)
        self.seedEntry.configure(background="white")
        self.seedEntry.configure(disabledforeground="#a3a3a3")
        self.seedEntry.configure(font="TkFixedFont")
        self.seedEntry.configure(foreground="#000000")
        self.seedEntry.configure(highlightbackground="#d9d9d9")
        self.seedEntry.configure(highlightcolor="black")
        self.seedEntry.configure(insertbackground="black")
        self.seedEntry.configure(selectbackground="#c4c4c4")
        self.seedEntry.configure(selectforeground="black")

        self.Seed = tk.Label(self.TNotebook1_t2)
        self.Seed.place(relx=0.09, rely=0.108, height=20, width=31)
        self.Seed.configure(activebackground="#f9f9f9")
        self.Seed.configure(activeforeground="black")
        self.Seed.configure(background="#d9d9d9")
        self.Seed.configure(disabledforeground="#a3a3a3")
        self.Seed.configure(foreground="#000000")
        self.Seed.configure(highlightbackground="#d9d9d9")
        self.Seed.configure(highlightcolor="black")
        self.Seed.configure(text='''Seed''')

        self.targetAddressEntry = tk.Entry(self.TNotebook1_t2)
        self.targetAddressEntry.place(relx=0.09,
                                      rely=0.253,
                                      height=30,
                                      relwidth=0.424)
        self.targetAddressEntry.configure(background="white")
        self.targetAddressEntry.configure(disabledforeground="#a3a3a3")
        self.targetAddressEntry.configure(font="TkFixedFont")
        self.targetAddressEntry.configure(foreground="#000000")
        self.targetAddressEntry.configure(highlightbackground="#d9d9d9")
        self.targetAddressEntry.configure(highlightcolor="black")
        self.targetAddressEntry.configure(insertbackground="black")
        self.targetAddressEntry.configure(selectbackground="#c4c4c4")
        self.targetAddressEntry.configure(selectforeground="black")

        self.TargetAddress = tk.Label(self.TNotebook1_t2)
        self.TargetAddress.place(relx=0.09, rely=0.217, height=21, width=88)
        self.TargetAddress.configure(activebackground="#f9f9f9")
        self.TargetAddress.configure(activeforeground="black")
        self.TargetAddress.configure(background="#d9d9d9")
        self.TargetAddress.configure(disabledforeground="#a3a3a3")
        self.TargetAddress.configure(foreground="#000000")
        self.TargetAddress.configure(highlightbackground="#d9d9d9")
        self.TargetAddress.configure(highlightcolor="black")
        self.TargetAddress.configure(text='''Target Address''')

        self.nodeURLEntry = tk.Entry(self.TNotebook1_t2)
        self.nodeURLEntry.place(relx=0.09,
                                rely=0.47,
                                height=30,
                                relwidth=0.183)
        self.nodeURLEntry.configure(background="white")
        self.nodeURLEntry.configure(disabledforeground="#a3a3a3")
        self.nodeURLEntry.configure(font="TkFixedFont")
        self.nodeURLEntry.configure(foreground="#000000")
        self.nodeURLEntry.configure(highlightbackground="#d9d9d9")
        self.nodeURLEntry.configure(highlightcolor="black")
        self.nodeURLEntry.configure(insertbackground="black")
        self.nodeURLEntry.configure(selectbackground="#c4c4c4")
        self.nodeURLEntry.configure(selectforeground="black")

        self.NodeURL = tk.Label(self.TNotebook1_t2)
        self.NodeURL.place(relx=0.09, rely=0.434, height=20, width=58)
        self.NodeURL.configure(activebackground="#f9f9f9")
        self.NodeURL.configure(activeforeground="black")
        self.NodeURL.configure(background="#d9d9d9")
        self.NodeURL.configure(disabledforeground="#a3a3a3")
        self.NodeURL.configure(foreground="#000000")
        self.NodeURL.configure(highlightbackground="#d9d9d9")
        self.NodeURL.configure(highlightcolor="black")
        self.NodeURL.configure(text='''Node URL''')

        self.Connect = tk.Button(self.TNotebook1_t2)
        self.Connect.place(relx=0.293, rely=0.47, height=34, width=87)
        self.Connect.configure(activebackground="#ececec")
        self.Connect.configure(activeforeground="#000000")
        self.Connect.configure(background="#d9d9d9")
        self.Connect.configure(cursor="fleur")
        self.Connect.configure(disabledforeground="#a3a3a3")
        self.Connect.configure(foreground="#000000")
        self.Connect.configure(highlightbackground="#d9d9d9")
        self.Connect.configure(highlightcolor="black")
        self.Connect.configure(pady="0")
        self.Connect.configure(text='''Connect''')

        self.netEntry = tk.Entry(self.TNotebook1_t2)
        self.netEntry.place(relx=0.09, rely=0.554, height=70, relwidth=0.266)
        self.netEntry.configure(background="white")
        self.netEntry.configure(disabledforeground="#a3a3a3")
        self.netEntry.configure(font="TkFixedFont")
        self.netEntry.configure(foreground="#000000")
        self.netEntry.configure(highlightbackground="#d9d9d9")
        self.netEntry.configure(highlightcolor="black")
        self.netEntry.configure(insertbackground="black")
        self.netEntry.configure(selectbackground="#c4c4c4")
        self.netEntry.configure(selectforeground="black")

        self.NetStatus = tk.Label(self.TNotebook1_t2)
        self.NetStatus.place(relx=0.09, rely=0.518, height=21, width=86)
        self.NetStatus.configure(activebackground="#f9f9f9")
        self.NetStatus.configure(activeforeground="black")
        self.NetStatus.configure(background="#d9d9d9")
        self.NetStatus.configure(disabledforeground="#a3a3a3")
        self.NetStatus.configure(foreground="#000000")
        self.NetStatus.configure(highlightbackground="#d9d9d9")
        self.NetStatus.configure(highlightcolor="black")
        self.NetStatus.configure(text='''Network Status''')

        self.addressEntry = tk.Entry(self.TNotebook1_t2)
        self.addressEntry.place(relx=0.09,
                                rely=0.361,
                                height=30,
                                relwidth=0.424)
        self.addressEntry.configure(background="white")
        self.addressEntry.configure(disabledforeground="#a3a3a3")
        self.addressEntry.configure(font="TkFixedFont")
        self.addressEntry.configure(foreground="#000000")
        self.addressEntry.configure(insertbackground="black")

        self.Address = tk.Label(self.TNotebook1_t2)
        self.Address.place(relx=0.09, rely=0.325, height=20, width=54)
        self.Address.configure(background="#d9d9d9")
        self.Address.configure(disabledforeground="#a3a3a3")
        self.Address.configure(foreground="#000000")
        self.Address.configure(text='''Address''')

        self.Save = tk.Button(self.TNotebook1_t2,
                              command=self.saveConnectionSettings)
        self.Save.place(relx=0.563, rely=0.241, height=54, width=117)
        self.Save.configure(activebackground="#ececec")
        self.Save.configure(activeforeground="#000000")
        self.Save.configure(background="#d9d9d9")
        self.Save.configure(disabledforeground="#a3a3a3")
        self.Save.configure(foreground="#000000")
        self.Save.configure(highlightbackground="#d9d9d9")
        self.Save.configure(highlightcolor="black")
        self.Save.configure(pady="0")
        self.Save.configure(text='''Save''')
Пример #31
0
class PersonsTab(Frame):
    def __init__(self, notebook):

        #CARACTERÍSTICAS DE LA PESTAÑA
        super().__init__(notebook,
                         bg="#%02x%02x%02x" % (166, 185, 180),
                         highlightthickness=1,
                         highlightbackground="black")
        width = notebook.cget("width") * 3 / 5
        height = notebook.cget("height")

        #TÍTULO DEL PANEL
        Label(self,
              text="LISTA DE PERSONAS REGISTRADAS",
              font=("Verdana", 16, "bold"),
              bg="#%02x%02x%02x" % (166, 185, 180)).place(relx="0.05",
                                                          rely="0.05")

        #BOTÓN PARA CERRAR EL PANEL DE PESTAÑAS
        Button(self,
               text="Cerrar Menú",
               font=("Verdana", 12),
               command=lambda: self.close(notebook)).place(relx="0.85",
                                                           rely="0.05")

        #CREA LA TABLA DE PERSONAS
        self.tableFrame = Frame(self)
        self.model = TableModel()
        self.model.addColumn(colname="DNI")
        self.model.columnwidths["DNI"] = 90
        self.model.addColumn(colname="APELLIDO")
        self.model.columnwidths["APELLIDO"] = 90
        self.model.addColumn(colname="NOMBRES")
        self.model.addColumn(colname="FECHA DE NAC.")
        self.model.columnwidths["FECHA DE NAC."] = 130
        self.model.addColumn(colname="DOMICILIO")
        self.model.columnwidths["DOMICILIO"] = 147
        self.model.addColumn(colname="NACIONALIDAD")
        self.model.columnwidths["NACIONALIDAD"] = 120
        self.model.addColumn(colname="CATEGORÍA")
        self.model.columnwidths["CATEGORÍA"] = 90
        self.model.addColumn(colname="TIPO SANGRE")
        self.model.columnwidths["TIPO SANGRE"] = 110
        self.personsTable = TableCanvas(self.tableFrame,
                                        model=self.model,
                                        width=900,
                                        thefont=("Arial", 10),
                                        read_only=True)
        self.personsTable.show()
        self.tableFrame.place(relx="0.05", rely="0.15")

        self.showPersons()

        #BOTÓN PARA AÑADIR REGISTRO
        Button(self,
               text='AÑADIR REGISTRO',
               width=20,
               font=("Verdana", 14),
               command=lambda: notebook.createAddPersonTab()).place(relx=0.1,
                                                                    rely=0.7)

        #BOTÓN PARA MODIFICAR REGISTRO
        Button(self,
               text='MODIFICAR REGISTRO',
               width=20,
               font=("Verdana", 14),
               command=lambda: notebook.createModifyPersonTab()).place(
                   relx=0.4, rely=0.7)

        #BOTÓN PARA ELIMINAR REGISTRO
        Button(self,
               text='ELIMINAR REGISTRO',
               width=20,
               font=("Verdana", 14),
               command=lambda: notebook.createDeletePersonToplevel()).place(
                   relx=0.7, rely=0.7)

    #FUNCIÓN PARA OBTENER Y CARGAR LAS PERSONAS REGISTRADAS
    def showPersons(self):
        persons = DBManager().getAllPersons()
        self.model.deleteRows()
        dataModel = {}
        for person in persons:
            birthdate = "%02d-%02d-%4d" % (person[3].day, person[3].month,
                                           person[3].year)
            dataModel[person[0]] = {
                'DNI': person[0],
                'APELLIDO': person[1],
                'NOMBRES': person[2],
                'FECHA DE NAC.': birthdate,
                'DOMICILIO': person[4],
                'NACIONALIDAD': person[5],
                'CATEGORÍA': person[6],
                'TIPO SANGRE': person[7]
            }
        self.model.importDict(dataModel)
        self.personsTable.redraw()

    #OBTIENE LA FILA SELECCIONADA
    def getSelectedRow(self):
        return (self.personsTable.get_currentRecord())

    #CERRAR LA PESTAÑA Y ACCIONES COMPLEMENTARIAS
    def close(self, notebook):
        if notebook.addPersonFlag == 0 and notebook.modifyPersonFlag == 0 and notebook.deletePersonFlag == 0:
            notebook.container.personsFlag = 0
            notebook.container.principalFrame.searchBox["state"] = "normal"
            notebook.container.principalFrame.search()
            notebook.destroy()
        else:
            #PARA PODER CERRAR EL PANEL, LAS PESTAÑAS DEBEN ESTAR CERRADAS
            messagebox.showwarning(
                "Advertencia",
                "Para poder cerrar el menú no debe haber ninguna pestaña abierta"
            )
Пример #32
0
    def initUI(self):

        self.parent.title("Caritas")
        self.style = Style()
        self.style.theme_use("default")

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

        frameMenu = Frame(self)
        frameMenu.pack(fill="both", expand="0", side=RIGHT)

        labelBusqueda = LabelFrame(frameMenu, text="Busqueda")
        labelBusqueda.pack(fill="x",expand =1)

        labelVoluntarios = LabelFrame(frameMenu)
        labelVoluntarios.pack(fill="both",expand =0)

        frameTabla = Frame(self)
        frameTabla.pack(fill="both", expand="1", side=LEFT)

        labelTabla = LabelFrame(frameTabla)
        labelTabla.pack(fill="both", expand="1")

        labelBotonera = LabelFrame(frameTabla)
        labelTabla.pack(fill="both", expand="1")

        labelSelect = LabelFrame(frameTabla)
        labelSelect.pack(fill="both", expand="1")

        model = TableModel()
        modelSelect = TableModel()

        model.addColumn("nombre")
        model.addColumn("apellidos")
        model.addColumn("dni")
        model.addColumn("direccion")
        model.addColumn("correo_electronico")
        model.addColumn("estudio")
        model.addColumn("parroquial")
        model.addColumn("proyecto")
        model.addColumn("genero")
        model.addColumn("fecha_nacimiento")
        model.addColumn("telefono_1")
        model.addColumn("telefono_2")

        modelSelect.addColumn("nombre")
        modelSelect.addColumn("apellidos")
        modelSelect.addColumn("dni")
        modelSelect.addColumn("direccion")
        modelSelect.addColumn("correo_electronico")
        modelSelect.addColumn("estudio")
        modelSelect.addColumn("parroquial")
        modelSelect.addColumn("proyecto")
        modelSelect.addColumn("genero")
        modelSelect.addColumn("fecha_nacimiento")
        modelSelect.addColumn("telefono_1")
        modelSelect.addColumn("telefono_2")

        #Tabla Voluntarios
        self.listilla= queryAllVoluntarios()
        model.importDict(self.listilla)
        self.table = TableCanvas(labelTabla, model=model,editable=False)
        self.table.createTableFrame()
        self.table.handle_double_click(self.eventoClic)

        #Tabla Seleccionados
        self.selectTable = TableCanvas(labelSelect, model=modelSelect,editable=False)
        self.selectTable.createTableFrame()
        self.listadoSeleccionado = []

        L1 = Label(labelBusqueda, text="Nombre")
        L1.pack()
        E1 = Entry(labelBusqueda)
        E1.pack()

        L2 = Label(labelBusqueda, text="Apellidos")
        L2.pack()
        E2 = Entry(labelBusqueda)
        E2.pack()

        botonArriba = Button(labelVoluntarios, text="Agregar al listado",  command=lambda:self.agregarListado(self.table.getSelectedRow()))
        botonArriba.pack()
        botonAbajo = Button(labelVoluntarios, text="Quitar del listado",  command=lambda:self.quitarListado(self.selectTable.getSelectedRow()))
        botonAbajo.pack()

        button = Button(labelBusqueda, text="Buscar", command=lambda: self.buscar(E1.get(),E2.get()))
        button.pack()

        button = Button(labelVoluntarios, text="Nuevo Voluntario",  command=lambda:self.ventanaVoluntarios(-1))
        button.pack()

        buttonEditar = Button(labelVoluntarios, text="Editar Voluntario",  command=lambda:self.ventanaVoluntarios(self.table.getSelectedRow()))
        buttonEditar.pack()

        buttonImprimir = Button(labelVoluntarios, text="Imprimir",  command=lambda:self.ventanaImprimir())
        buttonImprimir.pack()
Пример #33
0
mycanvas.configure(yscrollcommand=yscrollbar.set)
mycanvas.bind('<Configure>',
              lambda e: mycanvas.configure(scrollregion=mycanvas.bbox('all')))

myframe = Frame(mycanvas)
mycanvas.create_window((0, 0), window=myframe, anchor="n")

start_date = datetime.strptime(entry1.get(), '%d-%m-%Y')
end_date = datetime.strptime(entry2.get(), '%d-%m-%Y')

tframe = Frame(root)
tframe.grid(column=0, row=1)
model = TableModel()

Makedata = makedata()
itemdict = Makedata.dictitems()

model.importDict(itemdict)

table = TableCanvas(tframe,
                    model,
                    cellwidth=100,
                    cellbackgr='#e3f698',
                    thefont=('Arial', 12),
                    rowheight=25,
                    rowheaderwidth=100,
                    rowselectedcolor='yellow',
                    editable=True)
table.show()