class channel_plot: ''' ''' def __init__(self, interface, toplevel=False, start_t=False, stop_t=False): ''' ''' self.abort = False if not start_t: start_t = datetime.utcnow() - timedelta(hours=2) if not stop_t: stop_t = datetime.utcnow() self.update_pending = False self.pype = interface self.plot_dicts = {} if isinstance(start_t, datetime): self.start_t = StringVar(value=start_t.strftime(time_format)) elif isinstance(start_t, str): self.start_t = StringVar(value=start_t) else: raise TypeError('start_t must be string or datetime') if isinstance(stop_t, datetime): self.stop_t = StringVar(value=stop_t.strftime(time_format)) elif isinstance(stop_t, str): self.stop_t = StringVar(value=stop_t) else: raise TypeError('stop_t must be string or datetime') self.time_interval = [self.start_t.get(), self.stop_t.get()] self.ymin = DoubleVar() self.ymax = DoubleVar() if toplevel: self.toplevel = toplevel else: self.toplevel = Tk.Tk() self.status_var = StringVar(value='initializing') self._SetupCanvas() self._BuildGui() if not toplevel: Tk.mainloop() def _BuildGui(self): ''' ''' self.removei = IntVar(value=0) self.relative_start_time = BooleanVar(value=False) self.relative_stop_time = BooleanVar(value=False) self.continuous_updates = BooleanVar(value=False) self.ManualLimits = BooleanVar(value=False) self.LogYScale = BooleanVar(value=False) self.ShowGrid = BooleanVar(value=False) self.ConnectedPts = BooleanVar(value=True) Button(self.toplevel, text="Add Line", command=self._AddSubplot ).grid(row=0, column=1) self._AddSubplot() Button(self.toplevel, text="Gas Line Temps", command=self._PlotGasLines ).grid(row=0, column=2) Button(self.toplevel, text="Amps+Cell Temps", command=self._PlotCell ).grid(row=0, column=3) Label(self.toplevel, text='Start Time').grid(row=4, column=1) start_entry = Entry(self.toplevel, textvariable=self.start_t) start_entry.bind('<Return>', self.Update) start_entry.bind('<KP_Enter>', self.Update, '+') start_entry.grid(row=4, column=2, columnspan=2) Checkbutton(self.toplevel, text='Hours ago', variable=self.relative_start_time).grid(row=4, column=4, sticky='W') Label(self.toplevel, text='Stop Time').grid(row=5, column=1) stop_entry = Entry(self.toplevel, textvariable=self.stop_t) stop_entry.bind('<Return>', self.Update) stop_entry.bind('<KP_Enter>', self.Update, '+') stop_entry.grid(row=5, column=2, columnspan=2) Checkbutton(self.toplevel, text='Now', variable=self.relative_stop_time).grid(row=5, column=4, sticky='W') Label(self.toplevel, text='Y limits (min-max)').grid(row=7, column=1) ymin = Entry(self.toplevel, textvariable=self.ymin) ymin.grid(row=7, column=2) ymin.bind('<Return>', self.Update) ymin.bind('<KP_Enter>', self.Update, '+') ymax = Entry(self.toplevel, textvariable=self.ymax) ymax.grid(row=7, column=3) ymax.bind('<Return>', self.Update) ymax.bind('<KP_Enter>', self.Update, '+') Checkbutton(self.toplevel, text='Manual Y-limits', variable=self.ManualLimits ).grid(row=8, column=1) Checkbutton(self.toplevel, text='Log Y-scale', variable=self.LogYScale ).grid(row=8, column=2) Checkbutton(self.toplevel, text='Show Grid', variable=self.ShowGrid ).grid(row=9, column=1) Checkbutton(self.toplevel, text='Connected Points', variable=self.ConnectedPts ).grid(row=9, column=2) Button(self.toplevel, text="Update All", command=self.Update ).grid(row=10, column=1) Button(self.toplevel, text="Save Plot", command=self.SaveFigure ).grid(row=10, column=2) Button(self.toplevel, text="Save Json", command=self.SaveJson ).grid(row=10, column=3) Checkbutton(self.toplevel, text='Continuous (Button above to start)', variable=self.continuous_updates ).grid(row=11, column=1, columnspan=2) self.status_var.set('done') Label(self.toplevel, textvariable=self.status_var).grid(row=20, column=1, columnspan=2) def _SetupCanvas(self): ''' ''' self.figure = Figure() self.figure.subplots_adjust(left=0.15, bottom=0.2) self.subfigure = self.figure.add_subplot(1,1,1) self.notebook = Notebook(self.toplevel) self.notebook.grid(row=1, column=1, rowspan=3, columnspan=3, sticky='nsew') self.canvas = FigureCanvasTkAgg(self.figure, master=self.toplevel) self.canvas.show() self.canvas.get_tk_widget().grid(row=0, column=0, rowspan=10) def _AddSubplot(self): ''' ''' plotnum = len(self.notebook.tabs()) self.plot_dicts[plotnum] = {} frame = Frame(self.notebook) frame.pack(side='top', fill='both', expand='y') self.plot_dicts[plotnum]['xname'] = StringVar(value='None') self.plot_dicts['xunit'] = False self.plot_dicts[plotnum]['yname'] = StringVar(value='None') self.plot_dicts['yunit'] = False Label(frame, text='X Channel').grid(row=0, column=0) Label(frame, text='Y Channel').grid(row=1, column=0) OptionMenu(frame, self.plot_dicts[plotnum]['xname'], "None", "time", "dpph_field", *self.pype.EligibleLoggers() ).grid(row=0, column=1, sticky='ew') OptionMenu(frame, self.plot_dicts[plotnum]['yname'], "None", "dpph_field", *self.pype.EligibleLoggers() ).grid(row=1, column=1, sticky='ew') self.notebook.add(frame, text='line:'+str(plotnum)) def _SetStartStop(self, event=None): ''' ''' try: if self.relative_stop_time.get(): stop_time = datetime.utcnow() else: stop_time = datetime.strptime(self.stop_t.get(), time_format) if self.relative_start_time.get(): hours = float(self.start_t.get()) start = datetime.utcnow() - timedelta(hours=hours) else: start = datetime.strptime(self.start_t.get(), time_format) assert (start < stop_time) self.time_interval[0] = start.strftime(time_format) self.time_interval[1] = stop_time.strftime(time_format) except ValueError: showwarning('Warning', 'invalid time format, must match yyyy-mm-ddThh:mm:ssZ') raise TimeFormatError("invalid start or stop time format") except AssertionError: showwarning('Warning', 'time order error, stop time must be after start time') raise TimeOrderError("stop time must be after start time") def Update(self, event=None, tab='All', unpend=False): ''' Call whatever sequence is needed to update local data and redraw the plot ''' if self.abort: self.abort = False return if unpend: self.update_pending = False self.status_var.set('updating!') if tab == 'All': tab = range(len(self.notebook.tabs())) elif isinstance(tab, int): tab = [tab] else: raise ValueError('tab should be "All" or an int') try: self._SetStartStop(event=None) except: print('SetStartStop problems') self.abort = True self.subfigure.clear() for tabi in tab: if tabi > len(self.subfigure.get_lines()): print('wtf') elif tabi == len(self.subfigure.get_lines()): self._UpdateData(tab=tabi) self._MakePlot(tab=tabi) else: self._UpdateExisting(tab=tabi) self.figure.legends = [] self.figure.legend(*self.subfigure.get_legend_handles_labels()) self.figure.legends[0].draggable(True) self.canvas.draw() self.status_var.set('updated at: ' + datetime.utcnow().strftime(time_format)) if (self.continuous_updates.get() and self.relative_stop_time.get() and not self.update_pending): self.update_pending = True self.toplevel.after(10000, lambda: self.Update(unpend=True)) def _UpdateData(self, tab=0): ''' ''' try: yname = self.plot_dicts[tab]['yname'].get() ychdat = self.pype.GetTimeSeries(yname, self.time_interval[0], self.time_interval[1]) if self.plot_dicts[tab]['xname'].get() == 'time': xchdat = (ychdat[0], ychdat[0], 'time' * len(ychdat[0])) else: xname = self.plot_dicts[tab]['xname'].get() xchdat = self.pype.GetTimeSeries(xname, self.time_interval[0], self.time_interval[1]) if tab > 0 and ychdat[0]: assert xchdat[2][0] == self.plot_dicts['xunit'], 'x units' assert ychdat[2][0] == self.plot_dicts['yunit'], 'y units' self.xdata = [] self.ydata = [] if ychdat[0]: for tx, x in zip(xchdat[0], xchdat[1]): xtmp = False ytmp = False dt = timedelta(seconds=60) for ty, y in zip(ychdat[0], ychdat[1]): if abs(ty - tx) < dt: dt = abs(ty - tx) xtmp = x ytmp = y if xtmp and ytmp: self.xdata.append(xtmp) self.ydata.append(ytmp) [self.xdata, self.ydata] = zip(*sorted(zip(self.xdata, self.ydata))) self.plot_dicts['xunit'] = xchdat[2][0] self.plot_dicts['yunit'] = ychdat[2][0] except AssertionError as e: print('*'*60, '\n the', e[0], 'do not match the 0th line', '*'*60) def _UpdateExisting(self, tab=0): ''' ''' try: yname = self.plot_dicts[tab]['yname'].get() ychdat = self.pype.GetTimeSeries(yname, self.time_interval[0], self.time_interval[1]) if self.plot_dicts[tab]['xname'].get() == 'time': xchdat = (ychdat[0], ychdat[0], 'time' * len(ychdat[0])) else: xname = self.plot_dicts[tab]['xname'].get() xchdat = self.pype.GetTimeSeries(xname, self.time_interval[0], self.time_interval[1]) if tab > 0 and ychdat[0]: assert xchdat[2][0] == self.plot_dicts['xunit'], 'x units' assert ychdat[2][0] == self.plot_dicts['yunit'], 'y units' self.xdata = [] self.ydata = [] if ychdat[0]: for tx, x in zip(xchdat[0], xchdat[1]): xtmp = False ytmp = False dt = timedelta(seconds=60) for ty, y in zip(ychdat[0], ychdat[1]): if abs(ty - tx) < dt: dt = abs(ty - tx) xtmp = x ytmp = y if xtmp and ytmp: self.xdata.append(xtmp) self.ydata.append(ytmp) [self.xdata, self.ydata] = zip(*sorted(zip(self.xdata, self.ydata))) self.plot_dicts['xunit'] = xchdat[2][0] self.plot_dicts['yunit'] = ychdat[2][0] this_line = self.subfigure.get_lines()[tab] this_line.set_xdata(array(self.xdata)) this_line.set_ydata(array(self.ydata)) except AssertionError as e: print('*'*60, '\n the', e[0], 'do not match the 0th line', '*'*60) def _MakePlot(self, tab=0): ''' ''' if self.ConnectedPts.get(): plotformat='o-' else: plotformat='o' if self.plot_dicts[tab]['xname'].get() == 'time': self.subfigure.plot_date(self.xdata, self.ydata, plotformat, label=self.plot_dicts[tab]['yname'].get()) self.subfigure.set_xticklabels(self.subfigure.get_xticklabels(), rotation=-45) self.subfigure.xaxis.set_major_formatter(dates.DateFormatter( "%m/%d %H:%M")) self.subfigure.yaxis.set_major_formatter(ticker.ScalarFormatter( useOffset=False)) else: self.subfigure.plot(self.xdata, self.ydata, plotformat, label=self.plot_dicts[tab]['yname'].get()) self.subfigure.set_title(self.plot_dicts[tab]['yname'].get() + ' vs ' + self.plot_dicts[tab]['xname'].get() + '\n from ' + self.time_interval[0] + ' to ' + self.time_interval[1]) xname = self.plot_dicts[tab]['xname'].get().replace('_', ' ') xunit = '[' + str(self.plot_dicts['xunit']) + ']' self.subfigure.set_xlabel(xname + ' ' + xunit) yname = self.plot_dicts[tab]['yname'].get().replace('_', ' ') yunit = '[' + str(self.plot_dicts['yunit']) + ']' self.subfigure.set_ylabel(yname + ' ' + yunit) tickformat = ticker.ScalarFormatter(useOffset=False) if self.ManualLimits.get(): self.subfigure.set_ylim(bottom=self.ymin.get(), top=self.ymax.get()) if self.LogYScale.get(): self.subfigure.set_yscale('log') if self.ShowGrid.get(): self.subfigure.grid(b=True, which='major') self.subfigure.grid(b=True, which='minor') def _PlotGasLines(self): ''' ''' gas_lines = ['left_gas_line_lower_t', 'left_gas_line_upper_t', 'right_gas_line_lower_t', 'right_gas_line_upper_t'] self._PlotSet(gas_lines) def _PlotCell(self): ''' ''' sensors = ['kh2_temp', 'kh3_temp', 'waveguide_cell_body_temp', 'coldhead_temp'] self._PlotSet(sensors) def _PlotSet(self, channels): ''' Plots a set of channels on common axes ''' for plotn, channel in enumerate(channels): if (len(self.plot_dicts)-2) <= plotn: self._AddSubplot() self.plot_dicts[plotn]['xname'].set('time') self.plot_dicts[plotn]['yname'].set(channel) self.start_t.set('3') self.relative_start_time.set(True) self.relative_stop_time.set(True) self.continuous_updates.set(True) self.Update() def SaveFigure(self): ''' ''' file_extensions = [('vectorized', '.eps'), ('adobe', '.pdf'), ('image', '.png'), ('all', '.*')] outfile = asksaveasfilename(defaultextension='.pdf', filetypes=file_extensions) self.figure.savefig(outfile) def SaveJson(self): ''' ''' outfile = asksaveasfile(defaultextension='.json') outdict = {'xunit':self.plot_dicts['xunit'], 'yunit':self.plot_dicts['yunit'] } for tab in range(len(self.plot_dicts)-2): outdict[tab] = {} outdict[tab]['xname']=self.plot_dicts[tab]['xname'].get() outdict[tab]['yname']=self.plot_dicts[tab]['yname'].get() this_line = self.subfigure.get_lines()[tab] if outdict['xunit'] == 't': outdict[tab]['xdata'] = [str(t) for t in this_line.get_xdata()] else: outdict[tab]['xdata'] = list(this_line.get_xdata()) outdict[tab]['ydata'] = list(this_line.get_ydata()) dump(outdict, outfile, indent=4) outfile.close()
class View(Toplevel): def __init__(self, model): self.model = model self.model_config = self.model.get_config() self.channels_num = 0 self.channels_amount = 0 self.root = Tk() self.root.resizable(width=FALSE, height=FALSE) self.root.title("RaaS. event_proxy configurator") #: self.root.iconbitmap('resourse/vit.ico') self.config_route = self.model.get_config_route() self.panelFrame = Frame(self.root, height=60) self.canvas = Canvas(self.root, borderwidth=0) self.textFrame = Frame(self.canvas, height=340, width=600) self.mainFrame = LabelFrame(self.root, width=200, text="Main:", height=340, relief=RAISED, borderwidth=1) self.chanelFrame = LabelFrame(self.root, width=370, text="Channels:", height=340, relief=RAISED, borderwidth=1) #: self.vsb = Scrollbar(self.root, orient="horizontal", #: command=self.canvas.xview) #:self.canvas.configure(xscrollcommand=self.vsb.set) #:self.vsb.pack(side="bottom", fill="x") self.canvas.pack(side="bottom", fill="both", expand=True) self.canvas.configure(scrollregion=self.canvas.bbox("all")) self.root.protocol("WM_DELETE_WINDOW", self.quit_handler) self.tabs = Notebook(self.root) self.in_channel_text = [] self.out_port_text = [] self.out_channel_text = [] self.c = self.model.get_channels().keys() self.channels_len = len(self.model.get_channels()) #:print self.model.get_channels() self.panelFrame.pack(side='top', fill='x') self.textFrame.pack(side='bottom', fill='both', expand=1) self.mainFrame.place(x=10, y=60) self.chanelFrame.place(x=220, y=60) self.tabs.place(x=230, y=80) x = (self.root.winfo_screenwidth() - self.root.winfo_reqwidth()) / 2 y = (self.root.winfo_screenheight() - self.root.winfo_reqheight()) / 2 self.root.geometry("+%d+%d" % (x-150, y-150)) for i in range(self.channels_len): self.channels_num += 1 self.channels_amount += 1 self.f1 = Frame(self.tabs, height=290, width=350) self.tabs.add(self.f1, text='Channel {0}'.format(i + 1)) self.in_channel = Label(self.f1, text="In channel") self.out_port = Label(self.f1, text="Out port") self.out_channel = Label(self.f1, text="Out channel") self.in_channel_text.append(Entry(self.f1, width=20, bd=3)) self.in_channel_text[i].insert(0, self.c[i]) self.out_port_text.append(Entry(self.f1, width=20, bd=3)) self.out_port_text[i].insert(0, self.model.get_channels()[ self.c[i]].out_port) self.out_channel_text.append(Entry(self.f1, width=20, bd=3)) self.out_channel_text[i].insert(0, self.model.get_channels()[ self.c[i]].out_channel) self.in_channel.place(x=5, y=10) self.in_channel_text[i].place(x=5, y=30) self.out_port.place(x=5, y=50) self.out_port_text[i].place(x=5, y=70) self.out_channel.place(x=5, y=90) self.out_channel_text[i].place(x=5, y=110) self.del_ch_btn = Button(self.f1, text='Delete channel {0}'.format( self.channels_amount), command= lambda: self.del_channel(i)) self.del_ch_btn.bind("<Button-1>") self.del_ch_btn.place(x=5, y=140, width=100, height=30) self.server_host_label = Label(self.root, text="Server host") self.server_port_label = Label(self.root, text="Server port") self.raas_port_label = Label(self.root, text="Raas port") self.encoding_label = Label(self.root, text='Encoding') self.levenshtein_distance_label = Label(self.root, text='Levenshtein distance') self.window_time_label = Label(self.root, text='Window time') self.server_host_entity = Entry(self.root, width=20, bd=3) self.server_host_entity.insert(0, self.model_config['server_host']) self.server_port_entity = Entry(self.root, width=20, bd=3) self.server_port_entity.insert(0, self.model_config['server_port']) self.raas_port_entity = Entry(self.root, width=20, bd=3) self.raas_port_entity.insert(0, self.model_config['raas_port']) self.encoding_entry = Entry(self.root, width=20, bd=3) self.encoding_entry.insert(0, self.model_config['encoding']) self.levenshtein_distance_entry = Entry(self.root, width=20, bd=3) self.levenshtein_distance_entry.insert(0, self.model_config[ 'levenshtein_distance']) self.window_time_entry = Entry(self.root, width=20, bd=3) self.window_time_entry.insert(0, self.model_config['window_time']) self.var = IntVar() self.cfg_debug = self.model_config['debug'] if self.cfg_debug == 'True': self.var.set(1) else: self.var.set(0) self.check_debug = Checkbutton(self.root, text='Debug', variable=self.var) self.filter_var = IntVar() self.cfg_use_filter = self.model_config['use_filter'] if self.cfg_use_filter == 'True': self.filter_var.set(1) else: self.filter_var.set(0) self.check_use_filter = Checkbutton(self.root, text='Use filter', variable=self.filter_var) self.addBtn = Button(self.panelFrame, text='Add channel') self.saveBtn = Button(self.panelFrame, text='Save') self.quitBtn = Button(self.panelFrame, text='Quit') self.saveBtn.bind("<Button-1>", self.SaveFile) self.quitBtn.bind("<Button-1>", self.Quit) self.addBtn.bind("<Button-1>", self.add_channel) self.saveBtn.place(x=10, y=10, width=40, height=40) self.quitBtn.place(x=60, y=10, width=40, height=40) self.addBtn.place(x=220, y=10, width=80, height=40) self.server_host_label.place(x=20, y=80) self.server_host_entity.place(x=20, y=100) self.server_port_label.place(x=20, y=120) self.server_port_entity.place(x=20, y=140) self.raas_port_label.place(x=20, y=160) self.raas_port_entity.place(x=20, y=180) self.encoding_label.place(x=20, y=200) self.encoding_entry.place(x=20, y=220) self.check_debug.place(x=20, y=250) self.f = Frame(self.root, height=1, width=190, bg='grey') self.f.place(x=15, y=275) self.levenshtein_distance_label.place(x=20, y=280) self.levenshtein_distance_entry.place(x=20, y=300) self.window_time_label.place(x=20, y=320) self.window_time_entry.place(x=20, y=340) self.check_use_filter.place(x=20, y=370) def del_channel(self, numb): rwidth = self.root.winfo_width() rheight = self.root.winfo_height() if self.channels_num > 6: self.chanelFrame.config(width=self.chanelFrame.winfo_width() - 65) self.root.geometry("%dx%d" % (rwidth - 65, rheight)) if self.channels_num == 6: self.chanelFrame.config(width=self.chanelFrame.winfo_width() - 20) self.root.geometry("%dx%d" % (rwidth - 20, rheight)) dvar = self.tabs.tabs().index(self.tabs.select()) self.in_channel_text.pop(dvar) self.out_channel_text.pop(dvar) self.out_port_text.pop(dvar) self.channels_num -= 1 self.tabs.forget(self.tabs.select()) tabs_list = self.tabs.tabs() self.root.update() def add_channel(self, env): if self.channels_num > 15: tkMessageBox.showerror('Error', 'You can not add more than 16 channels') return False rwidth = self.root.winfo_width() rheight = self.root.winfo_height() if self.channels_num == 5: self.chanelFrame.config(width=self.chanelFrame.winfo_width() + 20) self.root.geometry("%dx%d" % (rwidth + 20, rheight)) if self.channels_num > 5: self.chanelFrame.config(width=self.chanelFrame.winfo_width() + 65) self.root.geometry("%dx%d" % (rwidth + 65, rheight)) self.f1 = Frame(self.tabs, height=290, width=350) self.tabs.add(self.f1, text='Channel {0}'.format(self.channels_amount + 1)) self.in_channel = Label(self.f1, text="In channel") self.out_port = Label(self.f1, text="Out port") self.out_channel = Label(self.f1, text="Out channel") self.in_channel_text.append(Entry(self.f1, width=20, bd=3)) self.out_port_text.append(Entry(self.f1, width=20, bd=3)) self.out_channel_text.append(Entry(self.f1, width=20, bd=3)) self.in_channel.place(x=5, y=10) self.in_channel_text[self.channels_num].place(x=5, y=30) self.out_port.place(x=5, y=50) self.out_port_text[self.channels_num].place(x=5, y=70) self.out_channel.place(x=5, y=90) self.out_channel_text[self.channels_num].place(x=5, y=110) self.del_ch_btn = Button(self.f1, text='Delete channel {0}'.format( self.channels_num + 1), command= lambda: self.del_channel(self.channels_num)) self.del_ch_btn.bind("<Button-1>") self.del_ch_btn.place(x=5, y=140, width=100, height=30) self.channels_num += 1 self.channels_amount += 1 def Quit(self, env): if tkMessageBox.askyesno('Quit', 'Whant to save config before quit?'): self.SaveFile(env) self.root.destroy() def quit_handler(self): if tkMessageBox.askyesno('Quit', 'Whant to save config before quit?'): self.save_handler() self.root.destroy() def validate_int(self, var, text, channel): if not var.isdigit(): tkMessageBox.showerror("Error", "Error in {1}. Value of field '{0}' must be int.".format(text, channel)) return False return True def validate_empty(self, var, text): if not var: tkMessageBox.showerror("Error", "Field {0} must be not empty.".format(text)) return False return True def validate_channels(self): if not self.channels_num: tkMessageBox.showerror("Error", "You must add at least one channel") return False return True def validate_change_field(self): self.validating_config = self.model.get_updated_config() self.flag = False if self.server_host_entity.get() != str(self.validating_config['server_host']): self.flag = True if self.server_port_entity.get() != str(self.validating_config['server_port']): self.flag = True if self.raas_port_entity.get() != str(self.validating_config['raas_port']): self.flag = True if self.encoding_entry.get() != str(self.validating_config['encoding']): self.flag = True if str(self.levenshtein_distance_entry.get()) != str(self.validating_config['levenshtein_distance']): self.flag = True if str(self.window_time_entry.get()) != str(self.validating_config['window_time']): self.flag = True self.tmp = IntVar() if self.validating_config['debug'] == 'True': self.tmp.set(1) else: self.tmp.set(0) if self.tmp.get() != self.var.get(): self.flag = True self.tmp_filter = IntVar() if self.validating_config['use_filter'] == 'True': self.tmp_filter.set(1) else: self.tmp_filter.set(0) if self.tmp_filter.get() != self.filter_var.get(): self.flag = True #TODO: add validating of channels if self.channels_num != self.channels_amount or self.channels_len != self.channels_num: return True for i in range(self.channels_num): if self.in_channel_text[i].get() != str(self.c[i]): self.flag = True if self.out_port_text[i].get() != str(self.model.get_channels()[ self.c[i]].out_port): self.flag = True if self.out_channel_text[i].get() != str(self.model.get_channels()[ self.c[i]].out_channel): self.flag = True return self.flag def validate_all(self): #if not self.validate_change_field(): # return False if not self.validate_channels(): return False if not self.validate_empty(self.server_host_entity.get(), 'Server host'): return False if not self.validate_empty(self.encoding_entry.get(), 'Encoding'): return False if not self.validate_empty(self.levenshtein_distance_entry.get(), 'Levenshtein distance'): return False if not self.validate_int(self.server_port_entity.get(), 'Server port', ''): return False if not self.validate_int(self.raas_port_entity.get(), 'Raas port', ''): return False if not self.validate_int(self.levenshtein_distance_entry.get(), 'Levenshtein distance', ''): return False if not self.validate_int(self.window_time_entry.get(), 'Window time', ''): return False for i in range(self.channels_num): if not self.validate_int(self.in_channel_text[i].get(), 'In channel', ' Channel {0}'.format(i + 1)): return False if not self.validate_int(self.out_port_text[i].get(), 'Out port', ' Channel {0}'.format(i + 1)): return False if not self.validate_int(self.out_channel_text[i].get(), 'Out channel', ' Channel {0}'.format(i + 1)): return False return True def SaveFile(self, env): self.save_handler() def save_handler(self): if not self.validate_all(): return False config = ConfigParser.RawConfigParser() config.add_section('Main') config.set('Main', 'server_host', self.server_host_entity.get()) config.set('Main', 'server_port', self.server_port_entity.get()) config.set('Main', 'raas_port', self.raas_port_entity.get()) result = 'False' if self.var.get(): result = 'True' config.set('Main', 'debug', result) config.set('Main', 'encoding', self.encoding_entry.get()) config.set('Main', 'levenshtein_distance', self.levenshtein_distance_entry.get()) config.set('Main', 'window_time', self.window_time_entry.get()) result_filter = 'False' if self.filter_var.get(): result_filter = 'True' config.set('Main', 'use_filter', result_filter) for i in range(self.channels_num): config.add_section('Channel{0}'.format(i + 1)) config.set('Channel{0}'.format(i + 1), 'in_channel', self.in_channel_text[i].get()) config.set('Channel{0}'.format(i + 1), 'out_port', self.out_port_text[i].get()) config.set('Channel{0}'.format(i + 1), 'out_channel', self.out_channel_text[i].get()) with open(self.config_route, 'wb') as configfile: config.write(configfile) tkMessageBox.showinfo("Info", "Successfully saved.") def run(self): self.root.mainloop()
def __init__(self): self.tasks = None self.mainTerminated = None self.results = None self.awaited = None self.reqParser = RawQueryParser() self.defaultCfg = defaultCfg self.stlist = STAT_TYPES.keys() # set main window parameters mainWindow = SmartTk() mainWindow.title(_WindowLabels.window_title) self.root = mainWindow mainWindow.minsize(650, 450) # there are two frames with different finctions. # In fact, they work separately but use the same set of settings. generalframe = SettingHybrid(mainWindow) tabframe = Frame(mainWindow) self.settings = generalframe nb = Notebook(tabframe) nbUrlTab = Frame() nbFileEditingTab = Frame() nbStatTab = StatTypeFrame() self.statTab = nbStatTab self.homeDir = None qField = ParameterInputText(nbFileEditingTab) self.qField = qField qReadingButton = Button(nbFileEditingTab, text = u'OK', command = self.get_request_from_raw_query_window) self.urlText = CopyPasteText(nbUrlTab) urlButton = Button(nbUrlTab, text = u'OK', command = self.get_query_from_url_window) self.urlText.pack(fill=BOTH, expand=1) urlButton.pack() self.b1 = urlButton self.b2 = qReadingButton nb.add(nbFileEditingTab, text = tabs['file']) nb.add(nbUrlTab, text = tabs['url']) nb.add(nbStatTab, text = tabs['st']) minTabFrameWidth = 0 for tab in nb.tabs(): minTabFrameWidth += len(nb.tab(tab)['text']) self.root.config(width = minTabFrameWidth + 200) qField.pack(fill=BOTH, expand=1) qReadingButton.pack() #nbUrlTab.pack() nb.pack(fill=BOTH, expand=1) self.nb = nb # to manage tabs generalframe.pack(expand=0, side = 'left') tabframe.pack(fill=BOTH, expand=1) generalframe.bind_to_statistics_frame(nbStatTab) self.enable_keyboard_managing() self._add_menu()