Пример #1
0
 def test_invalid_value_domain(self):
     v = BooleanVar(self.root, name='name')
     self.root.globalsetvar('name', 'value')
     with self.assertRaises(TclError):
         v.get()
     self.root.globalsetvar('name', '1.0')
     with self.assertRaises(TclError):
         v.get()
Пример #2
0
 def test_invalid_value_domain(self):
     v = BooleanVar(self.root, name="name")
     self.root.globalsetvar("name", "value")
     with self.assertRaises(TclError):
         v.get()
     self.root.globalsetvar("name", "1.0")
     with self.assertRaises(TclError):
         v.get()
Пример #3
0
 def test_invalid_value_domain(self):
     v = BooleanVar(self.root, name='name')
     self.root.globalsetvar('name', 'value')
     with self.assertRaises(TclError):
         v.get()
     self.root.globalsetvar('name', '1.0')
     with self.assertRaises(TclError):
         v.get()
Пример #4
0
 def test_invalid_value_domain(self):
     v = BooleanVar(self.root, name="name")
     self.root.globalsetvar("name", "value")
     with self.assertRaises(TclError):
         v.get()
     self.root.globalsetvar("name", "1.0")
     with self.assertRaises(TclError):
         v.get()
Пример #5
0
 def test_invalid_value_domain(self):
     false = 0 if self.root.wantobjects() else "0"
     v = BooleanVar(self.root, name="name")
     with self.assertRaises(TclError):
         v.set("value")
     self.assertEqual(self.root.globalgetvar("name"), false)
     self.root.globalsetvar("name", "value")
     with self.assertRaises(TclError):
         v.get()
     self.root.globalsetvar("name", "1.0")
     with self.assertRaises(TclError):
         v.get()
Пример #6
0
 def test_invalid_value_domain(self):
     false = 0 if self.root.wantobjects() else "0"
     v = BooleanVar(self.root, name="name")
     with self.assertRaises(TclError):
         v.set("value")
     self.assertEqual(self.root.globalgetvar("name"), false)
     self.root.globalsetvar("name", "value")
     with self.assertRaises(TclError):
         v.get()
     self.root.globalsetvar("name", "1.0")
     with self.assertRaises(TclError):
         v.get()
Пример #7
0
class Example(Frame):
  
    def __init__(self, parent):
        Frame.__init__(self, parent)   
         
        self.parent = parent
        
        self.initUI()
        
        
    def initUI(self):
      
        self.parent.title("Checkbutton")

        self.pack(fill=BOTH, expand=True)
        
        self.var = BooleanVar()
        
        cb = Checkbutton(self, text="Show title",
            variable=self.var, command=self.onClick)
        cb.select()
        cb.place(x=50, y=30)
        

    def onClick(self):
       
        if self.var.get() == True:
            self.master.title("Checkbutton")
        else:
            self.master.title("")
Пример #8
0
class MenuItem(object):
    def __init__(self, menu, title, **kwargs):
        self._menu = menu
        if kwargs.get('checkbox'):
            # Checkbox menu item
            self._checkvar = BooleanVar()
            self._checkvar.set(kwargs.get('checked', False))

            self._menu._ctrl.add_checkbutton(label=title, command=self._on_check, variable=self._checkvar)
        else:
            # NOTE: For whatever reason, lambdas do not work in this case...
            self._menu._ctrl.add_command(label=title, command=self._on_click)

        if kwargs.get('on_click'):
            self.on_click = kwargs['on_click']

    def _on_check(self):
        """Handler for keeping on_click virtual with checkbox option"""
        self.on_click(self._checkvar.get())

    def _on_click(self):
        """Handler for keeping on_click virtual"""
        self.on_click()

    def on_click(self):
        pass

    def __exit__(self, *args):
        pass

    def __enter__(self, *args):
        return self
Пример #9
0
class MeasureFrame(LabelFrame):
    def __init__(self, master, tracker, text="Measuring", *args, **kwargs):
        LabelFrame.__init__(self, master, text=text, *args, **kwargs)
        self.tracker = tracker

        self.config_frame = NamedEntryFrame(self, (OBS_INTERVAL,
                                                   NUM_SAMPLES,
                                                   NUM_OBSS),
                                            parsers={OBS_INTERVAL: float,
                                                     NUM_SAMPLES: int,
                                                     NUM_OBSS: int})
        self.config_frame.grid()

        self.save_frame = LabelFrame(self, text="Saving")
        self.dest_selector = FileSelectionFrame(self.save_frame,
                                                ask_mode="save")
        self.dest_selector.grid(row=0, column=0, columnspan=2)
        self.save_button = Button(self.save_frame, text="Save",
                                  command=bg_caller(self.save))
        self.save_button.grid(row=1, column=0)
        self.appending_var = BooleanVar()
        self.append_checkbutton = Checkbutton(self.save_frame, text="Append",
                                              variable=self.appending_var)
        self.append_checkbutton.grid(row=1, column=1)
        self.save_frame.grid()

    def measure(self, only_accurate=True):
        try:
            interval = self.config_frame.get(OBS_INTERVAL)
            samples = self.config_frame.get(NUM_SAMPLES)
            num_obss = self.config_frame.get(NUM_OBSS)
        except ValueError:
            logger.error("Could not parse input fields.")
        data = self.tracker.measure(observation_interval=interval,
                                    samples_per_observation=samples,
                                    number_of_observations=num_obss)
        if only_accurate:
            accurate_data = [point for point in data
                             if point.status == point.DATA_ACCURATE]
            num_invalid = len(data) - len(accurate_data)
            if num_invalid > 0:
                logger.warning("Hiding {} inaccurate data points."
                               .format(num_invalid))
            return accurate_data
        else:
            return data

    def save(self, only_accurate=True):
        dest = self.dest_selector.path_var.get()
        if not dest:
            logger.error("Must select a destination file.")
            return

        data = self.measure(only_accurate=only_accurate)
        w = csv.writer(open(dest, 'a' if self.appending_var.get() else 'w'))
        for point in data:
            w.writerow((point.time, point.position.r,
                        point.position.theta, point.position.phi))

        logger.info("Saved measurements into {!r}".format(dest))
Пример #10
0
class Example(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)

        self.parent = parent

        self.initUI()

    def initUI(self):

        self.parent.title("Checkbutton")

        self.pack(fill=BOTH, expand=True)
        self.var = BooleanVar()

        cb = Checkbutton(self,
                         text="Show title",
                         variable=self.var,
                         command=self.onClick)
        cb.select()
        cb.place(x=50, y=50)

    def onClick(self):

        if self.var.get() == True:
            self.master.title("Checkbutton")
        else:
            self.master.title("")
Пример #11
0
 def test_get(self):
     v = BooleanVar(self.root, True, "name")
     self.assertIs(v.get(), True)
     self.root.globalsetvar("name", "0")
     self.assertIs(v.get(), False)
     self.root.globalsetvar("name", 42 if self.root.wantobjects() else 1)
     self.assertIs(v.get(), True)
     self.root.globalsetvar("name", 0)
     self.assertIs(v.get(), False)
     self.root.globalsetvar("name", 42L if self.root.wantobjects() else 1L)
     self.assertIs(v.get(), True)
     self.root.globalsetvar("name", 0L)
     self.assertIs(v.get(), False)
     self.root.globalsetvar("name", "on")
     self.assertIs(v.get(), True)
     self.root.globalsetvar("name", u"0")
     self.assertIs(v.get(), False)
     self.root.globalsetvar("name", u"on")
     self.assertIs(v.get(), True)
Пример #12
0
 def test_get(self):
     v = BooleanVar(self.root, True, "name")
     self.assertIs(v.get(), True)
     self.root.globalsetvar("name", "0")
     self.assertIs(v.get(), False)
     self.root.globalsetvar("name", 42 if self.root.wantobjects() else 1)
     self.assertIs(v.get(), True)
     self.root.globalsetvar("name", 0)
     self.assertIs(v.get(), False)
     self.root.globalsetvar("name", 42L if self.root.wantobjects() else 1L)
     self.assertIs(v.get(), True)
     self.root.globalsetvar("name", 0L)
     self.assertIs(v.get(), False)
     self.root.globalsetvar("name", "on")
     self.assertIs(v.get(), True)
     self.root.globalsetvar("name", u"0")
     self.assertIs(v.get(), False)
     self.root.globalsetvar("name", u"on")
     self.assertIs(v.get(), True)
Пример #13
0
 def test_default(self):
     v = BooleanVar(self.root)
     self.assertEqual(False, v.get())
Пример #14
0
class FontChooser(ttkSimpleDialog.Dialog):
    BASIC = 1
    ALL = 2

    def __init__(self, parent, defaultfont=None, showstyles=None):
        self._family = StringVar(value="Century Schoolbook L")
        self._sizeString = StringVar(value="20")
        self._weight = StringVar(value=tkFont.NORMAL)
        self._slant = StringVar(value=tkFont.ROMAN)
        self._isUnderline = BooleanVar(value=False)
        self._isOverstrike = BooleanVar(value=False)
        if defaultfont:
            self._initialize(defaultfont)

        self._currentFont = tkFont.Font(font=self.getFontTuple())

        self._showStyles = showstyles

        self.sampleText = None

        ttkSimpleDialog.Dialog.__init__(self, parent, "Font Chooser")

    def _initialize(self, aFont):
        if not isinstance(aFont, tkFont.Font):
            aFont = tkFont.Font(font=aFont)

        fontOpts = aFont.actual()

        self._family.set(fontOpts["family"])
        self._sizeString.set(fontOpts["size"])
        self._weight.set(fontOpts["weight"])
        self._slant.set(fontOpts["slant"])
        self._isUnderline.set(fontOpts["underline"])
        self._isOverstrike.set(fontOpts["overstrike"])

    def body(self, master):
        theRow = 0

        ttkLabel(master, text="Font Family").grid(row=theRow, column=0)
        ttkLabel(master, text="Font Size").grid(row=theRow, column=2)

        theRow += 1

        # Font Families
        fontList = ttk.Combobox(master, height=10, textvariable=self._family)
        fontList.grid(row=theRow, column=0, columnspan=2, sticky=N + S + E + W, padx=10)
        rawfamilyList = list(tkFont.families())
        rawfamilyList.sort()
        # print rawfamilyList
        familyList = []
        for family in rawfamilyList:
            if family[0] == "@":
                continue
            familyList.append(family)
        fontList.configure(values=familyList)
        fontList.bind("<<ComboboxSelected>>", self.selectionChanged)

        # Font Sizes
        sizeList = ttk.Combobox(master, height=10, width=5, textvariable=self._sizeString)
        sizeList.grid(row=theRow, column=2, columnspan=2, sticky=N + S + E + W, padx=10)
        sizes = []
        for size in xrange(10, 50):
            sizes.append(str(size))
        sizeList.configure(values=sizes)
        sizeList.bind("<<ComboboxSelected>>", self.selectionChanged)

        # Styles
        if self._showStyles is not None:
            theRow += 1
            if self._showStyles in (FontChooser.ALL, FontChooser.BASIC):
                ttkLabel(master, text="Styles", anchor=W).grid(row=theRow, column=0, pady=10, sticky=W)

                theRow += 1

                ttkCheckbutton(
                    master,
                    text="bold",
                    command=self.selectionChanged,
                    offvalue="normal",
                    onvalue="bold",
                    variable=self._weight,
                ).grid(row=theRow, column=0)
                ttkCheckbutton(
                    master,
                    text="italic",
                    command=self.selectionChanged,
                    offvalue="roman",
                    onvalue="italic",
                    variable=self._slant,
                ).grid(row=theRow, column=1)

        if self._showStyles == FontChooser.ALL:
            ttkCheckbutton(
                master,
                text="underline",
                command=self.selectionChanged,
                offvalue=False,
                onvalue=True,
                variable=self._isUnderline,
            ).grid(row=theRow, column=2)
            ttkCheckbutton(
                master,
                text="overstrike",
                command=self.selectionChanged,
                offvalue=False,
                onvalue=True,
                variable=self._isOverstrike,
            ).grid(row=theRow, column=3)

            # Sample Text
            theRow += 1

            ttkLabel(master, text="Sample Text", anchor=W).grid(row=theRow, column=0, pady=10, sticky=W)

            theRow += 1

            self.sampleText = Text(master, height=11, width=70)
            self.sampleText.insert(INSERT, "ABC...XYZ\nabc....xyz", "fontStyle")
            self.sampleText.config(state=DISABLED)
            self.sampleText.tag_config("fontStyle", font=self._currentFont)
            self.sampleText.grid(row=theRow, column=0, columnspan=4, padx=10)

    def apply(self):
        self.result = self.getFontTuple()

    def selectionChanged(self, something=None):
        self._currentFont.configure(
            family=self._family.get(),
            size=self._sizeString.get(),
            weight=self._weight.get(),
            slant=self._slant.get(),
            underline=self._isUnderline.get(),
            overstrike=self._isOverstrike.get(),
        )

        if self.sampleText:
            self.sampleText.tag_config("fontStyle", font=self._currentFont)

    def getFontString(self):
        family = self._family.get()
        size = int(self._sizeString.get())

        styleList = []
        if self._weight.get() == tkFont.BOLD:
            styleList.append("bold")
        if self._slant.get() == tkFont.ITALIC:
            styleList.append("italic")
        if self._isUnderline.get():
            styleList.append("underline")
        if self._isOverstrike.get():
            styleList.append("overstrike")

        if len(styleList) == 0:
            return family + " " + str(size)
        else:
            xx = ""
            for x in styleList:
                xx = xx + " " + x
            return family + " " + str(size) + " " + xx

    def getFontTuple(self):
        family = self._family.get()
        size = int(self._sizeString.get())

        styleList = []
        if self._weight.get() == tkFont.BOLD:
            styleList.append("bold")
        if self._slant.get() == tkFont.ITALIC:
            styleList.append("italic")
        if self._isUnderline.get():
            styleList.append("underline")
        if self._isOverstrike.get():
            styleList.append("overstrike")

        if len(styleList) == 0:
            return family, size
        else:
            return family, size, " ".join(styleList)
Пример #15
0
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()
Пример #16
0
 def test_default(self):
     v = BooleanVar(self.root)
     self.assertEqual(False, v.get())
Пример #17
0
class MenuBar(Menu):
    def __init__(self, master, visible=True):

        self.root = master

        Menu.__init__(self, master.root)

        self.sc3_plugins = BooleanVar()
        self.sc3_plugins.set(SC3_PLUGINS)

        self.listening = BooleanVar()
        self.listening.set(False)

        # Set font

        self.config(font="CodeFont")

        # File menu

        filemenu = Menu(self, tearoff=0)
        filemenu.add_command(label="New Document",
                             command=self.root.newfile,
                             accelerator="Ctrl+N")
        filemenu.add_command(label="Open",
                             command=self.root.openfile,
                             accelerator="Ctrl+O")
        filemenu.add_command(label="Save",
                             command=self.root.save,
                             accelerator="Ctrl+S")
        filemenu.add_command(label="Save As...", command=self.root.saveAs)
        self.add_cascade(label="File", menu=filemenu)

        # Edit menu

        editmenu = Menu(self, tearoff=0)
        editmenu.add_command(label="Undo",
                             command=self.root.undo,
                             accelerator="Ctrl+Z")
        editmenu.add_command(label="Redo",
                             command=self.root.redo,
                             accelerator="Ctrl+Y")
        editmenu.add_separator()
        editmenu.add_command(label="Cut",
                             command=self.root.edit_cut,
                             accelerator="Ctrl+X")
        editmenu.add_command(label="Copy",
                             command=self.root.edit_copy,
                             accelerator="Ctrl+C")
        editmenu.add_command(label="Paste",
                             command=self.root.edit_paste,
                             accelerator="Ctrl+V")
        editmenu.add_command(label="Select All",
                             command=self.root.selectall,
                             accelerator="Ctrl+A")
        editmenu.add_separator()
        editmenu.add_command(label="Increase Font Size",
                             command=self.root.zoom_in,
                             accelerator="Ctrl+=")
        editmenu.add_command(label="Decrease Font Size",
                             command=self.root.zoom_out,
                             accelerator="Ctrl+-")
        editmenu.add_separator()
        editmenu.add_command(label="Toggle Menu",
                             command=self.root.toggle_menu,
                             accelerator="Ctrl+M")
        editmenu.add_checkbutton(label="Toggle Window Transparency",
                                 command=self.root.toggle_transparency,
                                 variable=self.root.transparent)
        self.add_cascade(label="Edit", menu=editmenu)

        # Code menu

        ctrl = "Command" if SYSTEM == MAC_OS else "Ctrl"
        # Note: Alt renders properly to look like Option, so we don't need a
        # conditional for those shortcuts

        codemenu = Menu(self, tearoff=0)
        codemenu.add_command(label="Evaluate Block",
                             command=self.root.exec_block,
                             accelerator="{}+Return".format(ctrl))
        codemenu.add_command(label="Evaluate Line",
                             command=self.root.exec_line,
                             accelerator="Alt+Return")
        codemenu.add_command(label="Clear Scheduling Clock",
                             command=self.root.killall,
                             accelerator="{}+.".format(ctrl))
        codemenu.add_separator()
        codemenu.add_command(label="Toggle Console",
                             command=self.root.toggle_console)
        codemenu.add_command(label="Export Console Log",
                             command=self.root.export_console)
        codemenu.add_separator()
        codemenu.add_checkbutton(label="Use SC3 Plugins",
                                 command=self.root.toggle_sc3_plugins,
                                 variable=self.sc3_plugins)
        codemenu.add_separator()
        codemenu.add_checkbutton(label="Listen for connections",
                                 command=self.allow_connections,
                                 variable=self.listening)
        self.add_cascade(label="Language", menu=codemenu)

        # Help

        helpmenu = Menu(self, tearoff=0)
        helpmenu.add_command(label="Visit FoxDot Homepage",
                             command=self.root.openhomepage)
        helpmenu.add_command(label="Documentation",
                             command=self.root.opendocumentation)
        helpmenu.add_separator()
        helpmenu.add_command(label="Open Samples Folder",
                             command=self.root.open_samples_folder)
        helpmenu.add_command(label="Open config file (advanced)",
                             command=self.root.open_config_file)
        ##        settingsmenu.add_command(label="Change Colours...",   command=self.root.toggleMenu)
        self.add_cascade(label="Help & Settings", menu=helpmenu)

        # Tutorials

        tutorialmenu = Menu(self, tearoff=0)

        for tutorial in GET_TUTORIAL_FILES():

            filename = os.path.basename(tutorial).replace(".py", "")

            data = filename.split("_")

            num = data[0]
            name = " ".join(data[1:]).title()

            tutorialmenu.add_command(label="Load Tutorial {}: {}".format(
                num, name),
                                     command=partial(self.root.loadfile,
                                                     tutorial))

        self.add_cascade(label="Tutorials", menu=tutorialmenu)

        # Add to root

        self.visible = visible

        if self.visible:

            master.root.config(menu=self)

    def toggle(self):
        self.root.root.config(menu=self if not self.visible else 0)
        self.visible = not self.visible
        return

    def allow_connections(self):
        """ Starts a new instance of ServerManager.TempoServer and connects it with the clock """
        if self.listening.get() == True:
            Clock = FoxDotCode.namespace["Clock"]
            Clock.start_tempo_server(TempoServer)
            print("Listening for connections on {}".format(Clock.tempo_server))
        else:
            Clock = FoxDotCode.namespace["Clock"]
            Clock.kill_tempo_server()
            print("Closed connections")
        return
Пример #18
0
class SearchEngine:
    """Handles searching a text widget for Find, Replace, and Grep."""

    def __init__(self, root):
        '''Initialize Variables that save search state.

        The dialogs bind these to the UI elements present in the dialogs.
        '''
        self.root = root  # need for report_error()
        self.patvar = StringVar(root, '')   # search pattern
        self.revar = BooleanVar(root, False)   # regular expression?
        self.casevar = BooleanVar(root, False)   # match case?
        self.wordvar = BooleanVar(root, False)   # match whole word?
        self.wrapvar = BooleanVar(root, True)   # wrap around buffer?
        self.backvar = BooleanVar(root, False)   # search backwards?

    # Access methods

    def getpat(self):
        return self.patvar.get()

    def setpat(self, pat):
        self.patvar.set(pat)

    def isre(self):
        return self.revar.get()

    def iscase(self):
        return self.casevar.get()

    def isword(self):
        return self.wordvar.get()

    def iswrap(self):
        return self.wrapvar.get()

    def isback(self):
        return self.backvar.get()

    # Higher level access methods

    def setcookedpat(self, pat):
        "Set pattern after escaping if re."
        # called only in SearchDialog.py: 66
        if self.isre():
            pat = re.escape(pat)
        self.setpat(pat)

    def getcookedpat(self):
        pat = self.getpat()
        if not self.isre():  # if True, see setcookedpat
            pat = re.escape(pat)
        if self.isword():
            pat = r"\b%s\b" % pat
        return pat

    def getprog(self):
        "Return compiled cooked search pattern."
        pat = self.getpat()
        if not pat:
            self.report_error(pat, "Empty regular expression")
            return None
        pat = self.getcookedpat()
        flags = 0
        if not self.iscase():
            flags = flags | re.IGNORECASE
        try:
            prog = re.compile(pat, flags)
        except re.error as what:
            args = what.args
            msg = args[0]
            col = arg[1] if len(args) >= 2 else -1
            self.report_error(pat, msg, col)
            return None
        return prog

    def report_error(self, pat, msg, col=-1):
        # Derived class could override this with something fancier
        msg = "Error: " + str(msg)
        if pat:
            msg = msg + "\nPattern: " + str(pat)
        if col >= 0:
            msg = msg + "\nOffset: " + str(col)
        tkMessageBox.showerror("Regular expression error",
                               msg, master=self.root)

    def search_text(self, text, prog=None, ok=0):
        '''Return (lineno, matchobj) or None for forward/backward search.

        This function calls the right function with the right arguments.
        It directly return the result of that call.

        Text is a text widget. Prog is a precompiled pattern.
        The ok parameteris a bit complicated as it has two effects.

        If there is a selection, the search begin at either end,
        depending on the direction setting and ok, with ok meaning that
        the search starts with the selection. Otherwise, search begins
        at the insert mark.

        To aid progress, the search functions do not return an empty
        match at the starting position unless ok is True.
        '''

        if not prog:
            prog = self.getprog()
            if not prog:
                return None # Compilation failed -- stop
        wrap = self.wrapvar.get()
        first, last = get_selection(text)
        if self.isback():
            if ok:
                start = last
            else:
                start = first
            line, col = get_line_col(start)
            res = self.search_backward(text, prog, line, col, wrap, ok)
        else:
            if ok:
                start = first
            else:
                start = last
            line, col = get_line_col(start)
            res = self.search_forward(text, prog, line, col, wrap, ok)
        return res

    def search_forward(self, text, prog, line, col, wrap, ok=0):
        wrapped = 0
        startline = line
        chars = text.get("%d.0" % line, "%d.0" % (line+1))
        while chars:
            m = prog.search(chars[:-1], col)
            if m:
                if ok or m.end() > col:
                    return line, m
            line = line + 1
            if wrapped and line > startline:
                break
            col = 0
            ok = 1
            chars = text.get("%d.0" % line, "%d.0" % (line+1))
            if not chars and wrap:
                wrapped = 1
                wrap = 0
                line = 1
                chars = text.get("1.0", "2.0")
        return None

    def search_backward(self, text, prog, line, col, wrap, ok=0):
        wrapped = 0
        startline = line
        chars = text.get("%d.0" % line, "%d.0" % (line+1))
        while 1:
            m = search_reverse(prog, chars[:-1], col)
            if m:
                if ok or m.start() < col:
                    return line, m
            line = line - 1
            if wrapped and line < startline:
                break
            ok = 1
            if line <= 0:
                if not wrap:
                    break
                wrapped = 1
                wrap = 0
                pos = text.index("end-1c")
                line, col = map(int, pos.split("."))
            chars = text.get("%d.0" % line, "%d.0" % (line+1))
            col = len(chars) - 1
        return None
Пример #19
0
class SearchEngine:

    def __init__(self, root):
        self.root = root
        # State shared by search, replace, and grep;
        # the search dialogs bind these to UI elements.
        self.patvar = StringVar(root)           # search pattern
        self.revar = BooleanVar(root)           # regular expression?
        self.casevar = BooleanVar(root)         # match case?
        self.wordvar = BooleanVar(root)         # match whole word?
        self.wrapvar = BooleanVar(root)         # wrap around buffer?
        self.wrapvar.set(1)                     # (on by default)
        self.backvar = BooleanVar(root)         # search backwards?

    # Access methods

    def getpat(self):
        return self.patvar.get()

    def setpat(self, pat):
        self.patvar.set(pat)

    def isre(self):
        return self.revar.get()

    def iscase(self):
        return self.casevar.get()

    def isword(self):
        return self.wordvar.get()

    def iswrap(self):
        return self.wrapvar.get()

    def isback(self):
        return self.backvar.get()

    # Higher level access methods

    def getcookedpat(self):
        pat = self.getpat()
        if not self.isre():
            pat = re.escape(pat)
        if self.isword():
            pat = r"\b%s\b" % pat
        return pat

    def getprog(self):
        pat = self.getpat()
        if not pat:
            self.report_error(pat, "Empty regular expression")
            return None
        pat = self.getcookedpat()
        flags = 0
        if not self.iscase():
            flags = flags | re.IGNORECASE
        try:
            prog = re.compile(pat, flags)
        except re.error, what:
            try:
                msg, col = what
            except:
                msg = str(what)
                col = -1
            self.report_error(pat, msg, col)
            return None
        return prog
Пример #20
0
class CellularAutomataMain(Tk):
    GRID_WIDTH_PX = DisplayConfiguration.CA_CANVAS_MAX_PIX_X
    GRID_HEIGHT_PX = DisplayConfiguration.CA_CANVAS_MAX_PIX_Y

    def __init__(self, width_cells=DisplayConfiguration.DEFAULT_WIDTH, *args, **kwargs):
        Tk.__init__(self, *args, **kwargs)
        self.resizable(width=False, height=False)
        self.state = {'rules': None, 'rules_file': None, 'grid': None}

        self.random_start = BooleanVar(self)
        self.random_start.trace('w', self.random_start_callback)

        #Load blank grid
        self.width_cells = width_cells
        self.height_cells = width_cells  # Default setting should probably have the grid be square.
        canvas_width = self.GRID_WIDTH_PX-80
        canvas_height = self.GRID_HEIGHT_PX-80
        self.state['grid'] = build_blank_grid(width_cells, width_cells)
        self.grid_display = GridDisplay(self, self.state['grid'],
                                        self.GRID_WIDTH_PX, self.GRID_HEIGHT_PX,
                                        width=canvas_width, height=canvas_height, relief=GROOVE, bd=4)
        self.grid_display.grid(row=0, column=0, padx=20, pady=20)

        #Build top menus
        self.menubar = Menu(self)
        try:
            self.config(menu=self.Menu)
        except AttributeError:
            self.tk.call(self, 'config', '-menu', self.menubar)
        self.file_menu = Menu(self, tearoff=False)
        self.file_menu.add_command(label="Load Ruleset", command=self.load_dialogue)
        self.file_menu.add_separator()
        self.file_menu.add_command(label="Save Automata (Image)", command=self.save_image_dialogue)
        self.file_menu.add_separator()
        self.file_menu.add_command(label="Quit", command=self.quit)
        self.menubar.add_cascade(menu=self.file_menu, label='File')

        self.config_menu = Menu(self, tearoff=False)
        self.config_menu.add_command(label='Set Dimensions', command=self.config_dimensions)
        self.config_menu.add_checkbutton(label='Set Grid Wrap')
        self.config_menu.add_checkbutton(label='Random Start Row', variable=self.random_start)
        self.bg_color_menu = self.build_selector_menu(GridDisplay.ALLOWED_COLORS, self.grid_display.set_bg_color,
                                                      lambda: self.grid_display.draw_grid(self.state['grid']), 'white')
        self.fill_color_menu = self.build_selector_menu(GridDisplay.ALLOWED_COLORS, self.grid_display.set_fill_color,
                                                        lambda: self.grid_display.draw_grid(self.state['grid']), 'black')
        self.config_menu.add_cascade(menu=self.bg_color_menu, label="Set Background Color...")
        self.config_menu.add_cascade(menu=self.fill_color_menu, label="Set Fill Color...")
        self.config_menu.add_separator()
        self.config_menu.add_command(label='Configure Plug-ins')
        self.plugin_menu = Menu(self)
        self.config_menu.add_cascade(menu=self.plugin_menu, label="Plugins...")
        self.menubar.add_cascade(menu=self.config_menu, label='Configure')
        self.menubar.add_command(label="About", command=self.about)

        #Load status bar
        self.status_bar_var = StringVar(self)
        self.status_bar_var.set('Initialized.')
        self.status_bar = Label(self, textvar=self.status_bar_var, relief=SUNKEN, justify=LEFT, anchor=W)
        self.status_bar.grid(row=1, column=0, sticky="EW", padx=2, pady=2)


        #Build plugin manager
        disp_logger.info('Loading plug-in manager')
        self.status_bar_var.set('Loading plug-in manager...')
        self.plugin_manager = PluginManager()
        self.plugin_manager.setPluginPlaces(['../plugins/'])
        self.plugin_manager.collectPlugins()
        disp_logger.info('Plug-in manager loaded. {} plug-ins were loaded.'
                         ''.format(len(self.plugin_manager.getAllPlugins())))

    def load_dialogue(self):
        new_rule_filename = tkFileDialog.askopenfilename(parent=self, title='Open Rule File', defaultextension=".txt",
                                                         filetypes=[('Rules Files', '*.txt'), ('All Files', '*')])
        if not new_rule_filename:
            return
        try:
            self.load(new_rule_filename)
        except:
            disp_logger.exception('Faulted loading rules file!')

    def save_image_dialogue(self):
        automata_image_filename = tkFileDialog.asksaveasfilename(parent=self, title='Save Automata Image',
                                                                 defaultextension='.eps',
                                                                 filetypes=[('Postscript', '.eps'),
                                                                            ('PNG', '.png'),
                                                                            ('JPEG', '.jpg')])
        if not automata_image_filename:
            return
        try:

            #TODO: Should we be converting, or should I have a local image representation instead?
            if not automata_image_filename.endswith('.eps'):
                self.grid_display.postscript(file='tmp.eps')
                img = Image.open('tmp.eps')
                img.save(automata_image_filename)
                os.remove('tmp.eps')
            else:
                self.grid_display.postscript(file=automata_image_filename)
            self.status_bar_var.set('Saved automata image file as: {}'.format(automata_image_filename))
        except:
            disp_logger.exception('Faulted saving automata image!')

    def load(self, rule_file):
        disp_logger.info('Attempting to load new rules file: {}'.format(rule_file))
        rules = load_rules(rule_file)
        self.state['rules'] = rules
        self.state['rules_file'] = rule_file
        self._build_grid(rules)
        self.status_bar_var.set('Loaded rules file: {}'.format(rule_file))

    def _build_grid(self, rules):
        grid = []
        if self.random_start.get():
            start_row = build_random_start_row(self.width_cells)
        else:
            start_row = build_default_start_row(self.width_cells)
        grid.append(start_row)
        grid.extend(evolve_system_multi(start_row, rules, self.height_cells))
        self.state['grid'] = grid
        self.grid_display.draw_grid(grid)

    def config_dimensions(self):
        new_width, new_height = DimensionsDialog(self, title='Set Automata Dimensions',
                                                 prompt='Set Automata Dimensions', x_name='Width', y_name='Height',
                                                 x_default=self.width_cells, y_default=self.height_cells)
        if not new_width or not new_height:
            return
        disp_logger.info('Resizing automata to new width: {}, height: {}'.format(new_width, new_height))
        self.width_cells = new_width
        self.height_cells = new_height
        self._build_grid(self.state['rules'])


    def random_start_callback(self, *args):
        self._build_grid(self.state['rules'])

    @staticmethod
    def about():
        tkMessageBox.showinfo('About', '{app} ({ver})\nby {auth}, 2014'
                                       ''.format(ver=__version__, auth=__author__, app=__application_name__))

    def build_selector_menu(self, choices, set_fxn, update_fxn=None, default=None):
        new_menu = Menu(self)
        choice_map = {}

        def build_selector_trace(var):
            def callback(*args):
                set_fxn(choice_map[var.get()])
                if update_fxn:
                    update_fxn()
            return callback

        if not default:
            default = choices[0]
        new_var = StringVar(new_menu)
        new_var.set(str(default))
        new_var.trace('w', build_selector_trace(new_var))
        for choice in choices:
            choice_map[str(choice)] = choice
            new_menu.add_radiobutton(label=str(choice).capitalize(), variable=new_var, value=str(choice))
        return new_menu
Пример #21
0
class App(Frame):
    def __init__(self, master=None):
        self.master = master
        Frame.__init__(self, master, relief=SUNKEN, bd=2)

        self.gcode = []
        self.slicing = False
        self.printing = False
        self.connected = False
        self.monitorTemp = False
        self.paused = False
        self.sdpresent = False
        self.sdlisting = False
        self.sdchecking = False
        self.sdprinting = False
        self.sdpaused = False
        self.sduploading = False
        self.sdbytes = 0
        self.sdmaxbytes = 0
        self.insidelisting = False
        self.readingFirmware = False
        self.sdfiles = []
        self.bedtemp = float(0)
        self.bedtarget = float(0)
        self.exttemp = float(0)
        self.exttarget = float(0)
        self.acceleration = 0
        self.m114count = 0
        self.speedcount = 0
        self.location = [0, 0, 0, 0]
        self.pausePoint = [0, 0, 0, 0]
        self.percent = 0.0
        self.ets = "??"
        self.gcodeInfo = None
        self.GCodeFile = None
        self.StlFile = None
        self.Profile = None
        self.printStartLine = 0
        self.startTime = 0
        self.endTime = 0
        self.elapsedTime = 0
        self.FanSpeed = 0
        self.FeedMultiply = 100
        self.ExtrudeMultiply = 100

        self.timingReport = None
        self.filamentReport = None
        self.measurementsReport = None

        self.macroButtons = None

        self.rpt1re = re.compile(" *T:([0-9\.]+) *E:[0-9\.]+ *B:([0-9\.]+)")
        self.rpt2re = re.compile(" *T:([0-9\.]+) *E:[0-9\.]+ *W:.*")
        self.locrptre = re.compile("^X:([0-9\.\-]+)Y:([0-9\.\-]+)Z:([0-9\.\-]+)E:([0-9\.\-]+) *Count")
        self.speedrptre = re.compile("Fan speed:([0-9]+) Feed Multiply:([0-9]+) Extrude Multiply:([0-9]+)")

        self.sdre = re.compile("SD printing byte *([0-9]+) *\/ *([0-9]+)")

        self.printer = printcore()
        self.settings = Settings()
        self.settings.cmdFolder = cmd_folder
        self.logger = Logger(self)

        if self.settings.speedcommand is not None:
            allow_while_printing.append(self.settings.speedcommand)

        self.acceleration = self.settings.acceleration

        self.dataLoggers = {}
        for d in DLLIST:
            self.dataLoggers[d] = DataLogger(self, d)

        self.skeinforge = Skeinforge(self.settings)
        self.slic3r = Slic3r(self.settings)

        self.httpServer = RepRapServer(self, self.printer, self.settings, self.logger, self.settings.port)

        self.menubar = Menu(self)
        self.filemenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="File", menu=self.filemenu)
        self.filemenu.add_command(label="Slice", command=self.openSTLFile)
        self.filemenu.add_command(label="Load GCode", command=self.openGCodeFile)
        self.slicemenuindex = self.filemenu.index("Slice")
        self.loadgcodemenuindex = self.filemenu.index("Load GCode")

        self.filemenu.add_separator()
        self.filemenu.add_command(label="Exit", command=self.quitApp)

        self.editmenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Edit", menu=self.editmenu)

        self.editmenu.add_command(label="Settings", command=self.editSettings)
        self.editmenu.add_command(label="Firmware Settings", command=self.FirmwareSettings)
        self.editmenu.add_separator()
        self.editmenu.add_command(label=GCODE_MENU_TEXT, command=self.doGEdit, state=DISABLED)

        self.slicermenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Slicer", menu=self.slicermenu)
        self.rbSlicer = StringVar()

        self.slicermenu.add_radiobutton(
            label="Skeinforge", command=self.selSlicer, value=SKEINFORGE, variable=self.rbSlicer
        )
        self.slicermenu.add_command(label="Settings", command=self.skeinforgeSettings)
        self.slicermenu.add_command(label="Choose Profile", command=self.chooseSFProfile)
        self.SFprofileindex = self.slicermenu.index("Choose Profile")
        self.setSFProfileMenuText()
        self.slicermenu.add_command(label="Alterations", command=self.doEditAlterations)

        self.slicermenu.add_separator()
        self.slicermenu.add_radiobutton(label="Slic3r", command=self.selSlicer, value=SLIC3R, variable=self.rbSlicer)
        self.slicermenu.add_command(label="Settings", command=self.slic3rSettings)
        self.slicermenu.add_command(label="Choose Profile", command=self.chooseS3Profile)
        self.S3profileindex = self.slicermenu.index("Choose Profile")
        self.setS3ProfileMenuText()

        self.rbSlicer.set(self.settings.slicer)

        self.macromenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Macros", menu=self.macromenu)
        self.macromenu.add_command(label="New", command=self.doNewMacro)
        self.macromenu.add_command(label="Edit", command=self.doEditMacro)
        self.macromenu.add_command(label="Delete", command=self.doDelMacro)
        self.macromenu.add_separator()
        self.cbShowMacroButtons = BooleanVar()
        self.cbShowMacroButtons.set(self.settings.showmacrobuttons)
        self.macromenu.add_checkbutton(
            label="Show Macro Buttons",
            command=self.doShowButtons,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowMacroButtons,
        )
        self.macromenu.add_separator()
        self.runmacromenu = Menu(self.macromenu, tearoff=0)
        self.loadMacros()
        self.macromenu.add_cascade(label="Run", menu=self.runmacromenu)

        self.reportmenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="View", menu=self.reportmenu)
        self.cbShowPrevious = BooleanVar()
        self.cbShowPrevious.set(self.settings.showprevious)
        self.reportmenu.add_checkbutton(
            label="Show Previous Layer",
            command=self.toggleShowPrevious,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowPrevious,
        )
        self.cbShowMoves = BooleanVar()
        self.cbShowMoves.set(self.settings.showmoves)
        self.reportmenu.add_checkbutton(
            label="Show Non-extrusion Moves",
            command=self.toggleShowMoves,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowMoves,
        )
        self.reportmenu.add_separator()
        self.reportmenu.add_command(label="Show Hours of Usage", command=self.doDataLogReport)
        self.reportmenu.add_command(label="Reset Hours of Usage", command=self.doDataLogReset)
        self.reportmenu.add_separator()
        self.reportmenu.add_command(label="Layer by Layer Timing", command=self.doTimingReport)
        self.reportmenu.add_command(label="Layer by Layer Filament Usage", command=self.doFilamentReport)
        self.reportmenu.add_command(label="GCode Measurements", command=self.doMeasurementsReport)

        self.toolsmenu = Menu(self.menubar, tearoff=0)
        n = 0
        if self.settings.platercmd is not None:
            n += 1
            self.toolsmenu.add_command(label="Plater", command=self.doPlater)

        if self.settings.gcodeviewcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="GCode Viewer", command=self.doGCodeView)

        if self.settings.stlviewcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="STL Viewer", command=self.doSTLView)

        if self.settings.openscadcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="OpenSCAD", command=self.doOpenSCAD)

        if n > 0:
            self.menubar.add_cascade(label="Tools", menu=self.toolsmenu)

        try:
            self.master.config(menu=self.menubar)
        except AttributeError:
            self.master.tk.call(master, "config", "-menu", self.menubar)

        self.toolbar = ToolBar(self, self.printer, self.settings, self.logger)
        self.toolbar.grid(row=1, column=1, columnspan=4, sticky=W)

        self.ctl = MoveControl(self, self.printer, self.settings, self.logger)
        self.ctl.grid(row=2, column=1, rowspan=3, sticky=N)

        self.extr = Extruder(self, self.printer, self.settings, self.logger)
        self.extr.grid(row=2, column=2, rowspan=1, sticky=N + E + W)

        self.temps = Temperatures(self, self.printer, self.settings, self.logger)
        self.temps.grid(row=3, column=2, rowspan=2, sticky=N + E + W)

        self.gc = GcFrame(self, None, [], self.settings, self.logger)
        self.gc.grid(row=2, column=3, rowspan=3, sticky=N)

        self.statline = Status(self, self.printer, self.settings, self.logger)
        self.statline.grid(row=5, column=1, columnspan=4, sticky=E + W)

        self.logger.grid(row=2, column=4, rowspan=2, sticky=N + E + W)

        self.sendgcode = SendGCode(self, self.printer, self.settings, self.logger)
        self.sendgcode.grid(row=4, column=4, sticky=N + E + W)

        self.printer.errorcb = self.errorcb
        self.printer.sendcb = self.sendcb
        self.printer.recvcb = self.recvcb

        self.sd = SDCard(self, self.printer, self.settings, self.logger)
        self.firmware = FirmwareParms(self, self.printer, self.settings, self.logger)
        self.bind(MWM_FIRMWARECOMPLETE, self.firmwareReportComplete)
        self.bind(MWM_SLICERCOMPLETE, self.sliceComplete)
        self.bind(MWM_GCODELOADCOMPLETE, self.loadgcodeFinished)
        self.bind(MWM_GEDITMEASURECOMPLETE, self.geditMeasureComplete)
        self.bind(MWM_REQUESTPOSITIONREPORT, self.requestPosition)

        self.doShowButtons()

    def doStopAll(self):
        self.toolbar.doPause()
        self.temps.doOffBed()
        self.temps.doOffExt()

    def requestPosition(self, *arg):
        self.m114count += 1
        self.printer.send_now("M400")  # finish all moves
        self.printer.send_now("M114")

    def doShowButtons(self):
        self.settings.showmacrobuttons = self.cbShowMacroButtons.get() == 1
        self.settings.setModified()
        if self.settings.showmacrobuttons:
            self.macroButtons = MacroButtons(self, self.printer, self.settings, self.logger)
        else:
            if self.macroButtons:
                self.macroButtons.close()
                self.macroButtons = None

    def toggleShowPrevious(self):
        self.settings.showprevious = self.cbShowPrevious.get() == 1
        self.settings.setModified()
        self.gc.drawCanvas()

    def toggleShowMoves(self):
        self.settings.showmoves = self.cbShowMoves.get() == 1
        self.settings.setModified()
        self.gc.drawCanvas()

    def selSlicer(self):
        self.settings.slicer = self.rbSlicer.get()
        self.settings.setModified()
        self.toolbar.setSliceText()

    def macroButtonClose(self):
        self.settings.showmacrobuttons = False
        self.settings.setModified()
        self.cbShowMacroButtons.set(False)

    def firmwareReportComplete(self, *arg):
        p = self.firmware.reportComplete()
        if p is not None:
            self.acceleration = p["m204_s"].getFlash()
            print "Retrieved acc value of ", self.acceleration

    def openSTLFile(self):
        if self.printing:
            self.logger.logMsg("Cannot open a new file while printing")
            return

        if self.StlFile is None:
            fn = askopenfilename(
                filetypes=[("STL files", "*.stl"), ("G Code files", "*.gcode")], initialdir=self.settings.lastdirectory
            )
        else:
            fn = askopenfilename(
                filetypes=[("STL files", "*.stl"), ("G Code files", "*.gcode")],
                initialdir=self.settings.lastdirectory,
                initialfile=os.path.basename(self.StlFile),
            )
        if fn:
            self.settings.lastdirectory = os.path.dirname(os.path.abspath(fn))
            self.settings.setModified()
            if fn.lower().endswith(".gcode"):
                self.StlFile = None
                self.loadgcode(fn)
            elif fn.lower().endswith(".stl"):
                self.StlFile = fn
                self.doSlice(fn)
            else:
                self.logger.logMsg("Invalid file type")

    def openGCodeFile(self):
        if self.printing:
            self.logger.logMsg("Cannot open a new file while printing")
            return

        fn = askopenfilename(filetypes=[("G Code files", "*.gcode")], initialdir=self.settings.lastdirectory)
        if fn:
            self.settings.lastdirectory = os.path.dirname(os.path.abspath(fn))
            self.settings.setModified()
            if fn.lower().endswith(".gcode"):
                self.StlFile = None
                self.loadgcode(fn)
            else:
                self.logger.logMsg("Invalid file type")
        else:
            self.toolbar.clearCancelMode()

    def loadgcode(self, fn):
        self.GCodeFile = fn
        self.gcodeloadSuccess = True
        self.toolbar.setLoading(True)
        self.loader = threading.Thread(target=self.loadgcodeThread)
        self.loader.daemon = True
        self.loader.start()

    def loadgcodeFinished(self, *arg):
        self.toolbar.setLoading(False)
        if self.gcodeloadSuccess:
            self.showMetrics()

    def loadgcodeThread(self):
        try:
            self.gcode = []
            l = list(open(self.GCodeFile))
            for s in l:
                self.gcode.append(s.rstrip())
            self.logger.logMsg("read %d lines from %s" % (len(self.gcode), os.path.basename(self.GCodeFile)))
        except:
            self.logger.logMsg("Problem reading gcode from %s" % self.GCodeFile)
            self.gcode = []
            self.GCodeFile = None

        if len(self.gcode) != 0:
            self.logger.logMsg("Processing...")
            self.gc.loadFile(self.GCodeFile, self.gcode)
            self.printStartLine = self.gc.getPrintStartLine()
            self.gcodeInfo = GCode(self.gcode)
            self.logger.logMsg("Measuring...")
            self.gcodeInfo.measure(self.acceleration)
            self.estEta = self.gcodeInfo.totalduration
            self.timeLayers = self.gcodeInfo.layerdurations
        else:
            self.gcodeloadSuccess = False

        self.event_generate(MWM_GCODELOADCOMPLETE)

    def replace(self, s, slicer):
        if slicer == SLIC3R:
            d = os.path.expandvars(os.path.expanduser(self.settings.s3profiledir))
            profile = os.path.join(d, self.slic3r.getProfile() + ".ini")
        else:
            profile = self.skeinforge.getProfile()

        d = {}

        d["%starttime%"] = time.strftime("%H:%M:%S", time.localtime(self.startTime))
        d["%endtime%"] = time.strftime("%H:%M:%S", time.localtime(self.endTime))
        d["%elapsed%"] = formatElapsed(self.elapsedTime)

        d["%profile%"] = profile
        d["%slicer%"] = self.settings.slicer

        if self.StlFile is not None:
            d["%stlbase%"] = os.path.basename(self.StlFile)
            d["%stl%"] = self.StlFile
        else:
            d["%stlbase%"] = ""
            d["%stl%"] = ""

        if self.GCodeFile is not None:
            d["%gcodebase%"] = os.path.basename(self.GCodeFile)
            d["%gcode%"] = self.GCodeFile
        else:
            d["%gcodebase%"] = ""
            d["%gcode%"] = ""

        for t in d.keys():
            if d[t] is not None:
                s = s.replace(t, d[t])

        s = s.replace('""', "")
        return s

    def showMetrics(self):
        if len(self.gcode) != 0:
            self.paused = False
            self.toolbar.initializeToolbar()
            self.toolbar.checkAllowPrint()
            self.allowGEdit()

            self.logger.logMsg(
                "Width: %f mm (%f -> %f)" % (self.gcodeInfo.width, self.gcodeInfo.xmin, self.gcodeInfo.xmax)
            )
            self.logger.logMsg(
                "Depth: %f mm (%f -> %f)" % (self.gcodeInfo.depth, self.gcodeInfo.ymin, self.gcodeInfo.ymax)
            )
            self.logger.logMsg(
                "Height: is %f mm (%f -> %f)" % (self.gcodeInfo.height, self.gcodeInfo.zmin, self.gcodeInfo.zmax)
            )
            self.logger.logMsg("Total extrusion length: %f mm" % self.gcodeInfo.filament_length())

            self.logger.logMsg("Estimated print time: %s" % formatElapsed(self.estEta))

    def calcEta(self, line, timeThusFar):
        foundLayer = False
        for i in range(len(self.timeLayers)):
            if self.timeLayers[i][0] > line:
                foundLayer = True
                break

        if not foundLayer:
            return 0

        currentLayer = i - 1
        if currentLayer < 0:
            return 0

        totalInLayer = self.timeLayers[i][0] - self.timeLayers[currentLayer][0]
        printedInLayer = line - self.timeLayers[currentLayer][0]
        pct = printedInLayer / float(totalInLayer)
        thisLayerTime = (self.timeLayers[currentLayer][1]) * pct
        ratio = (self.timeLayers[currentLayer][2] - self.timeLayers[currentLayer][1] + thisLayerTime) / float(
            timeThusFar
        )
        ne = self.estEta / float(ratio)
        return ne - timeThusFar

    def doTimingReport(self):
        if not self.printing:
            self.logger.logMsg("Only available while printing")
            return

        self.timingReport = TimingReport(self, self.printer, self.settings, self.logger)

    def closeTimingReport(self):
        if self.timingReport is not None:
            self.timingReport.cleanup()
            self.timingReport.destroy()

        self.timingReport = None

    def doMeasurementsReport(self):
        if not self.gcodeInfo:
            self.logger.logMsg("Only available when GCode loaded")
            return

        self.measurementsReport = MeasurementsReport(self, self.printer, self.settings, self.logger)

    def closeMeasurementsReport(self):
        if self.measurementsReport is not None:
            self.measurementsReport.destroy()

        self.measurementsReport = None

    def doFilamentReport(self):
        if not self.gcodeInfo:
            self.logger.logMsg("Only available when GCode loaded")
            return
        if len(self.gcodeInfo.filLayers) == 0:
            self.logger.logMsg("No filament usage in this gcode")
            return

        self.filamentReport = FilamentReport(self, self.printer, self.settings, self.logger)

    def closeFilamentReport(self):
        if self.filamentReport is not None:
            self.filamentReport.destroy()

        self.filamentReport = None

    def closeAllReports(self):
        self.closeTimingReport()
        self.closeFilamentReport()
        self.closeMeasurementsReport()

    def doPlater(self):
        s = self.replace(self.settings.platercmd, self.settings.slicer)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def doGCodeView(self):
        s = self.replace(self.settings.gcodeviewcmd, self.settings.slicer)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def doSTLView(self):
        s = self.replace(self.settings.stlviewcmd, self.settings.slicer)
        self.logger.logMsg(s)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def doOpenSCAD(self):
        s = self.replace(self.settings.openscadcmd, self.settings.slicer)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def doSlice(self, fn):
        self.paused = False
        self.toolbar.initializeToolbar()
        self.slicerfn = fn
        self.slicing = True
        self.slicerCancel = False
        self.toolbar.setCancelMode()
        if self.settings.slicer == SLIC3R:
            self.GCodeFile = fn.replace(".stl", ".gcode")
            cmd = self.replace(os.path.expandvars(os.path.expanduser(self.settings.s3cmd)), SLIC3R)
        else:
            self.GCodeFile = fn.replace(".stl", "_export.gcode")
            cmd = self.replace(os.path.expandvars(os.path.expanduser(self.settings.sfcmd)), SKEINFORGE)
        self.slicer = threading.Thread(target=self.slicerThread, args=(cmd,))
        self.slicer.daemon = True
        self.slicer.start()

    def slicerThread(self, cmd):
        args = shlex.split(cmd)
        p = subprocess.Popen(args, stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
        obuf = ""
        while not self.slicerCancel:
            o = p.stdout.read(1)
            if o == "":
                break
            if o == "\r" or o == "\n":
                self.logger.logMsg(obuf)
                obuf = ""
            elif ord(o) < 32:
                pass
            else:
                obuf += o

        if self.slicerCancel:
            p.kill()

        p.wait()
        self.event_generate(MWM_SLICERCOMPLETE)

    def sliceComplete(self, *arg):
        self.slicing = False
        self.toolbar.clearCancelMode()
        if self.slicerCancel:
            self.slicerCancel = False
            self.logger.logMsg("Slicing was cancelled")
            return

        self.logger.logMsg("Slicing has completed successfully")
        if os.path.exists(self.GCodeFile):
            self.loadgcode(self.GCodeFile)
        else:
            self.logger.logMsg("Unable to find slicer output file: %s" % self.GCodeFile)

    def allowGEdit(self):
        self.editmenu.entryconfig(self.editmenu.index(GCODE_MENU_TEXT), state=NORMAL)

    def allowSliceMenu(self, flag=True):
        s = NORMAL
        if not flag:
            s = DISABLED
        self.filemenu.entryconfig(self.slicemenuindex, state=s)

    def allowLoadGCodeMenu(self, flag=True):
        s = NORMAL
        if not flag:
            s = DISABLED
        self.filemenu.entryconfig(self.loadgcodemenuindex, state=s)

    def doGEdit(self):
        GEditor(self, self.gcode, None)

    def geditMeasureComplete(self, *arg):
        self.showMetrics()

    def gEditSave(self, newgcode, fn, editwindow):
        if fn == None:
            self.gcode = newgcode
            self.meas = threading.Thread(target=self.geditMeasureThread)
            self.meas.daemon = True
            self.meas.start()
            return False
        else:
            try:
                f = open(fn, "w")
                for l in newgcode:
                    f.write(l + "\n")
                f.close()
                self.logger.logMsg("Alterations %s successfully saved" % fn)
                return True
            except:
                self.logger.logMsg("Unable to open %s for output" % fn)
                return False

    def geditMeasureThread(self):
        self.logger.logMsg("Processing...")
        self.gcodeInfo = GCode(self.gcode)
        self.logger.logMsg("Measuring...")
        self.gcodeInfo.measure(self.acceleration)
        self.estEta = self.gcodeInfo.totalduration
        self.timeLayers = self.gcodeInfo.layerdurations
        self.event_generate(MWM_GEDITMEASURECOMPLETE)

    def doSD(self):
        if not self.sd.isActive():
            self.sd.start()

    def setToolbarSDPrint(self):
        self.toolbar.setSDPrint()

    def startUpload(self):
        self.sduploading = True
        self.toolbar.doPrint()

    def printerAvailable(self, silent=False, cmd="xx"):
        if not self.connected:
            if not silent:
                self.logger.logMsg("Unable to comply - printer not on-line")
            return False
        if (self.printing or self.sdprinting) and cmd.upper() not in allow_while_printing:
            if not silent:
                self.logger.logMsg("Unable to comply - currently printing")
            return False

        return True

    def printerConnected(self, flag):
        self.sendgcode.activate(flag)
        self.connected = flag
        if flag:
            self.firmware.start(True)

    def updateScreen(self):
        if self.printing:
            self.gc.updatePrintProgress(self.printer.queueindex)

    def errorcb(self, s):
        self.logger.logMsg(s.rstrip())

    def sendcb(self, s):
        # self.logger.logMsg("Sent: %s" % s)
        pass

    def recvcb(self, s):
        if self.readingFirmware:
            if "M92" in s:
                X = self.parseG(s, "X")
                Y = self.parseG(s, "Y")
                Z = self.parseG(s, "Z")
                E = self.parseG(s, "E")
                self.firmware.m92(X, Y, Z, E)
                return
            elif "M201" in s:
                X = self.parseG(s, "X")
                Y = self.parseG(s, "Y")
                Z = self.parseG(s, "Z")
                E = self.parseG(s, "E")
                self.firmware.m201(X, Y, Z, E)
                return
            elif "M203" in s:
                X = self.parseG(s, "X")
                Y = self.parseG(s, "Y")
                Z = self.parseG(s, "Z")
                E = self.parseG(s, "E")
                self.firmware.m203(X, Y, Z, E)
                return
            elif "M204" in s:
                S = self.parseG(s, "S")
                T = self.parseG(s, "T")
                self.firmware.m204(S, T)
                return
            elif "M205" in s:
                S = self.parseG(s, "S")
                T = self.parseG(s, "T")
                B = self.parseG(s, "B")
                X = self.parseG(s, "X")
                Z = self.parseG(s, "Z")
                E = self.parseG(s, "E")
                self.firmware.m205(S, T, B, X, Z, E)
                return
            elif "M206" in s:
                X = self.parseG(s, "X")
                Y = self.parseG(s, "Y")
                Z = self.parseG(s, "Z")
                self.firmware.m206(X, Y, Z)
                return
            elif "M301" in s:
                P = self.parseG(s, "P")
                I = self.parseG(s, "I")
                D = self.parseG(s, "D")
                self.firmware.m301(P, I, D)
                return
            elif (
                ("Steps per unit" in s)
                or ("Acceleration:" in s)
                or ("Maximum Acceleration" in s)
                or ("Maximum feedrates" in s)
                or ("Advanced variables" in s)
                or ("Home offset" in s)
                or ("PID settings" in s)
                or ("Stored settings retreived" in s)
            ):
                return

        if self.sdchecking:
            if "SD card ok" in s:
                self.sdchecking = False
                self.sdpresent = True
                self.sd.sdCheckComplete(True)
                return
            elif "SD init fail" in s:
                self.sdchecking = False
                self.sdpresent = False
                self.sd.sdCheckComplete(False)
                return

        if self.sdlisting:
            if "Begin file list" in s:
                self.insidelisting = True
                self.sdfiles = []
                return
            elif "End file list" in s:
                self.sdlisting = False
                self.insidelisting = False
                self.sd.sdListComplete(self.sdfiles)
                return
            else:
                if self.insidelisting:
                    self.sdfiles.append(s.strip())
                    return

        if "SD printing byte" in s:
            m = self.sdre.search(s)
            t = m.groups()
            if len(t) != 2:
                return

            self.sdbytes = int(t[0])
            self.sdmaxbytes = int(t[1])
            return

        elif "Done printing file" in s:
            if self.sdprinting:
                self.sdprinting = False
                self.toolbar.clearSDPrint()

        m = self.speedrptre.search(s)
        if m:
            t = m.groups()
            if len(t) >= 3:
                if self.settings.forcefanspeed:
                    ns = int(t[0])
                    if ns != self.FanSpeed:
                        self.logger.logMsg("Asserting fan speed of %d" % self.FanSpeed)
                        self.toolbar.forceFanSpeed(self.FanSpeed)
                else:
                    self.FanSpeed = int(t[0])

                self.FeedMultiply = int(t[1])
                self.ExtrudeMultiply = int(t[2])
                self.toolbar.syncSpeeds()
                if self.speedcount > 0:
                    self.speedcount -= 1
                    return

        m = self.locrptre.search(s)
        if m:
            t = m.groups()
            if len(t) >= 4:
                self.location[XAxis] = float(t[0])
                self.location[YAxis] = float(t[1])
                self.location[ZAxis] = float(t[2])
                self.location[EAxis] = float(t[3])
                if self.m114count != 0:
                    self.m114count -= 1
                    if self.m114count < 0:
                        self.m114count = 0
                    return

        if s.startswith("ok"):
            return

        if s.startswith("echo:"):
            s = s[5:]

        m = self.rpt1re.search(s)
        if m:
            t = m.groups()
            if len(t) >= 1:
                self.exttemp = float(t[0])
            if len(t) >= 2:
                self.bedtemp = float(t[1])
            self.temps.updateTempDisplay(self.bedtemp, self.exttemp)

        m = self.rpt2re.search(s)
        if m:
            t = m.groups()
            if len(t) >= 1:
                self.exttemp = float(t[0])
            self.temps.updateTempDisplay(self.bedtemp, self.exttemp)

        self.logger.logMsg(s.rstrip())

    def parseG(self, s, v):
        l = s.split()
        for p in l:
            if p.startswith(v):
                try:
                    return float(p[1:])
                except:
                    return None
        return None

    def editSettings(self):
        # TO DO
        pass

    def slic3rSettings(self):
        s = self.replace(self.settings.s3config, SLIC3R)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def skeinforgeSettings(self):
        s = self.replace(self.settings.sfconfig, SKEINFORGE)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def chooseS3Profile(self):
        pl = self.slic3r.getProfileOptions()
        if len(pl) > 0:
            l = ListBoxChoice(
                clist=pl.keys(), master=self, title="Choose Slic3r Profile", message="Choose Slic3r profile"
            )
            pn = l.returnValue()
            if pn:
                self.slic3r.setProfile(pn)
                self.setS3ProfileMenuText()
                self.toolbar.setSliceText()
        else:
            self.logger.logMsg("Unable to retrieve available slic3r profiles")

    def chooseSFProfile(self):
        pl = self.skeinforge.getProfileOptions()
        if len(pl) > 0:
            l = ListBoxChoice(
                clist=pl.keys(), master=self, title="Choose Skeinforge Profile", message="Choose Skeinforge profile"
            )
            pn = l.returnValue()
            if pn:
                self.skeinforge.setProfile(pn)
                self.setSFProfileMenuText()
                self.toolbar.setSliceText()
        else:
            self.logger.logMsg("Unable to retrieve available skeinforge profiles")

    def setS3ProfileMenuText(self):
        self.slicermenu.entryconfig(self.S3profileindex, label="Choose Profile (%s)" % self.slic3r.getProfile())

    def setSFProfileMenuText(self):
        self.slicermenu.entryconfig(self.SFprofileindex, label="Choose Profile (%s)" % self.skeinforge.getProfile())

    def quitApp(self):
        self.cleanUp()
        self.master.quit()

    def cleanUp(self):
        if self.connected:
            self.printer.disconnect()
        if self.slicing:
            self.slicerCancel = True
        self.httpServer.close()
        self.statline.cleanUp()
        self.settings.cleanUp()

    def doEditMacro(self):
        idir = os.path.join(self.settings.cmdFolder, "macros")
        try:
            l = os.listdir(idir)
        except:
            self.logger.logMsg("Unable to get listing from macros directory: " + idir)
            return
        r = []
        for f in sorted(l):
            if f.endswith(".macro"):
                r.append(f)

        l = ListBoxChoice(master=self, title="Macro Files", message="Choose a macro to edit", clist=r)
        fn = l.returnValue()
        if fn:
            try:
                fn = os.path.join(idir, fn)
                with open(fn) as f:
                    text = f.read()
                self.macroEdit = MacroEdit(self, self.printer, self.settings, self.logger, fn, text)
            except:
                self.logger.logMsg("Unable to open %s for input" % fn)

    def doEditAlterations(self):
        idir = os.path.expandvars(os.path.expanduser(self.settings.sfalterationsdir))
        try:
            l = os.listdir(idir)
        except:
            self.logger.logMsg("Unable to get listing from alterations directory: " + idir)
            return
        r = []
        for f in sorted(l):
            if f.endswith(".gcode"):
                r.append(f)

        l = ListBoxChoice(master=self, title="Alteration Files", message="Choose an alteration file to edit", clist=r)
        fn = l.returnValue()
        if fn:
            try:
                fn = os.path.join(idir, fn)
                text = [line.strip() for line in open(fn)]
                GEditor(self, text, fn)
            except:
                self.logger.logMsg("Unable to open %s for input" % fn)

    def doNewMacro(self):
        self.macroEdit = MacroEdit(self, self.printer, self.settings, self.logger, None, "")

    def doDelMacro(self):
        idir = os.path.join(self.settings.cmdFolder, "macros")
        try:
            l = os.listdir(idir)
        except:
            self.logger.logMsg("Unable to get listing from macros directory: " + idir)
            return
        r = []
        for f in sorted(l):
            if f.endswith(".macro"):
                r.append(f)

        l = ListBoxChoice(master=self, title="Macro Files", message="Choose a macro to delete", clist=r)
        fn = l.returnValue()
        if fn:
            if askyesno("Delete?", "Are you sure you want to delete this macro?", parent=self):
                try:
                    os.unlink(os.path.join(idir, fn))
                    self.adjustMacroMenu(fn, True)
                    if self.settings.getMacroList().delMacroByName(fn):
                        self.settings.setModified()
                        if self.settings.showmacrobuttons:
                            self.macroButtons.close()
                            self.macroButtons = MacroButtons(self, self.printer, self.settings, self.logger)
                except:
                    self.logger.logMsg("Unable to delete %s" % fn)

    def macroEditSave(self, fn, text, btn, editwindow):
        if fn == None:
            idir = os.path.join(self.settings.cmdFolder, "macros")

            try:
                l = os.listdir(idir)
            except:
                self.logger.logMsg("Unable to get listing from macros directory: " + idir)
                return

            r = []
            for f in sorted(l):
                if f.endswith(".macro"):
                    r.append(f)

            l = ListBoxChoice(
                master=self,
                title="Macro Files",
                message="Choose a macro to overwrite",
                clist=r,
                newmessage="or enter new file name:",
            )
            fn = l.returnValue()
            if fn:
                fn = os.path.join(idir, fn)
                if not fn.endswith(".macro"):
                    fn += ".macro"

        if fn is None:
            return False

        try:
            f = open(fn, "w")
            f.write(text)
            f.close()
            self.settings.setModified()
            if btn != None:
                if not self.settings.getMacroList().addMacro(btn[0], btn[1], os.path.basename(fn), btn[2]):
                    self.settings.getMacroList().setMacroByName(btn[0], btn[1], os.path.basename(fn), btn[2])
                self.settings.setModified()

                if self.settings.showmacrobuttons:
                    self.macroButtons.close()
                    self.macroButtons = MacroButtons(self, self.printer, self.settings, self.logger)

            self.adjustMacroMenu(fn)
            self.logger.logMsg("Macro %s successfully saved" % fn)
            return True
        except:
            self.logger.logMsg("Unable to open %s for output" % fn)
            return False

    def macroEditExit(self, fn):
        pass

    def loadMacros(self):
        p = os.path.join(".", "macros")
        if not os.path.exists(p):
            os.makedirs(p)

        self.macroList = {}
        for filename in sorted(os.listdir(p)):
            if filename.endswith(".macro"):
                n = os.path.splitext(filename)[0]
                self.macroList[n] = 1
                self.runmacromenu.add_command(label=n, command=lambda m=n: self.doMacro(m))

    def adjustMacroMenu(self, fn, delete=False):
        mn = os.path.splitext(os.path.basename(fn))[0]

        if not delete:
            if mn in self.macroList:
                # nothing to be done here
                pass
            else:
                self.macroList[mn] = 1
                self.runmacromenu.add_command(label=mn, command=lambda m=mn: self.doMacro(name=mn))
        else:
            # delete the menu entry
            if mn in self.macroList:
                self.runmacromenu.delete(self.runmacromenu.index(mn))
                del self.macroList[mn]
            else:
                # huh??
                pass

    def doMacro(self, name=None, fname=None, silent=False):
        if name:
            if not silent:
                self.logger.logMsg("Invoking macro: %s" % name)
            n = os.path.join(self.settings.cmdFolder, "macros", name + ".macro")
        elif fname:
            if not silent:
                self.logger.logMsg("Invoking macro file: %s" % fname)
            n = os.path.join(self.settings.cmdFolder, "macros", fname)
        else:
            self.logger.logMsg("Error - must provide a macro name or filename")
            return

        try:
            l = list(open(n))
            for s in l:
                sl = s.lower()
                if sl.startswith("@log "):
                    self.logger.logMsg(self.replace(s[5:].strip(), self.settings.slicer))
                elif sl.startswith("@sh "):
                    s = self.replace(sl[4:], self.settings.slicer)
                    args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
                    subprocess.Popen(args, close_fds=True)
                else:
                    verb = s.split()[0]
                    if self.printerAvailable(cmd=verb):
                        self.printer.send_now(s)
                    else:
                        self.logger.logMsg("Printer not available for %s command" % verb)

            if not silent:
                self.logger.logMsg("End of macro")
        except:
            self.logger.logMsg("Error attempting to invoke macro file %s" % n)

    def FirmwareSettings(self):
        if self.connected:
            if not self.firmware.isActive():
                self.firmware.start()
        else:
            self.logger.logMsg("Unable to comply - printer not on-line")

    def doDataLogReport(self):
        for d in DLLIST:
            self.logger.logMsg("%s Usage: %s" % (DLNAMES[d], self.dataLoggers[d].getToNowStr()))

    def doDataLogReset(self):
        DataLogReset(self)
Пример #22
0
    def __init__(self, master):
        # Master Window
        self.master = master

        NUMLINES = 32
        BOXWIDTH = 42
        BUTTONWIDTH = 24
        CHECKWIDTH = 24
        BUTTONPAD = 12

        BG_COLOR1 = 'black'

        # Input Box
        BG_COLOR2 = '#301313'

        # Output Box
        BG_COLOR3 = '#131313'

        BG_COLOR4 = '#333333'
        BG_COLOR5 = '#433333'

        # Text
        FG_COLOR1 = 'white'
        FG_COLOR1 = 'grey'

        BD_COLOR1 = '#120000'

        FIELD_WIDTH = 9

        # Delimiter Options
        # Display, characterString
        global MODES

        DELIMITERS = list(MODES.keys())

        # Date String options
        DATEFORMATS = {
            'YMDhm', 'YMD_hm', 'D/M/Y', 'D/M/Y h:m:s', 'D/M/Y h:m', 'Y-M-D',
            'Y-M-D h:m:s', 'Y-M-D h:m'
        }

        # Initialize the source text.
        source_text_on_load = StringVar()
        source_text_on_load.set(self.getClipboard())
        source_text = StringVar()
        source_text.set(source_text_on_load.get())
        output_text = StringVar()
        output_text.set('')

        src_delimiter = StringVar()
        src_delimiter.set('\n')
        out_delimiter = StringVar()
        out_delimiter.set(',')
        out_quote = StringVar()
        out_quote.set('')

        prefix = StringVar()
        prefix.set('')
        suffix = StringVar()
        suffix.set('')

        find_text = StringVar()
        find_text.set('')
        replace_text = StringVar()
        replace_text.set('')

        capitalize = BooleanVar()
        remove_empty = BooleanVar()
        order_alpha = BooleanVar()
        unique_only = BooleanVar()
        skip_header = BooleanVar()

        capitalize.set(0)
        remove_empty.set(0)
        order_alpha.set(0)
        unique_only.set(0)
        skip_header.set(0)

        date_format = StringVar()
        date_format.set('YMDhm')

        ##################
        # NOTEBOOK 1
        ################

        #################
        # TOP
        ################
        top_frame = Frame(root, bg='', width=36, height=260, pady=3, padx=3)
        top_frame.pack()

        line_numbers = StringVar()
        for i in range(0, NUMLINES):
            line_numbers.set(line_numbers.get() + str(i + 1) + '\n')

        # Source Text Box
        source_text_frame = LabelFrame(top_frame,
                                       text='Source',
                                       fg=FG_COLOR1,
                                       bg=BD_COLOR1,
                                       width=20,
                                       height=400,
                                       pady=3,
                                       padx=3)
        source_text_frame.grid(row=0, column=1, sticky="nw")
        src_txt_line_numbers = Label(source_text_frame,
                                     textvar=line_numbers,
                                     fg=FG_COLOR1,
                                     bg=BG_COLOR4,
                                     anchor='ne',
                                     justify='right',
                                     width=2,
                                     height=NUMLINES,
                                     relief='raised')
        src_txt_line_numbers.grid(row=0, column=0)
        src_txt_box = Label(source_text_frame,
                            textvar=source_text,
                            fg=FG_COLOR1,
                            bg=BG_COLOR3,
                            anchor='nw',
                            justify='left',
                            wraplength=320,
                            width=BOXWIDTH,
                            height=NUMLINES,
                            relief='raised')
        src_txt_box.grid(row=0, column=1)

        # Output Text Box
        output_text_frame = LabelFrame(top_frame,
                                       text='Output',
                                       fg=FG_COLOR1,
                                       bg=BD_COLOR1,
                                       width=20,
                                       height=400,
                                       pady=3,
                                       padx=3)
        output_text_frame.grid(row=0, column=3, sticky="ne")
        out_txt_box = Label(output_text_frame,
                            textvar=line_numbers,
                            fg=FG_COLOR1,
                            bg=BG_COLOR5,
                            anchor='ne',
                            justify='right',
                            width=2,
                            height=NUMLINES,
                            relief='raised')
        out_txt_box.grid(row=0, column=0)
        out_txt_box = Label(output_text_frame,
                            textvar=output_text,
                            fg=FG_COLOR1,
                            bg=BG_COLOR2,
                            anchor='nw',
                            justify='left',
                            wraplength=320,
                            width=BOXWIDTH,
                            height=NUMLINES,
                            relief='raised')
        out_txt_box.grid(row=0, column=1)

        #################
        # MIDDLE
        ################
        # delimiter_frame = LabelFrame(master, fg=FG_COLOR1, bg=BG_COLOR1, pady=10, text='Delimiter Settings')
        # delimiter_frame.pack()

        delimiter_frame = LabelFrame(master,
                                     fg=FG_COLOR1,
                                     bg=BG_COLOR1,
                                     pady=10,
                                     text='Delmiter (From -> To)')
        delimiter_frame.pack()

        # MIDDLE LEFT
        src_delimiter_container = Frame(delimiter_frame, bg=BG_COLOR1, padx=5)
        src_delimiter_container.grid(sticky=('n', 'w', 's', 'e'),
                                     row=0,
                                     column=0,
                                     columnspan=3)

        # src_delimiter_label = Label(src_delimiter_container, text="Src", justify='left', height=1, width=3, anchor='e', relief='groove')
        # src_delimiter_label.grid(row=0, column=0, sticky=('n','w','s','e'))

        # src_delimiter_radio = Frame(src_delimiter_container, relief='groove')
        # src_delimiter_radio.grid(row=0, column=1, sticky=('n','w','s','e'))
        #
        # i = 0
        # for text, mode in MODES:
        #     b = Radiobutton(src_delimiter_radio, text=text, width=8,
        #                     variable=src_delimiter, value=mode, indicatoron=0)
        #     b.grid(row=0, column=i)
        #     i = i+1

        src_delimiter_option = OptionMenu(
            delimiter_frame, src_delimiter,
            *DELIMITERS)  # Pointer to option array
        src_delimiter_option.grid(row=0, column=0)

        # MIDDLE MIDDLE - Delimiter
        out_delimiter_container = Frame(delimiter_frame, bg=BG_COLOR1, padx=5)
        out_delimiter_container.grid(sticky=('n', 'w', 's', 'e'),
                                     row=1,
                                     column=0,
                                     columnspan=3)

        # out_delimiter_label = Label(out_delimiter_container, text="Out", justify='center', height=1, width=3, anchor='e', relief='groove')
        # out_delimiter_label.grid(sticky=('n','w','s','e'),row=0, column=0)
        #
        # out_delimiter_radio = Frame(out_delimiter_container, width=240, height=120, relief='groove')
        # out_delimiter_radio.grid(sticky=('n','w','s','e'),row=0, column=1)
        #
        # i = 1
        # for text, mode in MODES:
        #     if mode != 'none':
        #       b = Radiobutton(out_delimiter_radio, text=text, width=8,
        #                       variable=out_delimiter, value=mode, indicatoron=0)
        #       b.grid(row=0, column=i)
        #       i = i+1

        out_delimiter_option = OptionMenu(
            delimiter_frame, out_delimiter,
            *DELIMITERS)  # Pointer to option array
        out_delimiter_option.grid(row=0, column=1)

        mid_container = Frame(master, bg=BG_COLOR1)
        mid_container.pack()

        textvar_container = LabelFrame(mid_container,
                                       fg=FG_COLOR1,
                                       bg=BG_COLOR1,
                                       pady=10,
                                       text='Text Operations')
        textvar_container.grid(row=0, column=0, columnspan=5)

        # MIDDLE BOTTOM - Quote
        out_quote_container = Frame(textvar_container,
                                    bg=BG_COLOR1,
                                    width=100,
                                    height=160,
                                    pady=8)
        out_quote_container.grid(row=0, column=0)

        out_quote_label = Label(out_quote_container,
                                text="Quote",
                                justify='center',
                                width=FIELD_WIDTH,
                                height=1,
                                relief='groove')
        out_quote_label.grid(row=0, column=0)

        out_quote_entry = Entry(out_quote_container,
                                textvar=out_quote,
                                justify='center',
                                width=FIELD_WIDTH,
                                relief='groove',
                                bg=FG_COLOR1,
                                fg=BG_COLOR1)
        out_quote_entry.grid(row=1, column=0)

        # MIDDLE BOTTOM - Prefix
        prefix_container = Frame(textvar_container,
                                 bg=BG_COLOR1,
                                 width=100,
                                 height=160,
                                 pady=8)
        prefix_container.grid(row=0, column=1)

        prefix_label = Label(prefix_container,
                             text="Prefix",
                             justify='center',
                             width=FIELD_WIDTH,
                             height=1,
                             relief='groove')
        prefix_label.grid(row=0, column=0)

        prefix_entry = Entry(prefix_container,
                             textvar=prefix,
                             justify='center',
                             width=FIELD_WIDTH,
                             relief='groove',
                             bg=FG_COLOR1,
                             fg=BG_COLOR1)
        prefix_entry.grid(row=1, column=0)

        # MIDDLE BOTTOM - Suffix
        suffix_container = Frame(textvar_container,
                                 bg=BG_COLOR1,
                                 width=100,
                                 height=160,
                                 pady=8)
        suffix_container.grid(row=0, column=2)

        suffix_label = Label(suffix_container,
                             text="Suffix",
                             justify='center',
                             width=FIELD_WIDTH,
                             height=1,
                             relief='groove')
        suffix_label.grid(row=0, column=0)

        suffix_entry = Entry(suffix_container,
                             textvar=suffix,
                             justify='center',
                             width=FIELD_WIDTH,
                             relief='groove',
                             bg=FG_COLOR1,
                             fg=BG_COLOR1)
        suffix_entry.grid(row=1, column=0)

        ######################
        # FIND REPLACE PANEL #
        ######################
        find_container = Frame(textvar_container,
                               bg=BG_COLOR1,
                               width=100,
                               height=160,
                               pady=8)
        find_container.grid(row=0, column=3)

        find_label = Label(find_container,
                           text="Replace",
                           justify='left',
                           width=FIELD_WIDTH,
                           height=1,
                           relief='groove')
        find_label.grid(row=0, column=0)

        find_entry = Entry(find_container,
                           textvar=find_text,
                           justify='left',
                           width=FIELD_WIDTH * 2,
                           relief='groove',
                           bg=FG_COLOR1,
                           fg=BG_COLOR1)
        find_entry.grid(row=1, column=0)

        replace_container = Frame(textvar_container,
                                  bg=BG_COLOR1,
                                  width=100,
                                  height=160,
                                  pady=8)
        replace_container.grid(row=0, column=4)

        replace_label = Label(replace_container,
                              text="With",
                              justify='left',
                              width=FIELD_WIDTH,
                              height=1,
                              relief='groove')
        replace_label.grid(row=0, column=0)

        replace_entry = Entry(replace_container,
                              textvar=replace_text,
                              justify='left',
                              width=FIELD_WIDTH * 2,
                              relief='groove',
                              bg=FG_COLOR1,
                              fg=BG_COLOR1)
        replace_entry.grid(row=1, column=0)

        # DATE MENU
        date_frame = LabelFrame(mid_container,
                                bg=BG_COLOR1,
                                fg=FG_COLOR1,
                                text='Date',
                                width=650,
                                height=280,
                                pady=3,
                                padx=3,
                                relief='groove')
        date_frame.grid(row=0, column=6)

        date_option = OptionMenu(date_frame, date_format,
                                 *DATEFORMATS)  # Pointer to option array
        date_option.grid(row=0, column=0)

        date_button = Button(
            date_frame,
            text="Copy",
            command=lambda: self.setClipboard(self.printDate(date_format.get())
                                              ),
            width=BUTTONWIDTH / 2,
            highlightbackground=BG_COLOR1,
        )
        date_button.grid(row=1, column=0)

        #################
        # BOTTOM
        ################
        control_frame = Frame(root,
                              bg='',
                              width=650,
                              height=140,
                              pady=3,
                              padx=3,
                              relief='groove')
        control_frame.pack()
        #
        # # BOTTOM LEFT
        src_control_container = Frame(control_frame,
                                      bg=BG_COLOR1,
                                      width=200,
                                      height=280,
                                      padx=BUTTONPAD)
        src_control_container.grid(sticky='w', row=0, column=0)

        # Refresh State to Load
        refresh_button = Button(
            src_control_container,
            text="Refresh To Load State",
            command=lambda: source_text.set(source_text_on_load.get()),
            width=BUTTONWIDTH,
            highlightbackground=BG_COLOR1)
        refresh_button.grid(row=0, column=0)

        clipboard_button = Button(
            src_control_container,
            text="Copy from Clipboard",
            command=lambda: source_text.set(self.getClipboard()),
            width=BUTTONWIDTH,
            highlightbackground=BG_COLOR1)
        clipboard_button.grid(row=1, column=0)

        pushback_button = Button(
            src_control_container,
            text="Output to Input",
            command=lambda: source_text.set(output_text.get()),
            width=BUTTONWIDTH,
            highlightbackground=BG_COLOR1)
        pushback_button.grid(row=2, column=0)

        # BOTTOM MIDDLE
        settings_container = Frame(control_frame,
                                   bg='grey',
                                   width=200,
                                   height=280,
                                   pady=3,
                                   padx=3)
        settings_container.grid(row=0, column=1)

        order_check = Checkbutton(settings_container,
                                  text="Alphabeticalize",
                                  variable=order_alpha,
                                  anchor='w',
                                  width=CHECKWIDTH)
        order_check.pack(anchor='w')

        cap_check = Checkbutton(settings_container,
                                text="Capitalize",
                                variable=capitalize,
                                anchor='w',
                                width=CHECKWIDTH)
        cap_check.pack(anchor='w')

        header_check = Checkbutton(settings_container,
                                   text="Skip Header",
                                   variable=skip_header,
                                   anchor='w',
                                   width=CHECKWIDTH)
        header_check.pack(anchor='w')

        rem_check = Checkbutton(settings_container,
                                text="Strip Blanks",
                                variable=remove_empty,
                                anchor='w',
                                width=CHECKWIDTH)
        rem_check.pack(anchor='w')

        unique_check = Checkbutton(settings_container,
                                   text="Unique Values",
                                   variable=unique_only,
                                   anchor='w',
                                   width=CHECKWIDTH)
        unique_check.pack(anchor='w')

        # BOTTOM RIGHT
        out_control_container = Frame(control_frame,
                                      bg=BG_COLOR1,
                                      width=200,
                                      height=280,
                                      padx=BUTTONPAD)
        out_control_container.grid(row=0, column=2)

        fr_button = Button(
            out_control_container,
            text="Find/Replace",
            command=lambda: output_text.set(
                self.findReplace(source_text.get(), find_text.get(),
                                 replace_text.get())),
            width=BUTTONWIDTH,
            highlightbackground=BG_COLOR1,
        )
        fr_button.pack()

        go_button = Button(
            out_control_container,
            text="Process",
            command=lambda: output_text.set(
                self.process(source_text.get(), src_delimiter.get(
                ), out_delimiter.get(), out_quote.get(), order_alpha.get(
                ), skip_header.get(), remove_empty.get(), unique_only.get(),
                             capitalize.get(), prefix.get(), suffix.get(),
                             find_text.get(), replace_text.get())),
            width=BUTTONWIDTH,
            highlightbackground=BG_COLOR1,
        )
        go_button.pack()

        copy_button = Button(
            out_control_container,
            text="Copy to Clipboard",
            command=lambda: self.setClipboard(output_text.get()),
            width=BUTTONWIDTH,
            highlightbackground=BG_COLOR1)
        copy_button.pack()

        close_button = Button(out_control_container,
                              text="Quit",
                              command=master.quit,
                              width=BUTTONWIDTH,
                              highlightbackground=BG_COLOR1)
        close_button.pack()
Пример #23
0
class GrepDialog(SearchDialogBase):
    title = "Find in Files Dialog"
    icon = "Grep"
    needwrapbutton = 0
    bottom_btns = [("Search Files", 'default_command', 1)]

    def __init__(self, root, engine, flist):
        SearchDialogBase.__init__(self, root, engine)
        self.flist = flist
        self.globvar = StringVar(root)
        self.recvar = BooleanVar(root)

    def open(self, text, searchphrase, io=None):
        SearchDialogBase.open(self, text, searchphrase)
        if io:
            path = io.filename or ""
        else:
            path = ""
        dir, base = os.path.split(path)
        head, tail = os.path.splitext(base)
        if not tail:
            tail = ".py"
        self.globvar.set(os.path.join(dir, "*" + tail))

    def create_entries(self):
        SearchDialogBase.create_entries(self)
        self.globent = self.make_entry("In files", self.globvar)

    def create_other_buttons(self):
        f = self.make_frame()

        btn = Checkbutton(f, variable=self.recvar,
                text="Recurse down subdirectories")
        btn.pack(side="top", fill="both")
        btn.invoke()

    def create_command_buttons(self):
        SearchDialogBase.create_command_buttons(self)

    def default_command(self, event=None):
        prog = self.engine.getprog()
        if not prog:
            return
        path = self.globvar.get()
        if not path:
            self.top.bell()
            return
        from OutputWindow import OutputWindow
        save = sys.stdout
        try:
            sys.stdout = OutputWindow(self.flist)
            self.grep_it(prog, path)
        finally:
            sys.stdout = save

    def grep_it(self, prog, path):
        dir, base = os.path.split(path)
        list = self.findfiles(dir, base, self.recvar.get())
        list.sort()
        self.close()
        pat = self.engine.getpat()
        print "Searching %r in %s ..." % (pat, path)
        hits = 0
        for fn in list:
            try:
                f = open(fn)
            except IOError, msg:
                print msg
                continue
            lineno = 0
            while 1:
                block = f.readlines(100000)
                if not block:
                    break
                for line in block:
                    lineno = lineno + 1
                    if line[-1:] == '\n':
                        line = line[:-1]
                    if prog.search(line):
                        sys.stdout.write("%s: %s: %s\n" % (fn, lineno, line))
                        hits = hits + 1
        if hits:
            if hits == 1:
                s = ""
            else:
                s = "s"
            print "Found", hits, "hit%s." % s
            print "(Hint: right-click to open locations.)"
        else:
            print "No hits."
Пример #24
0
class simpleapp_tk(Tkinter.Tk):
    def __init__(self,parent):
        Tkinter.Tk.__init__(self,parent)
        self.parent = parent
        self.initialize()
        
    def initialize(self):
        self.grid()

        #ENTRY CELL
        self.entryVariable = StringVar()
        self.entry = Tkinter.Entry(self,textvariable=self.entryVariable)
        self.entry.grid(column=0,row=0,sticky='EW')
        self.entry.bind("<Return>", self.OnPressEnter)
        self.entryVariable.set(u"Enter text here.") 

        #CLICK BUTTON
        button = Tkinter.Button(self,text=u"Click me !",command=self.OnButtonClick) 
        button.grid(column=1,row=0)

        #CHECK BOX
        self.var = BooleanVar()
        cb = Tkinter.Checkbutton(self, text="Show title",variable=self.var, command=self.onClick)
        cb.select()
        cb.grid(column=0,row=5,sticky='W')

##        #COMBO BOX
##        self.combo = StringVar()
##        self.box = ttk.Combobox(self.parent, textvariable=self.box)
##        self.box['values'] = ('X', 'Y', 'Z')
##        self.box.current(0)
##        self.box.grid(column=0, row=4,sticky='W')

        #LABEL
        self.labelVariable = Tkinter.StringVar() 
        label = Tkinter.Label(self,textvariable=self.labelVariable,anchor="w",fg="white",bg="blue")
        label.grid(column=0,row=1,columnspan=2,sticky='EW')
        self.labelVariable.set(u"Hello !")

        # MENU
        menubar = Tkinter.Menu(self.parent) # level0: -- menubar--
        self.config(menu=menubar)
        
        fileMenu = Tkinter.Menu(menubar) #level1: filemenu 
        menubar.add_cascade(label="File", menu=fileMenu) # add to menubar

        submenu = Tkinter.Menu(menubar) #level2: submenu
        fileMenu.add_cascade(label='Import', menu=submenu) # add to filemenu
  
        submenu.add_command(label="test1",command=self.test1)# level3: add under submenu
        submenu.add_command(label="test2",command=self.test2)  
        fileMenu.add_separator()
        
        fileMenu.add_command(label="Exit", command=self.destroy)# level2: under filemenu


        self.grid_columnconfigure(0,weight=1) # just formatting
        self.resizable(True,False)
        self.update()
        self.geometry(self.geometry())       
        self.entry.focus_set()
        self.entry.selection_range(0, Tkinter.END)

        #QUIT
        quitButton = Tkinter.Button(self, text="Quit",command=self.destroy)
        quitButton.grid(column=1,row=5,sticky='E')

        
    def OnButtonClick(self):
        self.labelVariable.set(self.entryVariable.get()+" (TEST)" )
        self.entry.focus_set()
        self.entry.selection_range(0, Tkinter.END)

    def OnPressEnter(self,event):
        self.labelVariable.set(self.entryVariable.get()+" (TEST)")
        self.entry.focus_set()
        self.entry.selection_range(0, Tkinter.END)

    def onClick(self):
        if self.var.get() == True:
            a=1
        else:
            a=1

    def test1(self):
        ftypes = [('Python files', '*.py'), ('All files', '*')]
        dlg = tkFileDialog.Open(self, filetypes = ftypes)
        fl = dlg.show()
        if fl != '':
            text = self.readFile(fl) # get "text"
            self.labelVariable.set(text) # display in label
            
    def test2(self):
        a=1
        
    def readFile(self, filename):
        f = open(filename, "r")
        text = f.read()
        return text
Пример #25
0
class FontChooser( tkSimpleDialog.Dialog ):
    BASIC = 1
    ALL   = 2

    def __init__( self, parent, defaultfont=None, showstyles=None ):
        self._family       = StringVar(  value='Century Schoolbook L')
        self._sizeString   = StringVar(  value='20'          )
        self._weight       = StringVar(  value=tkFont.NORMAL )
        self._slant        = StringVar(  value=tkFont.ROMAN  )
        self._isUnderline  = BooleanVar( value=False         )
        self._isOverstrike = BooleanVar( value=False         )
        if defaultfont:
            self._initialize( defaultfont )

        self._currentFont  = tkFont.Font( font=self.getFontTuple() )

        self._showStyles   = showstyles

        self.sampleText      = None

        tkSimpleDialog.Dialog.__init__( self, parent, 'Font Chooser' )

    def _initialize( self, aFont ):
        if not isinstance( aFont, tkFont.Font ):
            aFont = tkFont.Font( font=aFont )

        fontOpts = aFont.actual( )

        self._family.set(       fontOpts[ 'family'     ] )
        self._sizeString.set(   fontOpts[ 'size'       ] )
        self._weight.set(       fontOpts[ 'weight'     ] )
        self._slant.set(        fontOpts[ 'slant'      ] )
        self._isUnderline.set(  fontOpts[ 'underline'  ] )
        self._isOverstrike.set( fontOpts[ 'overstrike' ] )

    def body( self, master ):
        theRow = 0

        Label( master, text="Font Family" ).grid( row=theRow, column=0 )
        Label( master, text="Font Size" ).grid( row=theRow, column=2 )

        theRow += 1

        # Font Families
        fontList = ttk.Combobox( master,  height=10, textvariable=self._family )
        fontList.grid( row=theRow, column=0, columnspan=2, sticky=N+S+E+W, padx=10 )
        rawfamilyList = list(tkFont.families( ))
        rawfamilyList.sort()
        # print rawfamilyList
        familyList=[]
        for family in rawfamilyList:
            if family[0] == '@':
                continue
            familyList.append(family)
        fontList.configure( values=familyList )
        fontList.bind('<<ComboboxSelected>>', self.selectionChanged)

        # Font Sizes
        sizeList = ttk.Combobox( master,  height=10, width=5, textvariable=self._sizeString )
        sizeList.grid( row=theRow, column=2, columnspan=2, sticky=N+S+E+W, padx=10 )
        sizes=[]
        for size in xrange( 10,50 ):
            sizes.append( str(size) )
        sizeList.configure( values=sizes)
        sizeList.bind('<<ComboboxSelected>>', self.selectionChanged)

        # Styles
        if self._showStyles is not None:
            theRow += 1
            if self._showStyles in ( FontChooser.ALL, FontChooser.BASIC ):
                Label( master, text='Styles', anchor=W ).grid( row=theRow, column=0, pady=10, sticky=W )

                theRow += 1

                Checkbutton( master, text="bold", command=self.selectionChanged, offvalue='normal', onvalue='bold', variable=self._weight ).grid(row=theRow, column=0)
                Checkbutton( master, text="italic", command=self.selectionChanged, offvalue='roman', onvalue='italic', variable=self._slant ).grid(row=theRow, column=1)

        if self._showStyles == FontChooser.ALL:
            Checkbutton( master, text="underline", command=self.selectionChanged, offvalue=False, onvalue=True, variable=self._isUnderline ).grid(row=theRow, column=2)
            Checkbutton( master, text="overstrike", command=self.selectionChanged, offvalue=False, onvalue=True, variable=self._isOverstrike ).grid(row=theRow, column=3)

        # Sample Text
            theRow += 1

            Label( master, text='Sample Text', anchor=W ).grid( row=theRow, column=0, pady=10, sticky=W )

            theRow += 1

            self.sampleText = Text( master, height=11, width=70 )
            self.sampleText.insert( INSERT,'ABC...XYZ\nabc....xyz', 'fontStyle' )
            self.sampleText.config( state=DISABLED )
            self.sampleText.tag_config( 'fontStyle', font=self._currentFont )
            self.sampleText.grid( row=theRow, column=0, columnspan=4, padx=10 )

    def apply( self ):
        self.result = self.getFontTuple( )

    def selectionChanged( self, something=None ):
        self._currentFont.configure( family=self._family.get(),
                                     size=self._sizeString.get(),
                                     weight=self._weight.get(),
                                     slant=self._slant.get(),
                                     underline=self._isUnderline.get(),
                                     overstrike=self._isOverstrike.get() )

        if self.sampleText:
            self.sampleText.tag_config( 'fontStyle', font=self._currentFont )

    def getFontString( self ):
        family = self._family.get()
        size   = int(self._sizeString.get())

        styleList = [ ]
        if self._weight.get() == tkFont.BOLD:
            styleList.append( 'bold' )
        if self._slant.get() == tkFont.ITALIC:
            styleList.append( 'italic' )
        if self._isUnderline.get():
            styleList.append( 'underline' )
        if self._isOverstrike.get():
            styleList.append( 'overstrike' )

        if len(styleList) == 0:
            return family+ ' ' + str(size)
        else:
            xx=''
            for x in styleList:
                xx=xx+' '+ x
            return family + ' ' +str(size) +' '+xx

    def getFontTuple( self ):
        family = self._family.get()
        size   = int(self._sizeString.get())

        styleList = [ ]
        if self._weight.get() == tkFont.BOLD:
            styleList.append( 'bold' )
        if self._slant.get() == tkFont.ITALIC:
            styleList.append( 'italic' )
        if self._isUnderline.get():
            styleList.append( 'underline' )
        if self._isOverstrike.get():
            styleList.append( 'overstrike' )

        if len(styleList) == 0:
            return family, size
        else:
            return family, size, ' '.join( styleList )
Пример #26
0
class Example(Frame):

	def __init__(self, parent):
		Frame.__init__(self, parent)
		self.parent = parent
		self.initUI()
		self.centerUI(w=570,h=240)

	def initUI(self):

		self.parent.title("DBLR for Dummies")
		self.pack(fill=BOTH, expand=True)

		#self.columnconfigure(0, weight=1)
		#self.rowconfigure(0, weight=1)
		# weight attibute is used to make them growable

		self.meas       = IntVar()
		self.base_path  = StringVar()
		self.coef       = DoubleVar()
		self.noise      = DoubleVar()
		self.n_sigma    = DoubleVar()
		self.thr1       = DoubleVar()
		self.thr2       = DoubleVar()
		self.thr3       = DoubleVar()
		self.graph_sw   = BooleanVar()

		#Image
		factor=0.65
		search = Image.open("NEXT_official_logo.jpg")
		width_org, height_org = search.size		
		search_temp = search.resize((int(width_org*factor), 
							int(height_org*factor)), Image.ANTIALIAS)
		search_aux = ImageTk.PhotoImage(search_temp)
		label1 = Label(self, image=search_aux)
		label1.image = search_aux
		label1.grid(row=0, column=4,
				columnspan=2, rowspan=3, padx=5)


		self.base_path.set("F:/DATOS_DAC/2052/pmt_0_trace_evt_")
		e1 = Entry(self, textvariable=self.base_path, width=40)
		e1.grid(row=0,column=1, sticky=W, columnspan=3, pady=5, padx=5)
		e1_label = Label(self, text="Path & Name")
		e1_label.grid(row=0,column=0, columnspan=1, sticky=E, pady=5, padx=5)

		self.meas.set("1")
		sb1 = Spinbox(self, from_=1, to=100, 
				  width=4, textvariable=self.meas)
		sb1.grid(row=2,column=1, sticky=W, pady=5, padx=5)
		sb1_label = Label(self, text="File")
		sb1_label.grid(row=2,column=0, padx=5, sticky=E)
		
		#Check buttons
		cb1 = Checkbutton(self, text="New Graph", variable=self.graph_sw)
		cb1.select()
		cb1.grid(row=2,column=2, sticky=W)


		#PARAMETERS
		Integration_label = Label(self, text="PARAMETERS",
		                          font = "Verdana 12 bold")
		Integration_label.grid(row=3,column=1,
						padx=5,
						columnspan = 2, pady=10, sticky=E)

		self.coef.set("1.625E-3")
		e2 = Entry(self, width=12, textvariable=self.coef)
		e2.grid(row=4,column=1, sticky=W, pady=5, padx=5)
		e2_label = Label(self, text="DBLR Coef")
		e2_label.grid(row=4,column=0, sticky=E, pady=5, padx=5)

		self.noise.set("0.75")
		e3 = Entry(self, width=12, textvariable=self.noise)
		e3.grid(row=4,column=3, sticky=W, pady=5, padx=5)
		e3_label = Label(self, text="Noise (LSB)")
		e3_label.grid(row=4,column=2, sticky=E, pady=5, padx=5)
		
		self.n_sigma.set("4")
		e4 = Entry(self, width=12, textvariable=self.n_sigma)
		e4.grid(row=4,column=5, sticky=W, pady=5, padx=5)
		e4_label = Label(self, text="Noise Threshold")
		e4_label.grid(row=4,column=4, sticky=E, pady=5, padx=5)

		self.thr1.set("3")
		e5 = Entry(self, width=12, textvariable=self.thr1)
		e5.grid(row=5,column=1, sticky=W, pady=5, padx=5)
		e5_label = Label(self, text="Threshold 1")
		e5_label.grid(row=5,column=0, sticky=E, pady=5, padx=5)

		self.thr2.set("5")
		e6 = Entry(self, width=12, textvariable=self.thr2)
		e6.grid(row=5,column=3, sticky=W, pady=5, padx=5)
		e6_label = Label(self, text="Threshold 2")
		e6_label.grid(row=5,column=2, sticky=E, pady=5, padx=5)

		self.thr3.set("1")
		e7 = Entry(self, width=12, textvariable=self.thr3)
		e7.grid(row=5,column=5, sticky=W, pady=5, padx=5)
		e7_label = Label(self, text="Threshold 3")
		e7_label.grid(row=5,column=4, sticky=E, pady=5, padx=5)





		# Main buttons
		obtn = Button(self, text="GO!!", command=self.DBLR_f)
		obtn.grid(row=6, column=4, sticky=E, pady=10)

		cbtn = Button(self, text="Quit", command=self.quit)
		cbtn.grid(row=6, column=5, sticky=E, pady=10)

		hbtn = Button(self, text="Help", command=self.help_f)
		hbtn.grid(row=6, column=0, sticky=W, pady=10)
		

	def help_f(self):
		top = Toplevel()
		top.title("HELP")
		msg = Message(top, width= 500, 
                 text="Noise Threshold (NT) - Noise Based Main Threshold \
(Sigmas)\n Threshold 1 - Main Threshold (LSBs) \n Threshold 2 - End of Pulse Error \n \
Threshold 3 - End of Tail Error \n When Thr1 = Thr3 = 0 their values are defined as: \n \
(THR1 = NT (LSBs) / THR3 = NT*NOISE_ADC / 5)") 
		msg.pack()

		button = Button(top, text="Close", command=top.destroy)
		button.pack()
#		tkMessageBox.showinfo("HELP", "Noise Threshold (NT) - Noise Based Main Threshold (Sigmas)\
#Threshold 1 - Main Threshold (LSBs)\
#Threshold 2 - End of Pulse Error\
#Threshold 3 - End of Tail Error\
#When Thr1 = Thr3 = 0 their values are defined as:\
#(THR1 = NT (LSBs) / THR3 = NT*NOISE_ADC/5)")


	def DBLR_f(self):
		
		global a
		
		if (self.graph_sw.get()==True): 
			b=a
			a=a+1
		else: 
			b=0		
		
		aux=self.base_path.get()
		path=''.join([aux,str(self.meas.get()),'.txt'])
		g=pd.read_csv(path)
		f=4096-g.values

		recons,energia = DB.BLR( signal_daq=f.flatten().astype(float),
						  coef=self.coef.get(),
						  n_sigma=self.n_sigma.get(),
						  NOISE_ADC=self.noise.get(),
						  thr1=self.thr1.get(),
						  thr2=self.thr2.get(),
						  thr3=self.thr3.get(),
						  plot=False)
		plt.figure(a)						
		plt.plot(recons)
		plt.figtext(0.2,0.75, ('ENERGY = %0.2f ' % (energia)))
		plt.show(block=False)
				

	def centerUI(self,w,h):
		sw = self.parent.winfo_screenwidth()
		sh = self.parent.winfo_screenheight()
		x  = (sw-w)/2
		y  = (sh-h)/2
		self.parent.geometry('%dx%d+%d+%d' % (w,h,x,y))
Пример #27
0
class ScalePanel(PluginPanel):
    name = 'ScaleAndMirror'
    title = _("Scale and Mirror")

    def init(self, master):
        PluginPanel.init(self, master)

        self.width_priority = 1

        root = self.mw.root
        self.var_width = DoubleVar(root)
        self.var_height = DoubleVar(root)

        unit = '%'
        jump = 5

        self.var_proportional = IntVar(root)
        self.var_proportional.set(0)

        self.var_basepoint = StringVar(root)
        self.var_basepoint.set('C')

        #---------------------------------------------------------
        top = TFrame(self.panel, style='FlatFrame')
        top.pack(side=TOP, fill=BOTH)
        #---------------------------------------------------------
        # Horisontal size
        size_frameH = TFrame(top, style='FlatFrame', borderwidth=3)
        size_frameH.pack(side=TOP, fill=BOTH)

        label = TLabel(size_frameH, style='FlatLabel', image='size_h')
        label.pack(side=LEFT, padx=5)
        self.entry_width = TSpinbox(size_frameH,
                                    var=100,
                                    vartype=1,
                                    textvariable=self.var_width,
                                    min=-30000,
                                    max=30000,
                                    step=jump,
                                    width=6,
                                    command=self.apply_scale)
        self.entry_width.pack(side=LEFT)

        self.entry_width.down_button.bind('<ButtonRelease>',
                                          self.entry_width_chang)
        self.entry_width.down_button.bind('<KeyRelease>',
                                          self.entry_width_chang)
        self.entry_width.up_button.bind('<ButtonRelease>',
                                        self.entry_width_chang)
        self.entry_width.up_button.bind('<KeyRelease>', self.entry_width_chang)
        self.entry_width.entry.bind('<ButtonRelease>', self.entry_width_chang)
        self.entry_width.entry.bind('<KeyRelease>', self.entry_width_chang)
        self.entry_width.entry.bind('<FocusOut>', self.entry_width_chang)
        self.entry_width.entry.bind('<FocusIn>', self.entry_width_FocusIn)

        self.labelwunit = TLabel(size_frameH, style='FlatLabel', text=unit)
        self.labelwunit.pack(side=LEFT, padx=5)

        self.hflip = BooleanVar(root)
        self.hflip.set(0)
        button = TCheckbutton(size_frameH,
                              image="pstrip_hflip",
                              style='ToolBarCheckButton',
                              variable=self.hflip,
                              command=None)
        button.pack(side=LEFT)

        #---------------------------------------------------------
        # Vertical

        size_frameV = TFrame(top, style='FlatFrame', borderwidth=3)
        size_frameV.pack(side=TOP, fill=BOTH)
        label = TLabel(size_frameV, style='FlatLabel', image='size_v')
        label.pack(side=LEFT, padx=5)

        self.entry_height = TSpinbox(size_frameV,
                                     var=100,
                                     vartype=1,
                                     textvariable=self.var_height,
                                     min=-30000,
                                     max=30000,
                                     step=jump,
                                     width=6,
                                     command=self.apply_scale)
        self.entry_height.pack(side=LEFT)

        self.entry_height.down_button.bind('<ButtonRelease>',
                                           self.entry_height_chang)
        self.entry_height.down_button.bind('<KeyRelease>',
                                           self.entry_height_chang)
        self.entry_height.up_button.bind('<ButtonRelease>',
                                         self.entry_height_chang)
        self.entry_height.up_button.bind('<KeyRelease>',
                                         self.entry_height_chang)
        self.entry_height.entry.bind('<ButtonRelease>',
                                     self.entry_height_chang)
        self.entry_height.entry.bind('<KeyRelease>', self.entry_height_chang)
        self.entry_height.entry.bind('<FocusOut>', self.entry_height_chang)
        self.entry_height.entry.bind('<FocusIn>', self.entry_height_FocusIn)

        self.labelhunit = TLabel(size_frameV, style='FlatLabel', text=unit)
        self.labelhunit.pack(side=LEFT, padx=5)

        self.vflip = BooleanVar(root)
        self.vflip.set(0)
        button = TCheckbutton(size_frameV,
                              image="pstrip_vflip",
                              style='ToolBarCheckButton',
                              variable=self.vflip,
                              command=None)
        button.pack(side=LEFT)

        #---------------------------------------------------------
        # Proportional chek

        self.proportional_check = TCheckbutton(top,
                                               text=_("Proportional"),
                                               variable=self.var_proportional,
                                               command=self.proportional)
        self.proportional_check.pack(side=TOP, anchor=W, padx=5, pady=5)

        #---------------------------------------------------------
        # Basepoint check
        label = TLabel(top, style='FlatLabel', text=_("Basepoint:"))
        label.pack(side=TOP, fill=BOTH, padx=5)
        basepoint_frame = TLabelframe(top,
                                      labelwidget=label,
                                      style='Labelframe',
                                      borderwidth=4)
        basepoint_frame.pack(side=TOP, fill=X, padx=5, pady=2)

        self.Basepoint = BasePointSelector(basepoint_frame,
                                           anchor=self.var_basepoint)
        self.Basepoint.pack(side=LEFT, fill=BOTH, padx=5)

        label = TLabel(basepoint_frame,
                       style='FlatLabel',
                       image='coordinate_sys')
        label.pack(side=LEFT, fill=BOTH, padx=10)

        #---------------------------------------------------------
        # Button frame

        button_frame = TFrame(top, style='FlatFrame', borderwidth=5)
        button_frame.pack(side=BOTTOM, fill=BOTH)

        self.update_buttons = []
        self.button = UpdatedButton(top,
                                    text=_("Apply"),
                                    command=self.apply_scale)
        self.button.pack(in_=button_frame,
                         side=BOTTOM,
                         expand=1,
                         fill=X,
                         pady=3)

        self.button_copy = UpdatedButton(top,
                                         text=_("Apply to Copy"),
                                         command=self.apply_to_copy)
        self.button_copy.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X)

        self.init_from_doc()
        self.subscribe_receivers()


###############################################################################

    def subscribe_receivers(self):
        self.document.Subscribe(SELECTION, self.Update)

    def unsubscribe_receivers(self):
        self.document.Unsubscribe(SELECTION, self.Update)

    def init_from_doc(self, *arg):
        self.Update()

    def Update(self, *arg):
        if self.is_selection():
            self.entry_width.set_state(NORMAL)
            self.entry_height.set_state(NORMAL)
            self.proportional_check['state'] = NORMAL
            self.button['state'] = NORMAL
            self.button_copy['state'] = NORMAL
        else:
            self.entry_width.set_state(DISABLED)
            self.entry_height.set_state(DISABLED)
            self.proportional_check['state'] = DISABLED
            self.button['state'] = DISABLED
            self.button_copy['state'] = DISABLED

    def entry_width_FocusIn(self, *arg):
        self.width_priority = 1

    def entry_height_FocusIn(self, *arg):
        self.width_priority = 0

    def ScaleSelected(self, h, v, cnt_x=None, cnt_y=None):
        text = _("Scale")
        if self.document.selection:
            self.document.begin_transaction(text)
            try:
                try:
                    br = self.document.selection.coord_rect
                    hor_sel = br.right - br.left
                    ver_sel = br.top - br.bottom
                    if cnt_x is None:
                        cnt_x = hor_sel / 2 + br.left
                    if cnt_y is None:
                        cnt_y = ver_sel / 2 + br.bottom
                    trafo = Trafo(h, 0, 0, v, cnt_x - cnt_x * h,
                                  cnt_y - cnt_y * v)
                    self.document.TransformSelected(trafo, text)
                except:
                    self.document.abort_transaction()
            finally:
                self.document.end_transaction()

    def ScaleAndCopy(self, h, v, cnt_x=None, cnt_y=None):
        text = _("Scale&Copy")
        if self.document.selection:
            self.document.begin_transaction(text)
            try:
                try:
                    br = self.document.selection.coord_rect
                    hor_sel = br.right - br.left
                    ver_sel = br.top - br.bottom
                    if cnt_x is None:
                        cnt_x = hor_sel / 2 + br.left
                    if cnt_y is None:
                        cnt_y = ver_sel / 2 + br.bottom
                    trafo = Trafo(h, 0, 0, v, cnt_x - cnt_x * h,
                                  cnt_y - cnt_y * v)
                    self.document.ApplyToDuplicate()
                    self.document.TransformSelected(trafo, text)
                except:
                    self.document.abort_transaction()
            finally:
                self.document.end_transaction()

    def entry_height_chang(self, *arg):
        if self.var_proportional.get():
            self.var_width.set(self.var_height.get())

    def entry_width_chang(self, *arg):
        if self.var_proportional.get():
            self.var_height.set(self.var_width.get())

    def proportional(self):
        if self.width_priority:
            self.entry_width_chang()
        else:
            self.entry_height_chang()

    def apply_scale(self, *arg):
        if self.button["state"] == DISABLED:
            return
        self.proportional()
        width = self.var_width.get()
        height = self.var_height.get()
        br = self.document.selection.coord_rect
        hor_sel = br.right - br.left
        ver_sel = br.top - br.bottom
        cnt_x, cnt_y = self.Basepoint.get_basepoint(hor_sel, ver_sel, br.left,
                                                    br.bottom)

        h = width / 100
        if h == 0:
            h = 1
        if self.hflip.get():
            h = -1 * h

        v = height / 100
        if v == 0:
            v = 1
        if self.vflip.get():
            v = -1 * v

        if arg and arg[0] == 'Duplicate':
            self.ScaleAndCopy(h, v, cnt_x, cnt_y)
        else:
            self.ScaleSelected(h, v, cnt_x, cnt_y)

    def apply_to_copy(self):
        self.apply_scale('Duplicate')

    def is_selection(self):
        return (len(self.document.selection) > 0)
Пример #28
0
class MainUI(Frame):
    """
    Main UI window for draft
    """
    
    def __init__(self, parent, draftgame):

        self.current_opponent_id = 0
        self.user_pick_made = BooleanVar()
        self.user_pick_made.set(False)

        self.game = draftgame
        self.parent = parent
        Frame.__init__(self, parent)
        self.grid()        
        self.__MainUI()

        self.draft_logic()

    def draft_logic(self):

        if self.game.draft_style == "Linear":
            self.linear_draft()

        elif self.game.draft_style == "Snake":
            self.snake_draft()

        FinalUI(self.parent, self.game)

    def linear_draft(self):
        while self.game.current_round <= self.game.number_of_rounds:
            if self.game.draft_position != self.game.current_position:
                self.opponent_pick_logic(self.current_opponent_id)
                self.current_opponent_id += 1
                self.increment_position()
            else:
                self.user_pick_logic()
                self.increment_position()

    def snake_draft(self):
        while self.game.current_round <= self.game.number_of_rounds:
            if self.game.current_round % 2 != 0:
                if self.game.draft_position != self.game.current_position:
                    self.opponent_pick_logic(self.current_opponent_id)
                    self.current_opponent_id += 1
                    self.increment_position()
                else:
                    self.user_pick_logic()
                    self.increment_position()
            else:
                if self.game.draft_position != \
                                        self.game.number_of_opponents \
                                        - self.game.current_position + 2:
                    self.opponent_pick_logic(
                        self.game.number_of_opponents - self.current_opponent_id - 1
                    )
                    self.current_opponent_id += 1
                    self.increment_position()
                else:
                    self.user_pick_logic()
                    self.increment_position()

    def increment_position(self):

        self.game.current_position += 1

        if self.game.current_position > self.game.number_of_opponents + 1:
            self.game.current_round += 1
            self.game.current_position = 1
            self.current_opponent_id = 0

        self.__MainUI()

    def user_pick_logic(self):

        self.user_pick_made.set(False)

        while not self.user_pick_made.get():
            self.wait_variable(name=self.user_pick_made)

    def opponent_pick_logic(self, opponent_id):
        pick_made = False

        pick = tkSimpleDialog.askstring(
            "Opponent's pick",
            "Who did your opponent pick?\nCurrent Pick: Round {0}: Pick {1}"
            .format(self.game.current_round, self.game.current_position))

        while not pick_made:
            try:
                if utils.get_player_position(pick, self.game.cursor) is not None:
                    position = utils.get_player_position(pick, self.game.cursor).rstrip('0123456789 ').upper()
                    if utils.get_player_from_table(pick, position, self.game.cursor) is not None:
                        utils.remove_player_from_possible_players(pick, self.game.connection, self.game.cursor)
                        opponent = [opponent for opponent in self.game.opponents if opponent_id == opponent.id][0]
                        opponent.team.append(pick)
                        pick_made = True
                    else:
                        pick = tkSimpleDialog.askstring(
                            "Opponent's pick",
                            "NOT A VALID PICK: please select again\nCurrent Pick: Round {0}: Pick {1}"
                            .format(self.game.current_round, self.game.current_position))

                else:
                    pick = tkSimpleDialog.askstring(
                        "Opponent's pick",
                        "NOT A VALID PICK: please select again\nCurrent Pick: Round {0}: Pick {1}"
                        .format(self.game.current_round, self.game.current_position))
            except AttributeError:
                tkMessageBox.showinfo("Error", "Opponent must pick a valid player")
                pick = tkSimpleDialog.askstring(
                    "Opponent's pick",
                    "NOT A VALID PICK: please select again\nCurrent Pick: Round {0}: Pick {1}"
                    .format(self.game.current_round, self.game.current_position))

    def __MainUI(self):

        self.parent.title("Fantasy Football Helper")
               
        for widget in self.parent.winfo_children():
            widget.destroy()

        self.__draw_round_label(self.parent)
        self.__draw_recommended_list(self.parent)
        self.__draw_valuable_list(self.parent)
        self.__draw_current_team(self.parent)
        self.__draw_team_requirements(self.parent)
        self.__draw_current_choice(self.parent)
        self.__draw_opponent_teams(self.parent)

    def __draw_round_label(self, parent):

        Label(parent, text="Round{0}: Pick{1}".format(self.game.current_round,
                                                      self.game.current_position)).grid(row=0)

    def __draw_current_choice(self, parent):
        
        choice = IntVar()
        other_player = StringVar()
        recommended = self.game.most_recommended_player_remaining()
        valuable = self.game.get_best_player_remaining()
        
        recommended_button = Radiobutton(parent, text=recommended, variable=choice, value=1)
        valuable_button = Radiobutton(parent, text=valuable, variable=choice, value=2)
        other_button = Radiobutton(parent, text="", variable=choice, takefocus=0, value=3)
        other_text = Entry(parent, textvariable=other_player)
        
        def text_focus(event):
            other_button.select()
        
        other_text.bind("<Button-1>", text_focus)

        def pick_player():

            decision = choice.get()

            if decision == 1:

                player = self.game.most_recommended_player_remaining()
                self.game.add_player_to_team(player)
                utils.remove_player_from_possible_players(
                    player,
                    self.game.connection,
                    self.game.cursor)
                self.user_pick_made.set(True)

            elif decision == 2:

                player = self.game.get_best_player_remaining()
                self.game.add_player_to_team(player)
                utils.remove_player_from_possible_players(
                    player,
                    self.game.connection,
                    self.game.cursor)
                self.user_pick_made.set(True)

            elif decision == 3:
                player = other_player.get()
                try:
                    self.game.add_player_to_team(player)
                    utils.remove_player_from_possible_players(
                        player,
                        self.game.connection,
                        self.game.cursor)
                    self.user_pick_made.set(True)
                except:
                    tkMessageBox.showinfo("Error", "Can't add that player to team, try again.")
                    self.user_pick_logic()

            else:
                tkMessageBox.showinfo("No Selection", "Please make a selection")
                self.user_pick_logic()

        def pick_player_button(event):
            pick_player()

        Label(parent, text="Recommended Player").grid(sticky="w", row=1)
        recommended_button.grid(sticky="w", row=1, column=1, columnspan=2)
        
        Label(parent, text="Most Valuable Player").grid(sticky="w", row=2)
        valuable_button.grid(sticky="w", row=2, column=1, columnspan=2)
        
        Label(parent, text="Choose other Player").grid(sticky="w", row=3)
        other_button.grid(sticky="w", row=3, column=1)
        other_text.grid(row=3, column=2, sticky="w", padx=5)
        
        pick_button = Button(parent, text="Pick", command=pick_player).grid(
            row=4, columnspan=3, sticky="ne", padx=5)
        self.parent.bind("<Return>", pick_player_button)
        
    def __draw_recommended_list(self, parent):
        
        recommended_list = self.game.get_list_recommended_players("10")
        recommended_listbox = Text(parent, height=10, width=35)
        
        Label(parent, text="List of Recommended Players").grid(row=1, column=3)
        recommended_listbox.grid(row=2, column=3, rowspan=4, sticky="n")
        for player in recommended_list:
            index = str(recommended_list.index(player) + 1)
            recommended_listbox.insert("end", "{0:>2}:{1:<20} {2} {3}\n".format(index,
                                                                                player[0],
                                                                                player[2],
                                                                                format(player[1], '.0f'))
                                       )
           
        recommended_listbox.config(state="disabled")
        
    def __draw_valuable_list(self, parent):
        
        valuable_list = self.game.get_list_of_best_players("10")
        valuable_listbox = Text(parent, height=10, width=35)
        
        Label(parent, text="List of Most Valuable Players").grid(row=1, column=4)
        valuable_listbox.grid(row=2, column=4, rowspan=4, sticky="n", padx=10)
        for player in valuable_list:
            index = str(valuable_list.index(player) + 1)
            valuable_listbox.insert("end",
                                    "{0:>2}:{1:<20} {2} {3}\n".format(index,
                                                                      player[0],
                                                                      player[2],
                                                                      format(player[1], '.0f'))
                                    )

        valuable_listbox.config(state="disabled")
            
    def __draw_team_requirements(self, parent):
        
        requirements = self.game.check_current_team_needs()
        requirement_list = []
        
        for key in requirements.keys():
            # key_string = "%d%s" % (requirements[key], key)
            requirement_list.append("{0}{1}".format(requirements[key], key))

        Label(parent, text="Still Need: " + ", ".join(requirement_list)).grid(
            row=5, columnspan=3, sticky="w")
            
    def __draw_current_team(self, parent):
        
        current_team = self.game.current_team
        team_list = []
        
        for key in current_team.keys():
            # player_string = "%s %s" % (key, current_team[key])
            team_list.append("{0}: {1}".format(key, current_team[key]))
        
        current_team_string = (", ".join(team_list[0:len(team_list) / 2 + 1])
                               + "\n" + ", ".join(team_list[len(team_list) / 2 + 1:]))
        
        Label(parent, text="Current Team: ").grid(
            row=6)
        Label(parent, text=current_team_string).grid(
            row=6, column=1, columnspan=4, pady=10)

    def __draw_opponent_teams(self, parent):

        opponents = self.game.opponents

        for opponent in opponents:
            Label(parent, text="Opponent{0}'s Team: ".format(opponent.id + 1)).grid(
                row=7 + opponent.id)
            Label(parent, text=str(opponent.team)).grid(
                row=7 + opponent.id,
                column=1, columnspan=4)
Пример #29
0
class vco_model_win(Toplevel):
    def __init__(self, parent):
        Toplevel.__init__(self)

        img = ImageTk.PhotoImage(file=os.path.join(os.path.dirname(__file__),
                                                   'Icons/LMS8001_PLLSim.png'))
        self.tk.call('wm', 'iconphoto', self._w, img)

        self.resizable(0, 0)

        self.parent = parent
        self.pll = self.parent.pll

        self.initUI()
        center_Window(self)
        self.protocol("WM_DELETE_WINDOW", self.on_Quit)

    def initUI(self):
        self.title("LMS8001-PLL-VCO Model Definition")

        self.style = Style()
        self.style.theme_use("default")

        self.columnconfigure(0, pad=1)
        self.columnconfigure(1, pad=1)
        self.columnconfigure(2, pad=1)
        #self.columnconfigure(3, pad=1, weight=1)

        self.rowconfigure(0, pad=10)
        self.rowconfigure(1, pad=1, weight=1)
        self.rowconfigure(2, pad=1, weight=1)
        self.rowconfigure(3, pad=15, weight=1)
        self.rowconfigure(4, pad=1, weight=1)

        self.VCO_EM = BooleanVar()
        self.VCO_EM.set(self.parent.VCO_EM.get())
        self.cbox_vco_em = Checkbutton(self,
                                       text='Use EM (RLCK) VCO Model',
                                       onvalue=1,
                                       offvalue=0,
                                       variable=self.VCO_EM,
                                       command=self.on_VCO_EM)
        self.cbox_vco_em.grid(row=0, column=0, columnspan=3, sticky=W)

        self.radio_fvco = IntVar()
        self.radio_fvco.set(int(self.parent.VCO_MEAS_FREQ.get()))
        self.radio_fvco_meas = Radiobutton(
            self,
            text='Use Measured VCO Frequency Values in Analysis',
            variable=self.radio_fvco,
            value=1)
        self.radio_fvco_meas.grid(row=1,
                                  column=0,
                                  columnspan=2,
                                  padx=15,
                                  sticky=W + N)
        self.radio_fvco_sim = Radiobutton(
            self,
            text='Use Simulated VCO Frequency Values in Analysis',
            variable=self.radio_fvco,
            value=0)
        self.radio_fvco_sim.grid(row=2,
                                 column=0,
                                 columnspan=2,
                                 padx=15,
                                 sticky=W + N)

        buttonFreq = Button(self,
                            text='Plot Freq',
                            command=self.on_FREQ,
                            width=10)
        buttonFreq.grid(row=3, column=0, sticky=W + E)

        buttonKVCO = Button(self,
                            text='Plot KVCO',
                            command=self.on_KVCO,
                            width=10)
        buttonKVCO.grid(row=3, column=1, sticky=W + E)

        buttonFSTEP = Button(self,
                             text='Plot FSTEP',
                             command=self.on_FSTEP,
                             width=17)
        buttonFSTEP.grid(row=3, column=2, sticky=W + E)

        buttonOK = Button(self, text='OK', command=self.on_OK, width=10)
        buttonOK.grid(row=4, column=0, sticky=W + E)

        buttonQuit = Button(self, text='Quit', command=self.on_Quit, width=17)
        buttonQuit.grid(row=4, column=2, sticky=W + E)

        buttonApply = Button(self,
                             text='Apply',
                             command=self.on_Apply,
                             width=10)
        buttonApply.grid(row=4, column=1, sticky=W + E)

        self.on_VCO_EM()

        #self.pack(fill=BOTH, expand=True)

    def get_vals(self):
        if (self.VCO_EM.get()):
            EM_MODEL = True
            if (self.radio_fvco.get()):
                MEAS_FREQ = True
            else:
                MEAS_FREQ = False
        else:
            EM_MODEL = False
            MEAS_FREQ = False
        return (EM_MODEL, MEAS_FREQ)

    def on_FREQ(self):
        (EM_MODEL, MEAS_FREQ) = self.get_vals()
        vco = lms8001_vco(EM_MODEL=EM_MODEL, MEAS_FREQ=MEAS_FREQ)
        fvco = np.array(np.empty([3, 256]))
        for sel in range(1, 4):
            for freq in range(0, 256):
                fvco[sel - 1, freq] = vco.calcF(sel, freq, 0.6)

        figure(15)
        plt1, = plotsig(range(0, 256),
                        fvco[0, :] / 1.0e9,
                        15,
                        xlabel='$Cap. Bank Code$',
                        ylabel='$F_{VCO} [GHz]$',
                        title='VCO Frequency vs. Cap Bank Code',
                        line_color='black',
                        font_name=self.parent.font_name)
        plt2, = plotsig(range(0, 256),
                        fvco[1, :] / 1.0e9,
                        15,
                        xlabel='$Cap. Bank Code$',
                        ylabel='$F_{VCO} [GHz]$',
                        title='VCO Frequency vs. Cap Bank Code',
                        line_color='blue',
                        font_name=self.parent.font_name)
        plt3, = plotsig(range(0, 256),
                        fvco[2, :] / 1.0e9,
                        15,
                        xlabel='$Cap. Bank Code$',
                        ylabel='$F_{VCO} [GHz]$',
                        title='VCO Frequency vs. Cap Bank Code',
                        line_color='red',
                        font_name=self.parent.font_name)
        setlegend(15, [plt1, plt2, plt3],
                  ['VCO_SEL=1', 'VCO_SEL=2', 'VCO_SEL=3'],
                  font_name=self.parent.font_name)
        show_plots()

    def on_KVCO(self):
        (EM_MODEL, MEAS_FREQ) = self.get_vals()
        vco = lms8001_vco(EM_MODEL=EM_MODEL, MEAS_FREQ=MEAS_FREQ)
        fvco = np.array(np.empty([3, 256]))
        NDIV = np.array(np.empty([3, 256]))
        kvco = np.array(np.empty([3, 256]))
        for sel in range(1, 4):
            for freq in range(0, 256):
                fvco[sel - 1, freq] = vco.calcF(sel, freq, 0.6)
                kvco[sel - 1, freq] = vco.calcKVCO(sel, freq, 0.6)
                NDIV[sel - 1, freq] = 1.0 * fvco[sel - 1, freq] / self.pll.Fref

        for sel in range(1, 4):
            kvco_avg = 1.0
            kvco_over_NDIV_avg = 1.0
            for freq in range(0, 256):
                kvco_avg = kvco_avg * (kvco[sel - 1, freq] / 1.0e6)**(1.0 /
                                                                      256)
                kvco_over_NDIV_avg = kvco_over_NDIV_avg * (
                    (kvco[sel - 1, freq] / 1.0e6) /
                    NDIV[sel - 1, freq])**(1.0 / 256.0)

            print 'VCO_SEL=%d, KVCO_AVG=%.3f MHz/V, KVCO_over_NDIV_AVG=%.3f MHz/V' % (
                sel, kvco_avg, kvco_over_NDIV_avg)
        print ''

        figure(16)
        plt1, = plotsig(fvco[0, :] / 1.0e9,
                        kvco[0, :] / 1.0e6,
                        16,
                        xlabel='$F_{VCO} [GHz]$',
                        ylabel='$K_{VCO} [MHz/V]$',
                        title='VCO Sensitivity vs. Frequency',
                        line_color='black',
                        font_name=self.parent.font_name)
        plt2, = plotsig(fvco[1, :] / 1.0e9,
                        kvco[1, :] / 1.0e6,
                        16,
                        xlabel='$F_{VCO} [GHz]$',
                        ylabel='$K_{VCO} [MHz/V]$',
                        title='VCO Sensitivity vs. Frequency',
                        line_color='blue',
                        font_name=self.parent.font_name)
        plt3, = plotsig(fvco[2, :] / 1.0e9,
                        kvco[2, :] / 1.0e6,
                        16,
                        xlabel='$F_{VCO} [GHz]$',
                        ylabel='$K_{VCO} [MHz/V]$',
                        title='VCO Sensitivity vs. Frequency',
                        line_color='red',
                        font_name=self.parent.font_name)
        setlegend(16, [plt1, plt2, plt3],
                  ['VCO_SEL=1', 'VCO_SEL=2', 'VCO_SEL=3'],
                  font_name=self.parent.font_name)
        show_plots()

    def on_FSTEP(self):
        (EM_MODEL, MEAS_FREQ) = self.get_vals()
        vco = lms8001_vco(EM_MODEL=EM_MODEL, MEAS_FREQ=MEAS_FREQ)
        fstep = np.array(np.empty([3, 255]))
        for sel in range(1, 4):
            for freq in range(0, 255):
                fstep[sel - 1,
                      freq] = vco.calcF(sel, freq + 1, 0.6) - vco.calcF(
                          sel, freq, 0.6)

        figure(17)
        plt1, = plotsig(
            range(0, 255),
            fstep[0, :] / 1.0e6,
            17,
            xlabel='$Cap. Bank Code$',
            ylabel='$F_{STEP} [MHz/V]$',
            title='VCO Frequency Step Between Adjacent Tuning Bands',
            line_color='black',
            font_name=self.parent.font_name)
        plt2, = plotsig(
            range(0, 255),
            fstep[1, :] / 1.0e6,
            17,
            xlabel='$Cap. Bank Code$',
            ylabel='$F_{STEP} [MHz/V]$',
            title='VCO Frequency Step Between Adjacent Tuning Bands',
            line_color='blue',
            font_name=self.parent.font_name)
        plt3, = plotsig(
            range(0, 255),
            fstep[2, :] / 1.0e6,
            17,
            xlabel='$Cap. Bank Code$',
            ylabel='$F_{STEP} [MHz/V]$',
            title='VCO Frequency Step Between Adjacent Tuning Bands',
            line_color='red',
            font_name=self.parent.font_name)
        setlegend(17, [plt1, plt2, plt3],
                  ['VCO_SEL=1', 'VCO_SEL=2', 'VCO_SEL=3'],
                  font_name=self.parent.font_name)
        show_plots()

    def on_VCO_EM(self):
        if (self.VCO_EM.get()):
            self.radio_fvco_meas.config(state='enabled')
            self.radio_fvco_sim.config(state='enabled')
        else:
            self.radio_fvco_meas.config(state='disabled')
            self.radio_fvco_sim.config(state='disabled')

    def on_OK(self):
        self.on_Apply()
        self.on_Quit()

    def on_Quit(self):
        self.parent.vco_model_win = None
        self.destroy()

    def on_Apply(self):
        (EM_MODEL, MEAS_FREQ) = self.get_vals()
        self.parent.VCO_EM.set(EM_MODEL)
        self.parent.VCO_MEAS_FREQ.set(MEAS_FREQ)

        self.pll.vco = lms8001_vco(SEL=2,
                                   FREQ=128,
                                   EM_MODEL=EM_MODEL,
                                   MEAS_FREQ=MEAS_FREQ)
Пример #30
0
 def test_get(self):
     v = BooleanVar(self.root, True, "name")
     self.assertAlmostEqual(True, v.get())
     self.root.globalsetvar("name", "0")
     self.assertAlmostEqual(False, v.get())
Пример #31
0
class CreateMask(Frame):
    def __init__(self,
                 parent,
                 filename=None,
                 dirname=None,
                 mask4d=False,
                 obj_return_value=None):
        Frame.__init__(self, parent)
        self.parent = parent
        self.obj_return_value = obj_return_value

        if dirname is None:
            self.dirname = ''
        else:
            self.dirname = dirname

        if filename is None or not os.path.isfile(filename):
            if dirname is not None:
                filename = tkFileDialog.askopenfilename(initialdir=dirname)
            else:
                filename = tkFileDialog.askopenfilename()

        if not os.path.isfile(filename):
            parent.destroy()
            return

        self.readImage(filename)
        _, _, filename_mask = create_mask.set_filenames(filename)
        self.filename_mask = filename_mask + '.nii.gz'

        if mask4d:
            if len(self.shape) > 3:
                self.mask_base = np.zeros(self.shape, dtype=np.int8)
                self.mask = self.mask_base[:, :, :, 0]
                self.mask4d = True
        else:
            self.mask = np.zeros(self.shape[:3], dtype=np.int8)
            self.mask4d = False
        self.volume = 0

        self.initUI()

        self.modifyUI()
        self.drawSlice()

    def initUI(self):
        self.frame_bottom = Frame(self)
        self.frame_main = Frame(self)

    def modifyUI(self):
        frame_bottom = self.frame_bottom
        frame_main = self.frame_main
        self.sliceView = [
            ImshowMplCanvas(frame_main) for k in range(self.shape[2])
        ]
        self.sliceSpin = [
            MySpinBox(frame_main, k) for k in range(self.shape[2])
        ]

        #Layout
        self.parent.title('CreateMask')

        max_spin = 0
        if self.mask4d:
            max_spin = self.shape[3] - 1
        self.spin_volume = Spinbox(frame_bottom,
                                   from_=0,
                                   to=max_spin,
                                   increment=1,
                                   command=self.change_volume,
                                   width=8)
        self.reset_box(self.spin_volume, 0)

        buttonMask = Button(frame_bottom,
                            text='B0 from Bval...',
                            command=self.createBaseImage)
        buttonMaskCreate = Button(frame_bottom,
                                  text='Create',
                                  command=self.createMaskAll)
        buttonSave = Button(frame_bottom, text='Save', command=self.saveMask)

        self.drawmask = BooleanVar()
        buttonDrawMask = Checkbutton(frame_bottom,
                                     text='Draw Mask',
                                     variable=self.drawmask,
                                     command=self.drawSlice)

        num_col = 3
        num_row = 6
        for col in range(self.shape[2] / num_row):
            for k in range(num_row):
                ind = col * num_row + k
                if ind >= self.shape[2]:
                    break
                self.sliceView[ind].get_tk_widget().grid(row=k,
                                                         column=col * num_col,
                                                         sticky=NSEW)
                self.sliceSpin[ind].grid(row=k, column=col * num_col + 1)
            self.frame_main.grid_columnconfigure(col * num_col, weight=1)

        for k in range(num_row):
            self.frame_main.grid_rowconfigure(k, weight=1)

        self.spin_volume.grid(row=0, column=0)
        buttonMask.grid(row=0, column=1)
        buttonMaskCreate.grid(row=0, column=2)
        buttonSave.grid(row=0, column=3)
        buttonDrawMask.grid(row=0, column=5)

        frame_bottom.pack(side=BOTTOM)
        frame_main.pack(fill=BOTH, expand=TRUE)
        self.pack(fill=BOTH, expand=True)

    def change_volume(self):
        if not self.mask4d:
            return

        self.volume = int(self.spin_volume.get())
        self.data = self.data_base[:, :, :, self.volume]
        self.mask = self.mask_base[:, :, :, self.volume]
        self.drawSlice()

    def saveMask(self):
        print 'save mask to %s' % self.filename_mask
        if self.mask4d:
            img_out = nib.Nifti1Image(self.mask_base, self.img.get_affine(),
                                      self.img.get_header())
        else:
            img_out = nib.Nifti1Image(self.mask, self.img.get_affine(),
                                      self.img.get_header())
        nib.save(img_out, os.path.join(self.dirname, self.filename_mask))

        if self.obj_return_value is not None:
            self.obj_return_value.delete(0, len(self.obj_return_value.get()))
            self.obj_return_value.insert(0,
                                         os.path.basename(self.filename_mask))

    def readImage(self, filename):
        self.filename = filename
        self.img = nib.load(filename)
        self.shape = self.img.shape
        self.data_base = self.img.get_data()
        if len(self.data_base.shape) > 3:
            for f in range(self.data_base.shape[3]):
                for z in range(self.data_base.shape[2]):
                    self.data_base[:, :, z, f] = ndimage.gaussian_filter(
                        self.data_base[:, :, z, f], sigma=0.5)
            self.data = self.data_base[:, :, :, 0]
        else:
            for z in range(self.data_base.shape[2]):
                self.data_base[:, :, z] = ndimage.gaussian_filter(
                    self.data_base[:, :, z], sigma=0.5)
            self.data = self.data_base

    def createBaseImage(self):
        bvalFilename = tkFileDialog.askopenfilename()
        if bvalFilename:
            b0frames = parameter.get_b0_from_bval(bvalFilename)
            print self.filename, b0frames
            filename, filename_fltd, filename_mask = create_mask.set_filenames(
                self.filename)
            create_mask.make_base_image(filename, filename_fltd + '.nii.gz',
                                        b0frames)

            self.filename_mask = filename_mask + '.nii.gz'
            self.readImage(filename_fltd + '.nii.gz')
            self.drawSlice()

    def setSpinBoxConnect(self):
        for k in range(self.shape[2]):
            #self.sliceSpin[k].valueChanged.connect(lambda: self.createMaskSlice(k))
            #self.sliceSpin[k].configure(command=lambda:self.createMaskSlice(k, self.sliceSpin[k]))
            self.sliceSpin[k].configure(command=functools.partial(
                self.createMaskSlice, k, self.sliceSpin[k]))

    def drawSlice(self):
        for k in range(self.shape[2]):
            self.sliceView[k].drawData(self.data[:, :, k], self.mask[:, :, k],
                                       self.drawmask.get())

    def reset_box(self, box, text):
        box.delete(0, len(box.get()))
        box.insert(0, text)

    def createMaskSlice(self, k, value=None):
        self.mask[:, :, k] = 0
        if value is None:
            value_i = int(self.sliceSpin[k].get())
        else:
            value_i = int(value.get())
        #create_mask.mask_from_threshold(self.com_x[k], self.com_y[k], self.sliceSpin[k].value(), self.data, self.mask, k)
        create_mask.mask_from_threshold(self.com_x[k], self.com_y[k], value_i,
                                        self.data, self.mask, k)
        self.sliceView[k].drawData(self.data[:, :, k], self.mask[:, :, k],
                                   self.drawmask.get())

    def createMaskAll(self):
        self.drawmask.set(True)
        hdr = self.img.get_header()
        zooms = hdr.get_zooms()
        shape = self.shape

        self.com_x, self.com_y, roi_x, roi_y = create_mask.calculate_com(
            self.data, zooms)

        for k in range(shape[2]):
            dat_subflt = self.data[roi_x[k][0]:roi_x[k][1],
                                   roi_y[k][0]:roi_y[k][1], k].flatten()

            #threshold = np.mean(dat_subflt)
            threshold = np.mean(dat_subflt) + np.std(dat_subflt)
            self.reset_box(self.sliceSpin[k], int(threshold))
            self.createMaskSlice(k)
            #create_mask.mask_from_threshold(self.com_x[k], self.com_y[k], threshold, self.data, self.mask, k)

        #self.drawSlice()
        self.setSpinBoxConnect()
class Cap(Frame):
	def __init__(self):
		' set defaults, create widgets, bind callbacks, start live view '
		self.root = Tk()
		# menu:
		self.menu = Menu(self.root)
		self.root.config(menu=self.menu)
		# bind global keypresses:
		self.root.bind('q', lambda e: self.root.quit())
		self.root.bind('x', lambda e: self.root.quit())
		self.root.bind('<Destroy>', self.do_stop_video)
		self.root.bind('<space>', self.do_single_shot)
		self.root.bind('<Return>', self.do_single_shot)
		self.root.bind('<Button-3>', self.do_single_shot)
		self.root.bind('<Left>', lambda e: self.degree.set(-90))
		self.root.bind('<Right>', lambda e: self.degree.set(90))
		self.root.bind('<Up>', lambda e: self.degree.set(0))
		self.root.bind('a', lambda e: self.autocontrast.set(not self.autocontrast.get()))
		self.root.bind('e', lambda e: self.equalize.set(not self.equalize.get()))
		self.root.bind('g', lambda e: self.grayscale.set(not self.grayscale.get()))
		self.root.bind('i', lambda e: self.invert.set(not self.invert.get()))
		self.root.bind('s', lambda e: self.solarize.set(not self.solarize.get()))
		# config:
		self.config = RawConfigParser()
		self.config.read('filmroller.conf')
		if not self.config.has_section('global'):
			self.config.add_section('global')
		self.video = None
		self.invert = BooleanVar(name='invert')
		self.invert.set(self.config_get('invert', True))
		self.invert.trace('w', self.do_configure)
		self.grayscale = BooleanVar(name='grayscale')
		self.grayscale.set(self.config_get('grayscale', False))
		self.grayscale.trace('w', self.do_configure)
		self.autocontrast = BooleanVar(name='autocontrast')
		self.autocontrast.set(self.config_get('autocontrast', True))
		self.autocontrast.trace('w', self.do_configure)
		self.equalize = BooleanVar(name='equalize')
		self.equalize.set(self.config_get('equalize', False))
		self.equalize.trace('w', self.do_configure)
		self.solarize = BooleanVar(name='solarize')
		self.solarize.set(self.config_get('solarize', False))
		self.solarize.trace('w', self.do_configure)
		self.degree = IntVar(name='degree')
		self.degree.set(0)
		self.filename = StringVar(name='filename')
		self.videodevice = StringVar(name='videodevice')
		dev_names = sorted(['/dev/{}'.format(x) for x in listdir('/dev') if x.startswith('video')])
		d = self.config_get('videodevice', dev_names[-1])
		if not d in dev_names:
			d = dev_names[-1]
		self.videodevice.set(d)
		self.videodevice.trace('w', self.do_configure)
		#
		self.path = 'filmroller'
		if not exists(self.path):
			makedirs(self.path)
		# create gui:
		Frame.__init__(self, self.root)
		self.grid()
		self.x_canvas = Canvas(self, width=640, height=640, )
		self.x_canvas.pack(side='top')
		self.x_canvas.bind('<Button-1>', self.do_change_rotation)
		Checkbutton(self, text='Invert', variable=self.invert).pack(side='left')
		Checkbutton(self, text='Gray', variable=self.grayscale).pack(side='left')
		Checkbutton(self, text='Auto', variable=self.autocontrast).pack(side='left')
		OptionMenu(self, self.videodevice, *dev_names, command=self.restart_video).pack(side='left')
		Button(self, text='First role', command=self.do_first_role).pack(side='left')
		Label(self, textvariable=self.filename).pack(side='left')
		Button(self, text='Next role', command=self.do_inc_role).pack(side='left')
		Button(self, text='Take!', command=self.do_single_shot).pack(side='right')
		#filemenu = Menu(self.menu)
		#self.menu.add_cascade(label=self.videodevice.get(), menu=filemenu, )
		#for n in dev_names:
		#	filemenu.add_command(label=n, )
		#filemenu.add_separator()
		# start operation:
		self.do_first_role()
		self.do_start_video()

	def do_change_rotation(self, event):
		' determine where the image was clicked and turn that to the top '
		if event.x < 200:
			self.degree.set(-90)
		elif event.x > 640 - 200:
			self.degree.set(90)
		else:
			self.degree.set(0)

	def config_get(self, name, default):
		' read a configuration entry, fallback to default if not already stored '
		if not self.config.has_option('global', name):
			return default
		if isinstance(default, bool):
			return self.config.getboolean('global', name)
		else:
			return self.config.get('global', name)

	def do_configure(self, name, mode, cbname):
		' change a configuration entry '
		if cbname == 'w':
			value = getattr(self, name).get()
			self.config.set('global', name, str(value))
			self.config.write(open('filmroller.conf', 'w'))

	def do_first_role(self, *args):
		' jump back to first role '
		self.role = 'aa'
		self.serial = 0
		self.inc_picture()

	def inc_picture(self):
		' increment the picture number, jump over existing files '
		self.filename.set('{}/scanned.{}-{:04}.jpg'.format(self.path, self.role, self.serial, ))
		while exists(self.filename.get()):
			self.serial += 1
			self.filename.set('{}/scanned.{}-{:04}.jpg'.format(self.path, self.role, self.serial, ))
		self.root.title('filmroller - ' + self.filename.get())

	def do_inc_role(self, *args):
		' increment to next role '
		self.serial = 0
		self.role = ascii_increment(self.role)
		self.inc_picture()

	def set_pauseimage(self):
		' show pause image (during shot) '
		self.image = fromfile('filmroller.pause.png')
		self.image.thumbnail((self.previewsize['size_x'], self.previewsize['size_y'], ), )
		self.photo = PhotoImage(self.image)
		self.x_canvas.create_image(640/2, 640/2, image=self.photo)

	def do_stop_video(self, *args):
		' stop video and release device '
		if self.video is not None:
			self.video.stop()
			self.video.close()
			self.video = None

	def restart_video(self, *args):
		' restart video (if device changes or hangs) '
		self.do_stop_video()
		self.root.after(1, self.do_start_video)

	def do_start_video(self, *args):
		' init video and start live view '
		if self.video is None:
			self.video = Video_device(self.videodevice.get())
			_, _, self.fourcc = self.video.get_format()
			caps = sorted(self.video.get_framesizes(self.fourcc), cmp=lambda a, b: cmp(a['size_x']*a['size_y'], b['size_x']*b['size_y']))
			self.previewsize, self.highressize = caps[0], caps[-1]
			self.previewsize['size_x'], self.previewsize['size_y'] = self.video.set_format(
				self.previewsize['size_x'], self.previewsize['size_y'], 0, 'MJPEG')
			try: self.video.set_auto_white_balance(True)
			except: pass
			try: self.video.set_exposure_auto(True)
			except: pass
			try: self.video.set_focus_auto(True)
			except: pass
			self.video.create_buffers(30)
			self.video.queue_all_buffers()
			self.video.start()
			self.root.after(1, self.do_live_view)
			#self.x_canvas.config(width=640, height=480)
			#self.x_canvas.pack(side='top')
			self.degree.set(0)

	def do_live_view(self, *args):
		' show single pic live view and ask tk to call us again later '
		if self.video is not None:
			select((self.video, ), (), ())
			data = self.video.read_and_queue()
			self.image = frombytes('RGB', (self.previewsize['size_x'], self.previewsize['size_y']), data)
			if self.invert.get():
				self.image = invert(self.image)
			if self.grayscale.get():
				self.image = grayscale(self.image)
			if self.autocontrast.get():
				self.image = autocontrast(self.image)
			if self.equalize.get():
				self.image = equalize(self.image)
			if self.solarize.get():
				self.image = solarize(self.image)
			if self.degree.get():
				self.image = self.image.rotate(self.degree.get())
			self.photo = PhotoImage(self.image)
			self.x_canvas.create_image(640/2, 640/2, image=self.photo)
			self.root.after(3, self.do_live_view)

	def do_single_shot(self, *args):
		' do a high res single shot and store it '
		def _go():
			self.video = Video_device(self.videodevice.get())
			try:
				self.highressize['size_x'], self.highressize['size_y'] = self.video.set_format(
					self.highressize['size_x'], self.highressize['size_y'], 0, 'MJPEG')
				try: self.video.set_auto_white_balance(True)
				except: pass
				try: self.video.set_exposure_auto(True)
				except: pass
				try: self.video.set_focus_auto(True)
				except: pass
				self.video.create_buffers(7)
				self.video.queue_all_buffers()
				self.video.start()
				stop_time = time() + 3.0
				# wait for auto
				while stop_time >= time():
					select((self.video, ), (), ())
					self.update_idletasks()
					data = self.video.read_and_queue()
				image = frombytes('RGB', (self.highressize['size_x'], self.highressize['size_y'], ), data)
				if self.invert.get():
					image = invert(image)
				if self.grayscale.get():
					image = grayscale(image)
				if self.autocontrast.get():
					image = autocontrast(image)
				if self.equalize.get():
					self.image = equalize(self.image)
				if self.solarize.get():
					self.image = solarize(self.image)
				if self.degree.get():
					image = image.rotate(self.degree.get())
				image.save(self.filename.get())
				self.inc_picture()
				self.root.bell()
				self.video.stop()
			finally:
				self.video.close()
				self.video = None
			self.root.after(1, self.do_start_video)
		self.do_stop_video()
		self.set_pauseimage()
		self.update_idletasks()
		self.root.after(1, _go)
Пример #33
0
class MyQuestion(object):
    def __init__(self, parent, question_text, ans1_text, ans2_text, ans3_text,
                 ans4_text, exp1_text, exp2_text, exp3_text, exp4_text,
                 correct_ans):
        # assigning parameters to attributes
        self.parent = parent
        self.qtext = str(question_text)
        self.text1 = str(ans1_text)
        self.text2 = str(ans2_text)
        self.text3 = str(ans3_text)
        self.text4 = str(ans4_text)
        self.exp1 = str(exp1_text)
        self.exp2 = str(exp2_text)
        self.exp3 = str(exp3_text)
        self.exp4 = str(exp4_text)
        self.ans = int(correct_ans)

        # creating Tkinter variables
        self.ans_input = IntVar()
        self.is_correct = BooleanVar()
        self.efbg = StringVar()
        self.is_correct_text = StringVar()
        self.exp_text = StringVar()

        # developer mode
        if dev:
            self.ans_input.set(self.ans)

        # questionwide bgcolor, fgcolor
        self.bgcolor = GrayScale(80)
        self.fgcolor = GrayScale(20)

        # creating parent frame
        self.parent_frame()
        self.question_frame()

    def parent_frame(self):
        # creating parent frame
        self.pf = Frame(self.parent)
        self.pf.configure(bg=self.bgcolor)
        self.pf.place(relx=0, rely=0, relwidth=1, relheight=1)

    def question_frame(self):
        # creating question frame within parent frame
        self.qf = Frame(self.pf)
        self.qf.configure(bg=self.bgcolor)
        self.qf.place(relx=0, rely=0, relwidth=1, relheight=1)

        # creating objects within question frame
        self.title_label()
        self.radiobutton1()
        self.radiobutton2()
        self.radiobutton3()
        self.radiobutton4()
        self.check_ans_button()

    def explanation_frame(self):
        # creating explanation frame within parent frame
        self.ef = Frame(self.pf)
        self.ef.configure(bg=self.efbg.get())
        self.ef.place(relx=0, rely=0, relwidth=1, relheight=1)

        # creating objects within explanation frame
        self.is_correct_label()
        self.exp_label()
        self.next_ques_button()

        # creating display answer button if answer is wrong
        if not self.is_correct.get():
            self.disp_ans_button()

    def title_label(self):
        # creating title label for question frame
        self.tl = Label(self.qf)
        self.tl.configure(text=self.qtext)
        self.tl.configure(font=MyFonts['ExtraLarge'])
        self.tl.configure(bg=self.bgcolor, fg=self.fgcolor)
        self.tl.configure(relief=FLAT)
        self.tl.configure(padx=2, pady=2, anchor=N)
        self.tl.place(relx=0.05, rely=0.05, relwidth=0.90, relheight=0.10)

    def radiobutton1(self):
        # creating radiobuttion1 for question frame
        self.q1 = Radiobutton(self.qf)
        self.q1.configure(text='A. ' + self.text1)
        self.q1.configure(font=MyFonts['Large'])
        self.q1.configure(bg=self.bgcolor, activebackground=self.bgcolor)
        self.q1.configure(variable=self.ans_input, value=1)
        self.q1.place(relx=0.10, rely=0.20)

    def radiobutton2(self):
        # creating radiobutton2 for question frame
        self.q2 = Radiobutton(self.qf)
        self.q2.configure(text='B. ' + self.text2)
        self.q2.configure(font=MyFonts['Large'])
        self.q2.configure(bg=self.bgcolor, activebackground=self.bgcolor)
        self.q2.configure(variable=self.ans_input, value=2)
        self.q2.place(relx=0.10, rely=0.35)

    def radiobutton3(self):
        # creating radiobutton3 for question frame
        self.q3 = Radiobutton(self.qf)
        self.q3.configure(text='C. ' + self.text3)
        self.q3.configure(font=MyFonts['Large'])
        self.q3.configure(bg=self.bgcolor, activebackground=self.bgcolor)
        self.q3.configure(variable=self.ans_input, value=3)
        self.q3.place(relx=0.10, rely=0.50)

    def radiobutton4(self):
        # creating radiobutton4 for question frame
        self.q4 = Radiobutton(self.qf)
        self.q4.configure(text='D. ' + self.text4)
        self.q4.configure(font=MyFonts['Large'])
        self.q4.configure(bg=self.bgcolor, activebackground=self.bgcolor)
        self.q4.configure(variable=self.ans_input, value=4)
        self.q4.place(relx=0.10, rely=0.65)

    def check_ans_button(self):
        # creating check answer button for question frame
        self.cb = MyButton(self.qf, 'Check Answer', self.check_ans, 0.80, 0.85)

    def is_correct_label(self):
        # creating is_correct_label for explanation frame
        self.cl = Label(self.ef)
        self.cl.configure(text=self.is_correct_text.get())
        self.cl.configure(font=MyFonts['ExtraLargeBold'])
        self.cl.configure(bg=self.efbg.get(), fg=GrayScale(20))
        self.cl.configure(relief=FLAT)
        self.cl.configure(padx=2, pady=2, anchor=N)
        self.cl.place(relx=0.05, rely=0.05, relwidth=0.90, relheight=0.05)

    def exp_label(self):
        # creating exp_label for explanation frame
        self.el = Label(self.ef)
        self.el.configure(text=self.exp_text.get())
        self.el.configure(font=MyFonts['LargeBold'])
        self.el.configure(bg=self.efbg.get(), fg=GrayScale(20))
        self.el.configure(relief=FLAT)
        self.el.configure(padx=2, pady=2, anchor=N)
        self.el.place(relx=0.05, rely=0.10, relwidth=0.90, relheight=0.85)

    def next_ques_button(self):
        # creating next question button for explanation frame
        self.nq = MyButton(self.ef, 'Next Question', self.next_ques, 0.80,
                           0.85)

    def disp_ans_button(self):
        # creating display answer button for explanation frame
        self.da = MyButton(self.ef, 'Show Answer', self.disp_ans, 0.65, 0.85)

    def assign_all(self):
        # assigning correct answer text (ans_text) and explanation attributes (ans_exp)
        if self.ans == 1:
            self.ans_text = 'A. ' + self.text1
            self.ans_exp = self.exp1
        elif self.ans == 2:
            self.ans_text = 'B. ' + self.text2
            self.ans_exp = self.exp2
        elif self.ans == 3:
            self.ans_text = 'C. ' + self.text3
            self.ans_exp = self.exp3
        elif self.ans == 4:
            self.ans_text = 'D. ' + self.text4
            self.ans_exp = self.exp4
        else:
            self.ans_text = 'invalid correct_ans parameter'
            self.ans_exp = 'invalid correct_ans parameter'
            print 'invalid correct_ans parameter, please input between 1 and 4'

    def check_ans(self):
        # defining check answer function

        # is_correct (Boolean conditional)
        if self.ans_input.get() == self.ans:
            self.efbg.set(color_green)
            self.is_correct.set(True)
            self.is_correct_text.set('Correct Answer! :)')

        else:
            self.efbg.set(color_red)
            self.is_correct.set(False)
            self.is_correct_text.set('Wrong Answer :(')

            # only assign values for show answer if user answer is wrong
            self.assign_all()

        # appropriate response to selected answer
        if self.ans_input.get() == 1:
            self.exp_text.set(self.exp1)
            self.explanation_frame()
            self.qf.destroy()

        elif self.ans_input.get() == 2:
            self.exp_text.set(self.exp2)
            self.explanation_frame()
            self.qf.destroy()

        elif self.ans_input.get() == 3:
            self.exp_text.set(self.exp3)
            self.explanation_frame()
            self.qf.destroy()

        elif self.ans_input.get() == 4:
            self.exp_text.set(self.exp4)
            self.explanation_frame()
            self.qf.destroy()

        else:
            # no selected answer condition
            showerror('Error', 'Please select an answer to continue')

    def disp_ans(self):
        # defining display answer function
        tmp_str = self.ans_exp[0].lower() + self.ans_exp[1:]
        disp_ans_text = 'The correct answer is "' + str(
            self.ans_text) + '" because ' + str(tmp_str)
        showinfo('Correct Answer', disp_ans_text)

    def next_ques(self):
        # defininf next_question function
        self.pf.destroy()
        self.ef.destroy()
Пример #34
0
class FindReplacePanel(PluginPanel):
	name='Text Find & Replace'
	title = _("Text Find & Replace")
	
	def init(self, master):
		PluginPanel.init(self, master)
		top = self.panel

		top = TFrame(top, borderwidth=2, style='FlatFrame')
		top.pack(side = TOP, expand = 1, fill = X)

		button_frame = TFrame(top, borderwidth=2, style='FlatFrame')
		button_frame.pack(side = BOTTOM, fill = BOTH, expand = 1)
		
		button=TButton(button_frame,text=_('Apply'), command=self.replace)
		button.pack(side = TOP)
		
		#----------------------------------------------------------
		main_frame = TFrame(top, style='FlatFrame', borderwidth=3)
		main_frame.pack(side = TOP, fill=X)

		self.find_var = StringVar(top);
		self.find_var.set('')
		findField = TEntryExt(main_frame, textvariable=self.find_var)
		findField.pack(side = RIGHT)
			   
		label = TLabel(main_frame, style='FlatLabel', text = _("Find:")+" ")
		label.pack(side = RIGHT, anchor = E)
		#---------------------------------------------------------
		main_frame = TFrame(top, style='FlatFrame', borderwidth=3)
		main_frame.pack(side = TOP, fill=X)


		self.replace_var = StringVar(top);
		self.replace_var.set('')
		replaceField = TEntryExt(main_frame, textvariable=self.replace_var)
		replaceField.pack(side = RIGHT)
		
		label = TLabel(main_frame, style='FlatLabel', text = _("Replace to:")+" ")
		label.pack(side = RIGHT, anchor = E)
		
		main_frame = TFrame(top, style='FlatFrame', borderwidth=3)
		main_frame.pack(side = TOP)
		#---------------------------------------------------------
		label=TLabel(top, text=" "+_("Parameters")+" ", style="FlatLabel")
		label.pack()
		
		parametersFrameLabel=TLabelframe(top, labelwidget=label, style='Labelframe', borderwidth=4)

		parametersFrameLabel.pack(side = TOP, fill=X, pady=4, padx=4)
		
		parametersFrame = TFrame(parametersFrameLabel, style='FlatFrame')  
		
		self.var_case_sensitive = BooleanVar(top)
		self.var_case_sensitive.set(False)
		self.case_sensitive_check = TCheckbutton(parametersFrame, text = _("Case sensitive"), variable = self.var_case_sensitive)
		self.case_sensitive_check.pack(side = TOP, anchor=W, padx=5)
	   
		self.var_whole_word = BooleanVar(top)
		self.var_whole_word.set(False)
		self.whole_word_check = TCheckbutton(parametersFrame, text = _("Whole word"), variable = self.var_whole_word)
		self.whole_word_check.pack(side = TOP, anchor=W, padx=5)
		
		self.var_regexp = BooleanVar(top)
		self.var_regexp.set(False)
		self.regexpCheck = TCheckbutton(parametersFrame, text = _("RegExp search"), variable = self.var_regexp, command=self.disable_enable_action)
		self.regexpCheck.pack(side = TOP, anchor=W, padx=5)
		
		parametersFrame.pack(side=TOP, fill=X, pady=2)
################################################################
	def replace_text(self,objects, toReplace, replaceTo):		
		for object in objects:
			if object.is_Text:
				
				if self.var_regexp.get():
					if self.var_case_sensitive.get():
						p=re.compile(toReplace)
					else:
						p=re.compile(toReplace, re.I)
					text=p.sub(replaceTo, object.text)
					app.mw.document.SelectObject(object)
					app.mw.document.CallObjectMethod(object.__class__,_('Text Replace'),'SetText',text)
					continue
				
				if self.var_whole_word.get():
					if not self.var_case_sensitive.get():
						if object.text.lower()==toReplace.lower():
							text=replaceTo
							app.mw.document.SelectObject(object)
							app.mw.document.CallObjectMethod(object.__class__,_('Text Replace'),'SetText',text)
					else:
						if object.text==toReplace:
							text=replaceTo
							app.mw.document.SelectObject(object)
							app.mw.document.CallObjectMethod(object.__class__,_('Text Replace'),'SetText',text)
							
				else:
					if object.text.lower().find(toReplace.lower(), 0, len(object.text)) != -1:
						if not self.var_case_sensitive.get():
							text=object.text.lower().replace(toReplace.lower(), replaceTo)
						else:
							text=object.text.replace(toReplace, replaceTo)
						app.mw.document.SelectObject(object)
						app.mw.document.CallObjectMethod(object.__class__,_('Text Replace'),'SetText',text)

			if object.is_Group:
				self.replace_text(object.objects)
################################################################
	def replace(self):
		textObjects=[]
		textToReplace=self.find_var.get().decode('utf-8')
		replaceTo=self.replace_var.get().decode('utf-8')

		for layer in app.mw.document.layers:
			self.replace_text(layer.objects, textToReplace, replaceTo)
		app.mw.canvas.ForceRedraw()
################################################################
	def disable_enable_action(self):
		if self.var_regexp.get():	
			self.whole_word_check['state'] = DISABLED
		else:
			self.whole_word_check['state'] = NORMAL
################################################################
	def whole_word_action(self):
		pass
Пример #35
0
 def test_get(self):
     v = BooleanVar(self.root, True, 'name')
     self.assertAlmostEqual(True, v.get())
     self.root.globalsetvar('name', '0')
     self.assertAlmostEqual(False, v.get())
Пример #36
0
class GrepDialog(SearchDialogBase):

    title = "Find in Files Dialog"
    icon = "Grep"
    needwrapbutton = 0

    def __init__(self, root, engine, flist):
        SearchDialogBase.__init__(self, root, engine)
        self.flist = flist
        self.globvar = StringVar(root)
        self.recvar = BooleanVar(root)

    def open(self, text, searchphrase, io=None):
        SearchDialogBase.open(self, text, searchphrase)
        if io:
            path = io.filename or ""
        else:
            path = ""
        dir, base = os.path.split(path)
        head, tail = os.path.splitext(base)
        if not tail:
            tail = ".py"
        self.globvar.set(os.path.join(dir, "*" + tail))

    def create_entries(self):
        SearchDialogBase.create_entries(self)
        self.globent = self.make_entry("In files:", self.globvar)[0]

    def create_other_buttons(self):
        f = self.make_frame()[0]

        btn = Checkbutton(f, anchor="w",
                variable=self.recvar,
                text="Recurse down subdirectories")
        btn.pack(side="top", fill="both")
        btn.select()

    def create_command_buttons(self):
        SearchDialogBase.create_command_buttons(self)
        self.make_button("Search Files", self.default_command, 1)

    def default_command(self, event=None):
        prog = self.engine.getprog()
        if not prog:
            return
        path = self.globvar.get()
        if not path:
            self.top.bell()
            return
        from idlelib.OutputWindow import OutputWindow  # leave here!
        save = sys.stdout
        try:
            sys.stdout = OutputWindow(self.flist)
            self.grep_it(prog, path)
        finally:
            sys.stdout = save

    def grep_it(self, prog, path):
        dir, base = os.path.split(path)
        list = self.findfiles(dir, base, self.recvar.get())
        list.sort()
        self.close()
        pat = self.engine.getpat()
        print("Searching %r in %s ..." % (pat, path))
        hits = 0
        try:
            for fn in list:
                try:
                    with open(fn) as f:
                        for lineno, line in enumerate(f, 1):
                            if line[-1:] == '\n':
                                line = line[:-1]
                            if prog.search(line):
                                sys.stdout.write("%s: %s: %s\n" %
                                                 (fn, lineno, line))
                                hits += 1
                except IOError as msg:
                    print(msg)
            print(("Hits found: %s\n"
                  "(Hint: right-click to open locations.)"
                  % hits) if hits else "No hits.")
        except AttributeError:
            # Tk window has been closed, OutputWindow.text = None,
            # so in OW.write, OW.text.insert fails.
            pass

    def findfiles(self, dir, base, rec):
        try:
            names = os.listdir(dir or os.curdir)
        except os.error as msg:
            print(msg)
            return []
        list = []
        subdirs = []
        for name in names:
            fn = os.path.join(dir, name)
            if os.path.isdir(fn):
                subdirs.append(fn)
            else:
                if fnmatch.fnmatch(name, base):
                    list.append(fn)
        if rec:
            for subdir in subdirs:
                list.extend(self.findfiles(subdir, base, rec))
        return list

    def close(self, event=None):
        if self.top:
            self.top.grab_release()
            self.top.withdraw()
Пример #37
0
 def test_get(self):
     v = BooleanVar(self.root, True, "name")
     self.assertAlmostEqual(True, v.get())
     self.root.globalsetvar("name", "0")
     self.assertAlmostEqual(False, v.get())
Пример #38
0
        class A_DWI:
            def __init__(self, container, frame, label='', text='', row=0, column=0):
                self.container = container
                self.is_b0 = BooleanVar(container.parent)
                self.is_dw = BooleanVar(container.parent)
                self.column = column
                self.direction = StringVar(container.parent)

                self.label_from = Label(frame, text='from')
                self.text_from = Entry(frame)
                self.text_from.insert(0, text)
                self.button_file_from = Button(frame, text='...', command=lambda:filenameDialog_text(self.text_from))
                self.button_rm = Button(frame, text='remove', command=self.click_remove)
                self.radio_ap = Radiobutton(frame, text='AP', variable=self.direction, value='AP', command=self.set_direction)
                self.radio_pa = Radiobutton(frame, text='PA', variable=self.direction, value='PA', command=self.set_direction)

                self.label_to = Label(frame, text='to')
                self.text_to = Entry(frame)
                #self.text_to.insert(0, text)
                self.button_file_to = Button(frame, text='Gen', command=self.set_filename_to)
                self.check_b0 = Checkbutton(frame, text='B0',   variable=self.is_b0)
                self.check_dw = Checkbutton(frame, text='DWI',  variable=self.is_dw)

                self.button_up = Button(frame, text='up', width=3, command=self.click_up)
                self.button_dn = Button(frame, text='down', width=3, command=self.click_dn)

                self.row = -1
                self.change_row(row)
                if text != '':
                    self.set_appa()
                    self.set_filename_to()

            def prefix(self):
                return self.container.parent.prefix()

            def set_direction(self):
                pass

            def get_dwi_filenames(self):
                '''
                :return: [('from', 'to'), ('from', 'to')]
                '''
                filename_from = self.text_from.get()
                filename_to = self.text_to.get()
                if self.is_dw.get():
                    rtn = [ [filename_from, filename_to] ]
                    filename_b_from = filename_wo_ext(filename_from)
                    filename_b_to = filename_wo_ext(filename_to)
                    rtn.append( [filename_b_from+'.bval', filename_b_to+'.bval'] )
                    rtn.append( [filename_b_from+'.bvec', filename_b_to+'.bvec'] )
                    return rtn
                return []

            def get_b0_filename(self):
                '''
                :return: [('from', 'to')]
                '''
                filename_from = self.text_from.get()
                filename_to = self.text_to.get()
                ext = extname(filename_to)
                if self.is_b0.get():
                    if self.is_dw.get():
                        filename_to = '%s_B0%s' % (filename_wo_ext(filename_to), ext)
                    return [ [filename_from, filename_to] ]
                return []

            def set_appa(self):
                filename_from = self.text_from.get()
                basename_from = os.path.basename(filename_from)
                basename_b_from = filename_wo_ext(basename_from)
                if 'pa' in basename_b_from.lower():
                    self.direction.set('PA')
                elif 'ap' in basename_b_from.lower():
                    self.direction.set('AP')
                else:
                    pass

            def set_filename_to(self, middle=None):
                filename_from = self.text_from.get()
                basename_from = os.path.basename(filename_from)
                number = os.path.dirname(filename_from).split('/')[-1].split('_')[0]
                if number == '':
                    number = str(self.row)
                else:
                    try:
                        int(number)
                    except:
                        number = str(self.row)


                ext = extname(basename_from)
                intermediate = self.direction.get()
                if intermediate == '':
                    intermediate = 'DWI'

                if self.is_b0.get() and not self.is_dw.get():
                    intermediate += '_B0'

                self.text_to.delete(0, len(self.text_to.get()))
                self.text_to.insert(0, '%s%s_%s%s' % (self.prefix(), number, intermediate, ext))

            def change_row(self, row):
                if self.row == row:
                    return
                self.row = row
                i = 2*row
                j = self.column
                j += 0; self.button_up.grid(row=i, column=j)
                j += 1; self.label_from.grid(row=i, column=j)
                j += 1; self.text_from.grid(row=i, column=j, sticky=EW)
                j += 1; self.button_file_from.grid(row=i, column=j)
                j += 1; self.button_rm.grid(row=i, column=j)
                j += 1; self.radio_ap.grid(row=i, column=j)
                j += 1; self.radio_pa.grid(row=i, column=j)
                i += 1
                j = 0
                j += 0; self.button_dn.grid(row=i, column=j)
                j += 1; self.label_to.grid(row=i, column=j)
                j += 1; self.text_to.grid(row=i, column=j, sticky=EW)
                j += 1; self.button_file_to.grid(row=i, column=j)
                j += 1
                j += 1; self.check_b0.grid(row=i, column=j)
                j += 1; self.check_dw.grid(row=i, column=j)

            def click_remove(self):
                self.container.remove(self.row)

                self.button_up.destroy()
                self.label_from.destroy()
                self.text_from.destroy()
                self.button_file_from.destroy()
                self.button_rm.destroy()
                self.radio_ap.destroy()
                self.radio_pa.destroy()
                self.button_dn.destroy()
                self.label_to.destroy()
                self.text_to.destroy()
                self.button_file_to.destroy()
                self.check_b0.destroy()
                self.check_dw.destroy()

            def click_up(self):
                self.container.up(self.row)
            def click_dn(self):
                self.container.dn(self.row)
Пример #39
0
class SearchEngine:
    def __init__(self, root):
        self.root = root
        self.patvar = StringVar(root, '')
        self.revar = BooleanVar(root, False)
        self.casevar = BooleanVar(root, False)
        self.wordvar = BooleanVar(root, False)
        self.wrapvar = BooleanVar(root, True)
        self.backvar = BooleanVar(root, False)

    def getpat(self):
        return self.patvar.get()

    def setpat(self, pat):
        self.patvar.set(pat)

    def isre(self):
        return self.revar.get()

    def iscase(self):
        return self.casevar.get()

    def isword(self):
        return self.wordvar.get()

    def iswrap(self):
        return self.wrapvar.get()

    def isback(self):
        return self.backvar.get()

    def setcookedpat(self, pat):
        if self.isre():
            pat = re.escape(pat)
        self.setpat(pat)

    def getcookedpat(self):
        pat = self.getpat()
        if not self.isre():
            pat = re.escape(pat)
        if self.isword():
            pat = '\\b%s\\b' % pat
        return pat

    def getprog(self):
        pat = self.getpat()
        if not pat:
            self.report_error(pat, 'Empty regular expression')
            return None
        else:
            pat = self.getcookedpat()
            flags = 0
            if not self.iscase():
                flags = flags | re.IGNORECASE
            try:
                prog = re.compile(pat, flags)
            except re.error as what:
                args = what.args
                msg = args[0]
                col = arg[1] if len(args) >= 2 else -1
                self.report_error(pat, msg, col)
                return None

            return prog

    def report_error(self, pat, msg, col=-1):
        msg = 'Error: ' + str(msg)
        if pat:
            msg = msg + '\nPattern: ' + str(pat)
        if col >= 0:
            msg = msg + '\nOffset: ' + str(col)
        tkMessageBox.showerror('Regular expression error',
                               msg,
                               master=self.root)

    def search_text(self, text, prog=None, ok=0):
        if not prog:
            prog = self.getprog()
            if not prog:
                return None
        wrap = self.wrapvar.get()
        first, last = get_selection(text)
        if self.isback():
            if ok:
                start = last
            else:
                start = first
            line, col = get_line_col(start)
            res = self.search_backward(text, prog, line, col, wrap, ok)
        else:
            if ok:
                start = first
            else:
                start = last
            line, col = get_line_col(start)
            res = self.search_forward(text, prog, line, col, wrap, ok)
        return res

    def search_forward(self, text, prog, line, col, wrap, ok=0):
        wrapped = 0
        startline = line
        chars = text.get('%d.0' % line, '%d.0' % (line + 1))
        while chars:
            m = prog.search(chars[:-1], col)
            if m and (ok or m.end() > col):
                return (line, m)
            line = line + 1
            if wrapped and line > startline:
                break
            col = 0
            ok = 1
            chars = text.get('%d.0' % line, '%d.0' % (line + 1))
            if not chars and wrap:
                wrapped = 1
                wrap = 0
                line = 1
                chars = text.get('1.0', '2.0')

        return None

    def search_backward(self, text, prog, line, col, wrap, ok=0):
        wrapped = 0
        startline = line
        chars = text.get('%d.0' % line, '%d.0' % (line + 1))
        while 1:
            m = search_reverse(prog, chars[:-1], col)
            if m and (ok or m.start() < col):
                return (line, m)
            line = line - 1
            if wrapped and line < startline:
                break
            ok = 1
            if line <= 0:
                if not wrap:
                    break
                wrapped = 1
                wrap = 0
                pos = text.index('end-1c')
                line, col = map(int, pos.split('.'))
            chars = text.get('%d.0' % line, '%d.0' % (line + 1))
            col = len(chars) - 1

        return None
Пример #40
0
 def test_default(self):
     v = BooleanVar(self.root)
     self.assertIs(v.get(), False)
Пример #41
0
class wm_seg:
    """
    Simple GUI application
    If the application inside a container, automatic updates are removed.

    The application uses two frames (tabs):
    - training
    - testing
    """
    def __init__(self, master, container):

        self.master = master
        master.title("nicMSlesions")

        # running on a container
        self.container = container

        # gui attributes
        self.path = os.getcwd()
        self.default_config = None
        self.user_config = None
        self.current_folder = os.getcwd()
        self.list_train_pretrained_nets = []
        self.list_test_nets = []
        self.version = __version__
        if self.container is False:
            # version_number
            self.commit_version = subprocess.check_output(
                ['git', 'rev-parse', 'HEAD'])

        # queue and thread parameters. All processes are embedded
        # inside threads to avoid freezing the application
        self.train_task = None
        self.test_task = None
        self.test_queue = Queue.Queue()
        self.train_queue = Queue.Queue()

        # --------------------------------------------------
        # parameters. Mostly from the config/*.cfg files
        # --------------------------------------------------

        # data parameters
        self.param_training_folder = StringVar()
        self.param_test_folder = StringVar()
        self.param_FLAIR_tag = StringVar()
        self.param_T1_tag = StringVar()
        self.param_MOD3_tag = StringVar()
        self.param_MOD4_tag = StringVar()
        self.param_mask_tag = StringVar()
        self.param_model_tag = StringVar()
        self.param_register_modalities = BooleanVar()
        self.param_skull_stripping = BooleanVar()
        self.param_denoise = BooleanVar()
        self.param_denoise_iter = IntVar()
        self.param_save_tmp = BooleanVar()
        self.param_debug = BooleanVar()

        # train parameters
        self.param_net_folder = os.path.join(self.current_folder, 'nets')
        self.param_use_pretrained_model = BooleanVar()
        self.param_pretrained_model = StringVar()
        self.param_inference_model = StringVar()
        self.param_num_layers = IntVar()
        self.param_net_name = StringVar()
        self.param_net_name.set('None')
        self.param_balanced_dataset = StringVar()
        self.param_fract_negatives = DoubleVar()

        # model parameters
        self.param_pretrained = None
        self.param_min_th = DoubleVar()
        self.param_patch_size = IntVar()
        self.param_weight_paths = StringVar()
        self.param_load_weights = BooleanVar()
        self.param_train_split = DoubleVar()
        self.param_max_epochs = IntVar()
        self.param_patience = IntVar()
        self.param_batch_size = IntVar()
        self.param_net_verbose = IntVar()
        self.param_t_bin = DoubleVar()
        self.param_l_min = IntVar()
        self.param_min_error = DoubleVar()
        self.param_mode = BooleanVar()
        self.param_gpu_number = IntVar()

        # load the default configuration from the conf file
        self.load_default_configuration()

        # self frame (tabbed notebook)
        self.note = Notebook(self.master)
        self.note.pack()

        os.system('cls' if platform.system() == 'Windows' else 'clear')
        print "##################################################"
        print "# ------------                                   #"
        print "# nicMSlesions                                   #"
        print "# ------------                                   #"
        print "# MS WM lesion segmentation                      #"
        print "#                                                #"
        print "# -------------------------------                #"
        print "# (c) Sergi Valverde 2018                        #"
        print "# Neuroimage Computing Group                     #"
        print "# -------------------------------                #"
        print "##################################################\n"
        print "Please select options for training or inference in the menu..."

        # --------------------------------------------------
        # training tab
        # --------------------------------------------------
        self.train_frame = Frame()
        self.note.add(self.train_frame, text="Training")
        self.test_frame = Frame()
        self.note.add(self.test_frame, text="Inference")

        # label frames
        cl_s = 5
        self.tr_frame = LabelFrame(self.train_frame, text="Training images:")
        self.tr_frame.grid(row=0,
                           columnspan=cl_s,
                           sticky='WE',
                           padx=5,
                           pady=5,
                           ipadx=5,
                           ipady=5)
        self.model_frame = LabelFrame(self.train_frame, text="CNN model:")
        self.model_frame.grid(row=5,
                              columnspan=cl_s,
                              sticky='WE',
                              padx=5,
                              pady=5,
                              ipadx=5,
                              ipady=5)

        # training options
        self.inFolderLbl = Label(self.tr_frame, text="Training folder:")
        self.inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2)
        self.inFolderTxt = Entry(self.tr_frame)
        self.inFolderTxt.grid(row=0,
                              column=1,
                              columnspan=5,
                              sticky="W",
                              pady=3)
        self.inFileBtn = Button(self.tr_frame,
                                text="Browse ...",
                                command=self.load_training_path)
        self.inFileBtn.grid(row=0,
                            column=5,
                            columnspan=1,
                            sticky='W',
                            padx=5,
                            pady=1)

        self.optionsBtn = Button(self.tr_frame,
                                 text="Other options",
                                 command=self.parameter_window)
        self.optionsBtn.grid(row=0,
                             column=10,
                             columnspan=1,
                             sticky="W",
                             padx=(100, 1),
                             pady=1)

        # setting input modalities: FLAIR + T1 are mandatory
        # Mod 3 / 4 are optional
        self.flairTagLbl = Label(self.tr_frame, text="FLAIR tag:")
        self.flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2)
        self.flairTxt = Entry(self.tr_frame, textvariable=self.param_FLAIR_tag)
        self.flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1)

        self.t1TagLbl = Label(self.tr_frame, text="T1 tag:")
        self.t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2)
        self.t1Txt = Entry(self.tr_frame, textvariable=self.param_T1_tag)
        self.t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1)

        self.mod3TagLbl = Label(self.tr_frame, text="mod 3 tag:")
        self.mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2)
        self.mod3Txt = Entry(self.tr_frame, textvariable=self.param_MOD3_tag)
        self.mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1)

        self.mod4TagLbl = Label(self.tr_frame, text="mod 4 tag:")
        self.mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2)
        self.mod4Txt = Entry(self.tr_frame, textvariable=self.param_MOD4_tag)
        self.mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1)

        self.maskTagLbl = Label(self.tr_frame, text="MASK tag:")
        self.maskTagLbl.grid(row=5, column=0, sticky='E', padx=5, pady=2)
        self.maskTxt = Entry(self.tr_frame, textvariable=self.param_mask_tag)
        self.maskTxt.grid(row=5, column=1, columnspan=1, sticky="W", pady=1)

        # model options
        self.modelTagLbl = Label(self.model_frame, text="Model name:")
        self.modelTagLbl.grid(row=6, column=0, sticky='E', padx=5, pady=2)
        self.modelTxt = Entry(self.model_frame,
                              textvariable=self.param_net_name)
        self.modelTxt.grid(row=6, column=1, columnspan=1, sticky="W", pady=1)

        self.checkPretrain = Checkbutton(self.model_frame,
                                         text="use pretrained",
                                         var=self.param_use_pretrained_model)
        self.checkPretrain.grid(row=6, column=3, padx=5, pady=5)

        self.update_pretrained_nets()

        self.pretrainTxt = OptionMenu(self.model_frame,
                                      self.param_pretrained_model,
                                      *self.list_train_pretrained_nets)
        self.pretrainTxt.grid(row=6, column=5, sticky='E', padx=5, pady=5)

        # START button links
        self.trainingBtn = Button(self.train_frame,
                                  state='disabled',
                                  text="Start training",
                                  command=self.train_net)
        self.trainingBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1)

        # --------------------------------------------------
        # inference tab
        # --------------------------------------------------
        self.tt_frame = LabelFrame(self.test_frame, text="Inference images:")
        self.tt_frame.grid(row=0,
                           columnspan=cl_s,
                           sticky='WE',
                           padx=5,
                           pady=5,
                           ipadx=5,
                           ipady=5)
        self.test_model_frame = LabelFrame(self.test_frame, text="CNN model:")
        self.test_model_frame.grid(row=5,
                                   columnspan=cl_s,
                                   sticky='WE',
                                   padx=5,
                                   pady=5,
                                   ipadx=5,
                                   ipady=5)

        # testing options
        self.test_inFolderLbl = Label(self.tt_frame, text="Testing folder:")
        self.test_inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2)
        self.test_inFolderTxt = Entry(self.tt_frame)
        self.test_inFolderTxt.grid(row=0,
                                   column=1,
                                   columnspan=5,
                                   sticky="W",
                                   pady=3)
        self.test_inFileBtn = Button(self.tt_frame,
                                     text="Browse ...",
                                     command=self.load_testing_path)
        self.test_inFileBtn.grid(row=0,
                                 column=5,
                                 columnspan=1,
                                 sticky='W',
                                 padx=5,
                                 pady=1)

        self.test_optionsBtn = Button(self.tt_frame,
                                      text="Other options",
                                      command=self.parameter_window)
        self.test_optionsBtn.grid(row=0,
                                  column=10,
                                  columnspan=1,
                                  sticky="W",
                                  padx=(100, 1),
                                  pady=1)

        self.test_flairTagLbl = Label(self.tt_frame, text="FLAIR tag:")
        self.test_flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2)
        self.test_flairTxt = Entry(self.tt_frame,
                                   textvariable=self.param_FLAIR_tag)
        self.test_flairTxt.grid(row=1,
                                column=1,
                                columnspan=1,
                                sticky="W",
                                pady=1)

        self.test_t1TagLbl = Label(self.tt_frame, text="T1 tag:")
        self.test_t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2)
        self.test_t1Txt = Entry(self.tt_frame, textvariable=self.param_T1_tag)
        self.test_t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1)

        self.test_mod3TagLbl = Label(self.tt_frame, text="mod 3 tag:")
        self.test_mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2)
        self.test_mod3Txt = Entry(self.tt_frame,
                                  textvariable=self.param_MOD3_tag)
        self.test_mod3Txt.grid(row=3,
                               column=1,
                               columnspan=1,
                               sticky="W",
                               pady=1)

        self.test_mod4TagLbl = Label(self.tt_frame, text="mod 4 tag:")
        self.test_mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2)
        self.test_mod4Txt = Entry(self.tt_frame,
                                  textvariable=self.param_MOD4_tag)
        self.test_mod4Txt.grid(row=4,
                               column=1,
                               columnspan=1,
                               sticky="W",
                               pady=1)

        self.test_pretrainTxt = OptionMenu(self.test_model_frame,
                                           self.param_inference_model,
                                           *self.list_test_nets)

        self.param_inference_model.set('None')
        self.test_pretrainTxt.grid(row=5, column=0, sticky='E', padx=5, pady=5)

        # START button links cto docker task
        self.inferenceBtn = Button(self.test_frame,
                                   state='disabled',
                                   text="Start inference",
                                   command=self.infer_segmentation)
        self.inferenceBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1)

        # train / test ABOUT button
        self.train_aboutBtn = Button(self.train_frame,
                                     text="about",
                                     command=self.about_window)
        self.train_aboutBtn.grid(row=7,
                                 column=4,
                                 sticky='E',
                                 padx=(1, 1),
                                 pady=1)

        self.test_aboutBtn = Button(self.test_frame,
                                    text="about",
                                    command=self.about_window)
        self.test_aboutBtn.grid(row=7,
                                column=4,
                                sticky='E',
                                padx=(1, 1),
                                pady=1)

        # Processing state
        self.process_indicator = StringVar()
        self.process_indicator.set(' ')
        self.label_indicator = Label(master,
                                     textvariable=self.process_indicator)
        self.label_indicator.pack(side="left")

        # Closing processing events is implemented via
        # a master protocol
        self.master.protocol("WM_DELETE_WINDOW", self.close_event)

    def parameter_window(self):
        """
        Setting other parameters using an emerging window
        CNN parameters, CUDA device, post-processing....

        """
        t = Toplevel(self.master)
        t.wm_title("Other parameters")

        # data parameters
        t_data = LabelFrame(t, text="data options:")
        t_data.grid(row=0, sticky="WE")
        checkPretrain = Checkbutton(t_data,
                                    text="Register modalities",
                                    var=self.param_register_modalities)
        checkPretrain.grid(row=0, sticky='W')
        checkSkull = Checkbutton(t_data,
                                 text="Skull-strip modalities",
                                 var=self.param_skull_stripping)
        checkSkull.grid(row=1, sticky="W")
        checkDenoise = Checkbutton(t_data,
                                   text="Denoise masks",
                                   var=self.param_denoise)
        checkDenoise.grid(row=2, sticky="W")

        denoise_iter_label = Label(t_data,
                                   text=" Denoise iter:               ")
        denoise_iter_label.grid(row=3, sticky="W")
        denoise_iter_entry = Entry(t_data,
                                   textvariable=self.param_denoise_iter)
        denoise_iter_entry.grid(row=3, column=1, sticky="E")

        check_tmp = Checkbutton(t_data,
                                text="Save tmp files",
                                var=self.param_save_tmp)
        check_tmp.grid(row=4, sticky="W")
        checkdebug = Checkbutton(t_data,
                                 text="Debug mode",
                                 var=self.param_debug)
        checkdebug.grid(row=5, sticky="W")

        # model parameters
        t_model = LabelFrame(t, text="Model:")
        t_model.grid(row=5, sticky="EW")

        maxepochs_label = Label(t_model, text="Max epochs:                  ")
        maxepochs_label.grid(row=6, sticky="W")
        maxepochs_entry = Entry(t_model, textvariable=self.param_max_epochs)
        maxepochs_entry.grid(row=6, column=1, sticky="E")

        trainsplit_label = Label(t_model, text="Validation %:           ")
        trainsplit_label.grid(row=7, sticky="W")
        trainsplit_entry = Entry(t_model, textvariable=self.param_train_split)
        trainsplit_entry.grid(row=7, column=1, sticky="E")

        batchsize_label = Label(t_model, text="Test batch size:")
        batchsize_label.grid(row=8, sticky="W")
        batchsize_entry = Entry(t_model, textvariable=self.param_batch_size)
        batchsize_entry.grid(row=8, column=1, sticky="E")

        mode_label = Label(t_model, text="Verbosity:")
        mode_label.grid(row=9, sticky="W")
        mode_entry = Entry(t_model, textvariable=self.param_net_verbose)
        mode_entry.grid(row=9, column=1, sticky="E")

        #gpu_mode = Checkbutton(t_model,
        #                         text="GPU:",
        #                         var=self.param_mode)
        #gpu_mode.grid(row=10, sticky="W")

        gpu_number = Label(t_model, text="GPU number:")
        gpu_number.grid(row=10, sticky="W")
        gpu_entry = Entry(t_model, textvariable=self.param_gpu_number)
        gpu_entry.grid(row=10, column=1, sticky="W")

        # training parameters
        tr_model = LabelFrame(t, text="Training:")
        tr_model.grid(row=12, sticky="EW")

        balanced_label = Label(tr_model, text="Balanced dataset:    ")
        balanced_label.grid(row=13, sticky="W")
        balanced_entry = Entry(tr_model,
                               textvariable=self.param_balanced_dataset)
        balanced_entry.grid(row=13, column=1, sticky="E")

        fraction_label = Label(tr_model, text="Fraction negative/positives: ")
        fraction_label.grid(row=14, sticky="W")
        fraction_entry = Entry(tr_model,
                               textvariable=self.param_fract_negatives)
        fraction_entry.grid(row=14, column=1, sticky="E")

        # postprocessing parameters
        t_post = LabelFrame(t, text="Post-processing:  ")
        t_post.grid(row=15, sticky="EW")
        t_bin_label = Label(t_post, text="Out probability th:      ")
        t_bin_label.grid(row=16, sticky="W")
        t_bin_entry = Entry(t_post, textvariable=self.param_t_bin)
        t_bin_entry.grid(row=16, column=1, sticky="E")

        l_min_label = Label(t_post, text="Min out region size:         ")
        l_min_label.grid(row=17, sticky="W")
        l_min_entry = Entry(t_post, textvariable=self.param_l_min)
        l_min_entry.grid(row=17, column=1, sticky="E")

        vol_min_label = Label(t_post, text="Min vol error (ml):   ")
        vol_min_label.grid(row=18, sticky="W")
        vol_min_entry = Entry(t_post, textvariable=self.param_min_error)
        vol_min_entry.grid(row=18, column=1, sticky="E")

    def load_default_configuration(self):
        """
        load the default configuration from /config/default.cfg
        This method assign each of the configuration parameters to
        class attributes
        """

        default_config = ConfigParser.SafeConfigParser()
        default_config.read(os.path.join(self.path, 'config', 'default.cfg'))

        # dastaset parameters
        self.param_training_folder.set(
            default_config.get('database', 'train_folder'))
        self.param_test_folder.set(
            default_config.get('database', 'inference_folder'))
        self.param_FLAIR_tag.set(default_config.get('database', 'flair_tags'))
        self.param_T1_tag.set(default_config.get('database', 't1_tags'))
        self.param_MOD3_tag.set(default_config.get('database', 'mod3_tags'))
        self.param_MOD4_tag.set(default_config.get('database', 'mod4_tags'))
        self.param_mask_tag.set(default_config.get('database', 'roi_tags'))
        self.param_register_modalities.set(
            default_config.get('database', 'register_modalities'))
        self.param_denoise.set(default_config.get('database', 'denoise'))
        self.param_denoise_iter.set(
            default_config.getint('database', 'denoise_iter'))
        self.param_skull_stripping.set(
            default_config.get('database', 'skull_stripping'))
        self.param_save_tmp.set(default_config.get('database', 'save_tmp'))
        self.param_debug.set(default_config.get('database', 'debug'))

        # train parameters
        self.param_use_pretrained_model.set(
            default_config.get('train', 'full_train'))
        self.param_pretrained_model.set(
            default_config.get('train', 'pretrained_model'))
        self.param_inference_model.set("      ")
        self.param_balanced_dataset.set(
            default_config.get('train', 'balanced_training'))
        self.param_fract_negatives.set(
            default_config.getfloat('train', 'fraction_negatives'))

        # model parameters
        self.param_net_folder = os.path.join(self.current_folder, 'nets')
        self.param_net_name.set(default_config.get('model', 'name'))
        self.param_train_split.set(
            default_config.getfloat('model', 'train_split'))
        self.param_max_epochs.set(default_config.getint('model', 'max_epochs'))
        self.param_patience.set(default_config.getint('model', 'patience'))
        self.param_batch_size.set(default_config.getint('model', 'batch_size'))
        self.param_net_verbose.set(default_config.get('model', 'net_verbose'))
        self.param_gpu_number.set(default_config.getint('model', 'gpu_number'))
        # self.param_mode.set(default_config.get('model', 'gpu_mode'))

        # post-processing
        self.param_l_min.set(default_config.getint('postprocessing', 'l_min'))
        self.param_t_bin.set(default_config.getfloat('postprocessing',
                                                     't_bin'))
        self.param_min_error.set(
            default_config.getfloat('postprocessing', 'min_error'))

    def write_user_configuration(self):
        """
        write the configuration into config/configuration.cfg
        """
        user_config = ConfigParser.RawConfigParser()

        # dataset parameters
        user_config.add_section('database')
        user_config.set('database', 'train_folder',
                        self.param_training_folder.get())
        user_config.set('database', 'inference_folder',
                        self.param_test_folder.get())
        user_config.set('database', 'flair_tags', self.param_FLAIR_tag.get())
        user_config.set('database', 't1_tags', self.param_T1_tag.get())
        user_config.set('database', 'mod3_tags', self.param_MOD3_tag.get())
        user_config.set('database', 'mod4_tags', self.param_MOD4_tag.get())
        user_config.set('database', 'roi_tags', self.param_mask_tag.get())

        user_config.set('database', 'register_modalities',
                        self.param_register_modalities.get())
        user_config.set('database', 'denoise', self.param_denoise.get())
        user_config.set('database', 'denoise_iter',
                        self.param_denoise_iter.get())
        user_config.set('database', 'skull_stripping',
                        self.param_skull_stripping.get())
        user_config.set('database', 'save_tmp', self.param_save_tmp.get())
        user_config.set('database', 'debug', self.param_debug.get())

        # train parameters
        user_config.add_section('train')
        user_config.set('train', 'full_train',
                        not (self.param_use_pretrained_model.get()))
        user_config.set('train', 'pretrained_model',
                        self.param_pretrained_model.get())
        user_config.set('train', 'balanced_training',
                        self.param_balanced_dataset.get())
        user_config.set('train', 'fraction_negatives',
                        self.param_fract_negatives.get())
        # model parameters
        user_config.add_section('model')
        user_config.set('model', 'name', self.param_net_name.get())
        user_config.set('model', 'pretrained', self.param_pretrained)
        user_config.set('model', 'train_split', self.param_train_split.get())
        user_config.set('model', 'max_epochs', self.param_max_epochs.get())
        user_config.set('model', 'patience', self.param_patience.get())
        user_config.set('model', 'batch_size', self.param_batch_size.get())
        user_config.set('model', 'net_verbose', self.param_net_verbose.get())
        # user_config.set('model', 'gpu_mode', self.param_mode.get())
        user_config.set('model', 'gpu_number', self.param_gpu_number.get())

        # postprocessing parameters
        user_config.add_section('postprocessing')
        user_config.set('postprocessing', 't_bin', self.param_t_bin.get())
        user_config.set('postprocessing', 'l_min', self.param_l_min.get())
        user_config.set('postprocessing', 'min_error',
                        self.param_min_error.get())

        # Writing our configuration file to 'example.cfg'
        with open(os.path.join(self.path, 'config', 'configuration.cfg'),
                  'wb') as configfile:
            user_config.write(configfile)

    def load_training_path(self):
        """
        Select training path from disk and write it.
        If the app is run inside a container,
        link the iniitaldir with /data
        """
        initialdir = '/data' if self.container else os.getcwd()
        fname = askdirectory(initialdir=initialdir)
        if fname:
            try:
                self.param_training_folder.set(fname)
                self.inFolderTxt.delete(0, END)
                self.inFolderTxt.insert(0, self.param_training_folder.get())
                self.trainingBtn['state'] = 'normal'
            except:
                pass

    def load_testing_path(self):
        """
        Selecet the inference path from disk and write it
        If the app is run inside a container,
        link the iniitaldir with /data
        """
        initialdir = '/data' if self.container else os.getcwd()
        fname = askdirectory(initialdir=initialdir)
        if fname:
            try:
                self.param_test_folder.set(fname)
                self.test_inFolderTxt.delete(0, END)
                self.test_inFolderTxt.insert(0, self.param_test_folder.get())
                self.inferenceBtn['state'] = 'normal'
            except:
                pass

    def update_pretrained_nets(self):
        """
        get a list of the  different net configuration present in the system.
        Each model configuration is represented by a folder containing the network
        weights for each of the networks. The baseline net config is always
        included by default

        """
        folders = os.listdir(self.param_net_folder)
        self.list_train_pretrained_nets = folders
        self.list_test_nets = folders

    def write_to_console(self, txt):
        """
        to doc:
        important method
        """
        self.command_out.insert(END, str(txt))

    def write_to_test_console(self, txt):
        """
        to doc:
        important method
        """
        self.test_command_out.insert(END, str(txt))

    def infer_segmentation(self):
        """
        Method implementing the inference process:
        - Check network selection
        - write the configuration to disk
        - Run the process on a new thread
        """

        if self.param_inference_model.get() == 'None':
            print "ERROR: Please, select a network model before starting...\n"
            return
        if self.test_task is None:
            self.inferenceBtn.config(state='disabled')
            self.param_net_name.set(self.param_inference_model.get())
            self.param_use_pretrained_model.set(False)
            self.write_user_configuration()
            print "\n-----------------------"
            print "Running configuration:"
            print "-----------------------"
            print "Inference model:", self.param_model_tag.get()
            print "Inference folder:", self.param_test_folder.get(), "\n"

            print "Method info:"
            print "------------"
            self.test_task = ThreadedTask(self.write_to_test_console,
                                          self.test_queue,
                                          mode='testing')
            self.test_task.start()
            self.master.after(100, self.process_container_queue)

    def train_net(self):
        """
        Method implementing the training process:
        - write the configuration to disk
        - Run the process on a new thread
        """

        if self.param_net_name.get() == 'None':
            print "ERROR: Please, define network name before starting...\n"
            return

        self.trainingBtn['state'] = 'disable'

        if self.train_task is None:
            self.trainingBtn.update()
            self.write_user_configuration()
            print "\n-----------------------"
            print "Running configuration:"
            print "-----------------------"
            print "Train model:", self.param_net_name.get()
            print "Training folder:", self.param_training_folder.get(), "\n"

            print "Method info:"
            print "------------"

            self.train_task = ThreadedTask(self.write_to_console,
                                           self.test_queue,
                                           mode='training')
            self.train_task.start()
            self.master.after(100, self.process_container_queue)

    def check_update(self):
        """
            check update version and propose to download it if differnt
            So far, a rudimentary mode is used to check the last version.
            """

        # I have to discard possible local changes :(
        print "---------------------------------------"
        print "Updating software"
        print "current version:", self.commit_version

        remote_commit = subprocess.check_output(['git', 'stash'])
        remote_commit = subprocess.check_output(['git', 'fetch'])
        remote_commit = subprocess.check_output(
            ['git', 'rev-parse', 'origin/master'])

        if remote_commit != self.commit_version:
            proc = subprocess.check_output(['git', 'pull', 'origin', 'master'])
            self.check_link.config(text="Updated")
            self.commit_version = remote_commit
            print "updated version:", self.commit_version
        else:
            print "This software is already in the latest version"
        print "---------------------------------------"

    def about_window(self):
        """
        Window showing information about the software and
        version number, including auto-update. If the application
        is run from a container, then auto-update is disabled
        """
        def callback(event):
            """
            open webbrowser when clicking links
            """
            webbrowser.open_new(event.widget.cget("text"))

        # main window
        t = Toplevel(self.master, width=500, height=500)
        t.wm_title("About")

        # NIC logo + name
        title = Label(t,
                      text="nicMSlesions v" + self.version + "\n"
                      "Multiple Sclerosis White Matter Lesion Segmentation")
        title.grid(row=2, column=1, padx=20, pady=10)
        img = ImageTk.PhotoImage(Image.open('./logonic.png'))
        imglabel = Label(t, image=img)
        imglabel.image = img
        imglabel.grid(row=1, column=1, padx=10, pady=10)
        group_name = Label(t,
                           text="Copyright Sergi Valverde (2018-) \n " +
                           "NeuroImage Computing Group")
        group_name.grid(row=3, column=1)
        group_link = Label(t,
                           text=r"http://atc.udg.edu/nic",
                           fg="blue",
                           cursor="hand2")
        group_link.grid(row=4, column=1)
        group_link.bind("<Button-1>", callback)

        license_content = "Licensed under the BSD 2-Clause license. \n" + \
                          "A copy of the license is present in the root directory."

        license_label = Label(t, text=license_content)
        license_label.grid(row=5, column=1, padx=20, pady=20)

        # if self.container is False:
        #     # check version and updates
        #     version_number = Label(t, text="commit: " + self.commit_version)
        #     version_number.grid(row=6, column=1, padx=20, pady=(1, 1))
        #
        #     self.check_link = Button(t,
        #                         text="Check for updates",
        #                         command=self.check_update)
        #     self.check_link.grid(row=7, column=1)

    def process_container_queue(self):
        """
        Process the threading queue. When the threaded processes are
        finished, buttons are reset and a message is shown in the app.
        """
        self.process_indicator.set('Running... please wait')
        try:
            msg = self.test_queue.get(0)
            self.process_indicator.set('Done. See log for more details.')
            self.inferenceBtn['state'] = 'normal'
            self.trainingBtn['state'] = 'normal'
        except Queue.Empty:
            self.master.after(100, self.process_container_queue)

    def close_event(self):
        """
        Stop the thread processes using OS related calls.
        """
        if self.train_task is not None:
            self.train_task.stop_process()
        if self.test_task is not None:
            self.test_task.stop_process()
        os.system('cls' if platform.system == "Windows" else 'clear')
        root.destroy()
Пример #42
0
class Example(Frame):

    #######################################################################

    def __init__(self, parent):
        Frame.__init__(self, width=1000, height=1000, background="green")
        self.parent = parent
        self.pack(fill=BOTH, expand=True)
        self.initUI()

    def initUI(self):
        self.parent.title("Cravis_ver1")
        self.pack(fill=BOTH, expand=1)
        frame = Frame(self,
                      width=1500,
                      height=200,
                      relief=RAISED,
                      borderwidth=1)
        frame.pack(expand=False)
        #frame.config(bg="blue")
        self.pack(expand=False)
        #####

        #####

        frame2 = Frame(self,
                       width=1500,
                       height=300,
                       relief=RAISED,
                       borderwidth=1)
        frame2.pack(expand=False)
        self.pack(expand=False)

        self.var0 = BooleanVar()
        self.var1 = BooleanVar()
        self.var2 = BooleanVar()
        self.var3 = BooleanVar()
        self.var4 = BooleanVar()
        self.var5 = BooleanVar()
        self.content = IntVar()

        reset_Area_Button = Button(self,
                                   width=10,
                                   text="reset_Area",
                                   command=self.reset_Area)
        reset_Area_Button.place(x=610, y=400)

        set_Area_Button = Button(self,
                                 width=10,
                                 text="set_Area",
                                 command=self.set_Area)
        set_Area_Button.place(x=610, y=430)

        show_Area_Button = Button(self,
                                  width=10,
                                  text="show_Area",
                                  command=self.show_Area)
        show_Area_Button.place(x=610, y=460)

        quitButton = Button(self, text="Quit", command=self.off_video)
        quitButton.place(x=50, y=20)

        startButton = Button(self, text="Video", command=self.on_start)
        startButton.place(x=100, y=20)

        TakePicButton = Button(self, text="TakePic", command=self.Takepic)
        TakePicButton.place(x=150, y=20)

        LoadDataButton = Button(self,
                                text="Load_Data",
                                bg="green",
                                command=self.confirm_LoadData)
        LoadDataButton.place(x=550, y=90)

        SaveDataButton = Button(self,
                                text="Save_Data",
                                bg="green",
                                command=self.confirm_SaveData)
        SaveDataButton.place(x=550, y=120)
        ######

        cb1 = Checkbutton(self,
                          text="Binary",
                          variable=self.var1,
                          command=self.on_Binary)
        cb1.place(x=80, y=50)

        cb2 = Checkbutton(self,
                          text="Partical",
                          variable=self.var2,
                          command=self.on_Partical)
        cb2.place(x=80, y=80)

        cb3 = Checkbutton(self,
                          text="Sobel",
                          variable=self.var3,
                          command=self.on_Sobel)
        cb3.place(x=80, y=110)

        cb4 = Checkbutton(self,
                          text="Median",
                          variable=self.var4,
                          command=self.on_Median)
        cb4.place(x=80, y=140)

        cb5 = Checkbutton(self,
                          text="Level_Adjust",
                          variable=self.var5,
                          command=self.on_LevelAdjust)
        cb5.place(x=80, y=170)

        cb5 = Checkbutton(self, text="SaveImage", variable=self.var0)
        cb5.place(x=550, y=20)
        #####

        ###################################

        AdjustBinaryButton = Button(self,
                                    text="Adjust_Binary",
                                    command=self.AdjustBinary)
        AdjustBinaryButton.place(x=340, y=50)

        AdjustExtractButton = Button(self,
                                     text="Adjust_Extract",
                                     command=self.AdjustExtract)
        AdjustExtractButton.place(x=340, y=80)

        AdjustBinaryButton = Button(self,
                                    text="Adjust_3",
                                    command=self.AdjustBinary)
        AdjustBinaryButton.place(x=340, y=110)

        AdjustExtractButton = Button(self,
                                     text="Adjust_4",
                                     command=self.AdjustExtract)
        AdjustExtractButton.place(x=340, y=140)

        AdjustExtractButton = Button(self,
                                     text="Adjust_5",
                                     command=self.AdjustExtract)
        AdjustExtractButton.place(x=340, y=170)

        ########
        self.infor_Alg1 = Text(self, width=40, height=1)
        #self.infor_Alg1.pack(side=LEFT)
        self.infor_Alg1.place(x=130, y=250)
        #thongtin_Alg1="Binary : "
        #self.infor_Alg1.insert(END,thongtin_Alg1)
        self.label_Alg1 = Label(self, text="Binary: ")
        self.label_Alg1.place(x=50, y=250)
        ##
        self.infor_Alg2 = Text(self, width=40, height=1)
        #self.infor_Alg2.pack(side=LEFT)
        self.infor_Alg2.place(x=130, y=270)

        #thongtin_Alg2="Extract : "
        #self.infor_Alg2.insert(END,thongtin_Alg2)
        self.label_Alg2 = Label(self, text="Extract: ")
        self.label_Alg2.place(x=50, y=270)
        ##
        self.infor_Alg3 = Text(self, width=40, height=1)
        #self.infor_Alg3.pack()
        self.infor_Alg3.place(x=130, y=290)
        #thongtin_Alg3="Alg_3 : "
        #self.infor_Alg3.insert(END,thongtin_Alg3)
        self.label_Alg3 = Label(self, text="Alg3: ")
        self.label_Alg3.place(x=50, y=290)
        ##
        self.infor_Alg4 = Text(self, width=40, height=1)
        #self.infor_Alg4.pack(side=LEFT)
        self.infor_Alg4.place(x=130, y=310)
        #thongtin_Alg4="Alg_4 : "
        #self.infor_Alg4.insert(END,thongtin_Alg4)
        self.label_Alg4 = Label(self, text="Alg4: ")
        self.label_Alg4.place(x=50, y=310)
        ##
        self.infor_Alg5 = Text(self, width=40, height=1)
        #self.infor_Alg5.pack()
        self.infor_Alg5.place(x=130, y=330)
        #thongtin_Alg5="Alg_5 : "
        #self.infor_Alg5.insert(END,thongtin_Alg5)
        self.label_Alg5 = Label(self, text="Alg5: ")
        self.label_Alg5.place(x=50, y=330)
        ##

        self.infor_Area1 = Text(self, width=20, height=1)
        self.infor_Area1.place(x=100, y=400)
        #thongtin_Area1="Area1:"
        #self.infor_Area1.insert(END,thongtin_Area1)
        self.label_Area1 = Label(self, text="Area1: ")
        self.label_Area1.place(x=50, y=400)

        ##
        self.infor_Area2 = Text(self, width=20, height=1)
        self.infor_Area2.place(x=350, y=400)
        #thongtin_Area2="Area2:"
        #self.infor_Area2.insert(END,thongtin_Area2)
        self.label_Area2 = Label(self, text="Area2: ")
        self.label_Area2.place(x=300, y=400)
        ##
        self.infor_Area3 = Text(self, width=20, height=1)
        self.infor_Area3.place(x=100, y=450)
        #thongtin_Area3="Area3:"
        #self.infor_Area3.insert(END,thongtin_Area3)
        self.label_Area3 = Label(self, text="Area3: ")
        self.label_Area3.place(x=50, y=450)
        ##
        self.infor_Area4 = Text(self, width=20, height=1)
        self.infor_Area4.place(x=350, y=450)
        #thongtin_Area4="Area4:"
        #self.infor_Area4.insert(END,thongtin_Area4)
        self.label_Area4 = Label(self, text="Area4: ")
        self.label_Area4.place(x=300, y=450)
        #####

        ################################
        self.infor = Text(self, width=50, height=2)
        self.infor.pack()
        thongtin = "CHAO MUNG DEN VOI CHUONG TRINH CRAVIS_V1  \n DESIGN BY VISUAL GROUP"
        self.infor.insert(END, thongtin)

        ###################################

        menuBar = Menu(self.parent)
        self.parent.config(menu=menuBar)

        fileMenu1 = Menu(menuBar)
        fileMenu2 = Menu(menuBar)
        fileMenu3 = Menu(menuBar)

        fileMenu1.add_command(label="zoom", command=self.zoom)
        fileMenu1.add_command(label="password", command=self.zoom)
        fileMenu1.add_command(label="2", command=self.onExit)
        fileMenu1.add_command(label="3", command=self.onExit)

        fileMenu2.add_command(label="Exit", command=self.onExit)
        fileMenu2.add_command(label="1", command=self.onExit)
        fileMenu2.add_command(label="2", command=self.onExit)
        fileMenu2.add_command(label="3", command=self.onExit)

        fileMenu3.add_command(label="help", command=self.file_help)
        fileMenu3.add_command(label="1", command=self.onExit)
        fileMenu3.add_command(label="2", command=self.onExit)
        fileMenu3.add_command(label="3", command=self.onExit)

        menuBar.add_cascade(label="File", menu=fileMenu1)
        menuBar.add_cascade(label="Infor", menu=fileMenu2)
        menuBar.add_cascade(label="Help", menu=fileMenu3)
        ######

        ####### ################################################               function for menu

    def onScale_H(self, val):
        v = int(float(val))
        self.varHigh.set(v)
        print(v)
#self.varHigh.set(v)

    def onScale_L(self, val):
        v = int(float(val))
        self.varLow.set(v)
        print(v)

    ###
    def onScale_R_L(self, val):
        v = int(float(val))
        self.varRed_L.set(v)
        print(v)

    def onScale_R_H(self, val):
        v = int(float(val))
        self.varRed_H.set(v)
        print(v)

    def onScale_G_L(self, val):
        v = int(float(val))
        self.varGreen_L.set(v)
        print(v)

    def onScale_G_H(self, val):
        v = int(float(val))
        self.varGreen_H.set(v)
        print(v)

    def onScale_B_L(self, val):
        v = int(float(val))
        self.varBlue_L.set(v)
        print(v)

    def onScale_B_H(self, val):
        v = int(float(val))
        self.varBlue_H.set(v)
        print(v)

    ###
    def on_Select(self, val):
        sender = val.widget
        idx = sender.curselection()
        value = sender.get(idx)

        self.varSelect.set(value)

    def onExit(self):
        self.quit()

    def file_help(self):
        f = open('a.txt', 'w+')
        #line=f.readline()
        infor = "1111111111111\n 2222222222222222222\n333333333333333"
        f.write(infor)
        line = f.readline()
        for line in f:
            print(line)

    def zoom(self):
        root.geometry("1500x500")
######################################################   ############       Algorithm

    def on_Binary(self):
        if self.var1.get() == True:
            print("Binary")
            self.show_Binary()  #show window
        else:

            print("No_Binary")
            if hasattr(self, 'ThExtract'):
                print "dsfsdfds"
                self.ThBinary.withdraw()
            else:
                print "dddddddd"

            #self.ThBinary.withdraw()
    def on_Partical(self):
        if self.var2.get() == True:
            print("Partical")
            self.show_Extract()
        else:
            print("No_Partical")
            self.ThExtract.withdraw()

    def on_Sobel(self):
        if self.var3.get() == True:
            print("Sobel")
        else:
            print("No_Sobel")

    def on_Median(self):
        if self.var4.get() == True:
            print("Median")
        else:
            print("No_Median")

    def on_LevelAdjust(self):
        if self.var5.get() == True:
            print("LevAd")
        else:
            print("No_LevAd")

    def showvideo(self):

        if camera.resolution == (400, 300):
            print("ok")
            cwgt.camera.start_preview()

###############################################################################   button  to analyse image

    def Takepic(self):  ## take pic button

        src = Frame(cwgt, width=400, height=300, relief=RAISED, borderwidth=1)
        src = camera.capture('src.png')
        analysed = camera.capture('analysed.png')
        if self.var0.get() == 1:
            camera.capture("/home/pi/Desktop/New/{0:%Y%m%d-%H%M%S}.png".format(
                datetime.now()))

        #'{0:%Y%m%d-%H%M%S}: start.'.format(datetime.now())
        #img_abc=PhotoImage(file="src.png")
        #h=img_abc.width()
        #w=img_abc.height()
        #print h,w

        #cv2.imwrite("src.png",src)

        #img_abc = cv2.imread("img.png",cv2.IMREAD_COLOR)
        #cv2.rectangle(img_abc,(50,50),(100,50),(255,0,0),15)
        #cv2.imwrite("out2.png",img_abc)

        img_origin = PhotoImage(file="src.png")
        cwgt2.img = img_origin
        cwgt2.create_image(200, 200, image=img_origin)

        h = img_origin.width()
        w = img_origin.height()
        #print h,w
        #px=img[55,55]

        #img_new=cv2.imread("out2.png")

        #pix=img_new[2,2]
        #pix0=img_new[2,2][0]
        #pix1=img_new[2,2][1]
        #pix2=img_new[2,2][2]
        #print pix,pix0,pix1,pix2

        #for j in range (0,h):
        #	  for i in range (0,w):
        #	  if img_new[i,j]

        #img_new[i,i]=[255,255,255]
        #pix__=img_new[2,2][0]
        #print pix__

        #cv2.imwrite("out3.png",img_new)
        #img_x=PhotoImage(file="out3.png")
        #cwgt2.img=img_x
        #cwgt2.create_image(200, 200,  image=img_x)

        #if self.var1.get() == True:

        #src=cv2.imread("src.png")
        #res=cv2.Canny(src,self.varLow.get(), self.varHigh.get())
        #retval,res = cv2.threshold(src, self.varLow.get(), self.varHigh.get(), cv2.THRESH_BINARY)
        #cv2.imwrite("analysed.png",res)

        if self.var2.get() == True:
            min_R = self.varRed_L.get()
            max_R = self.varRed_H.get()

            min_G = self.varGreen_L.get()
            max_G = self.varGreen_H.get()

            min_B = self.varBlue_L.get()
            max_B = self.varBlue_H.get()

            pro_2 = cv2.imread('analysed.png')
            #hsv = cv2.cvtColor(src,cv2.COLOR_BGR2HSV)
            lower = np.array([min_B, min_G, min_R], np.uint8)
            upper = np.array([max_B, max_G, max_R], np.uint8)
            mask = cv2.inRange(pro_2, lower, upper)
            analysed = cv2.bitwise_and(pro_2, pro_2, mask=mask)
            cv2.imwrite("analysed.png", analysed)
            #cv2.imshow('aaa',src)
            #
            #img2=PhotoImage(file="out.png")
            #cwgt.img2=img2
            #cwgt.create_image(200, 200,  image=img2)
            #cv2.imwrite("out3.png",img_new)
        img_show = PhotoImage(file="analysed.png")
        cwgt.img = img_show
        cwgt.create_image(200, 200, image=img_show)

        if self.var1.get() == True:

            src = cv2.imread("analysed.png")
            #analysed=cv2.Canny(src,self.varLow.get(), self.varHigh.get())
            retval, res = cv2.threshold(src, self.varLow.get(),
                                        self.varHigh.get(), cv2.THRESH_BINARY)
            cv2.imwrite("analysed.png", res)

        if self.var5.get() == True:
            src = cv2.imread("analysed.png")
            number = 0
            for j in range(self.x0_1, self.x1_1):
                for i in range(self.y0_1, self.y1_1):
                    if src[i, j][0] > 0 and src[i, j][1] > 0 and src[i,
                                                                     j][2] > 0:
                        src[i, j] = [255, 255, 255]
                        number = number + 1
            print number
            if number > 180:
                tkMessageBox.showinfo(title="OK", message="OK")
            else:
                tkMessageBox.showinfo(title="ng", message="ng")
            cv2.imwrite("analysed.png", src)
        img_show = PhotoImage(file="analysed.png")
        cwgt.img = img_show
        cwgt.create_image(200, 200, image=img_show)
        #img_show=PhotoImage(file="src.png")
        #cwgt.img=img_show
        #cwgt.create_image(200, 200,  image=img_show)

#retval, after_Binary = cv2.threshold(img, self.varLow.get(), self.varHigh.get(), cv2.THRESH_BINARY)

#after_Blurr =cv2.blur(img,(5,5))
#after_MedianBlur=cv2.medianBlur(after_Blurr,5)

#cv2.imwrite("out.png",res)
#after_Binary=PhotoImage(file="out.png")
#cwgt.img=res
#cv2.imshow("show",res)
#cwgt.create_image(0, 0,  image=after_Binary)
#cwgt.create_image(0, 0,  image=mask)

#after_Canny=cv2.Canny(after_MedianBlur,100,200)

#findlabel=cv2.findContours(after_Blurr,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
#findlabel=cv2.findContours(after_Binary,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
#im = cv2.imread('new.png')
#imgray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
#ret,thresh = cv2.threshold(imgray,0,255,0)
#image, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
#img=cv2.drawContours(image,contours,-1,(0,255,0),1)
#cv2.imwrite("out.png",after_Binary)
#cv2.imwrite("blur.png",after_Blurr)
#cv2.imwrite("median blur.png",after_MedianBlur)
#cv2.imwrite("Canny.png",after_Canny)

#after_Binary=PhotoImage(file="out.png")
#cwgt.img=after_Binary
#cwgt.create_image(0, 0,  image=after_Binary)

#else:
#cwgt.create_image(0, 0,  image=img_origin)
#print("xsfd")
#print img_origin[100,100][0]
#www=img_origin.width()
#print www

#

    def on_start(self):
        print("xsfd")
        self.showvideo()

    def off_video(self):
        #cwgt.frame.destroy()
        camera.stop_preview()

        ########

    ######################################################################################   show window
    def show_Binary(self):  ## input Thresh_Binary

        if (hasattr(self, 'ThBinary')):
            #(self.varHigh.get()> self.varLow.get())
            self.ThBinary.deiconify()
        else:
            self.ThBinary = Tk()
            self.ThBinary.geometry("350x100+350+350")
            self.ThBinary.title("Binary")
            self.scale_L = Scale(self.ThBinary,
                                 from_=255,
                                 to=0,
                                 command=self.onScale_L)
            self.scale_L.pack(side=LEFT, padx=10)

            self.varLow = IntVar()
            self.label1 = Label(self.ThBinary, text="LOW")
            self.label1.pack(side=LEFT, padx=0)

            self.scale_H = Scale(self.ThBinary,
                                 from_=255,
                                 to=0,
                                 command=self.onScale_H)
            self.scale_H.pack(side=LEFT, padx=20)

            self.varHigh = IntVar()
            self.label2 = Label(self.ThBinary, text="HIGH")
            self.label2.pack(side=LEFT, padx=1)

            binary = Button(self.ThBinary,
                            text="OK",
                            width=5,
                            background="green",
                            command=self.getdata_Binary)
            binary.pack(side=LEFT)
            #binary = Button(self.ThBinary, text="Get_Binary",background="green",command=self.getdata_Binary)
            #binary.pack()

########

    def show_Extract(self):  ## input Thresh_Extract

        if hasattr(self, 'ThExtract'):
            self.ThExtract.deiconify()
        else:

            self.ThExtract = Tk()
            self.ThExtract.geometry("750x100+350+350")
            self.ThExtract.title("Extract_Color")
            ###
            self.scale_R_L = Scale(self.ThExtract,
                                   from_=255,
                                   to=0,
                                   command=self.onScale_R_L)
            self.scale_R_L.pack(side=LEFT, padx=10)

            self.varRed_L = IntVar()
            self.label_R_L = Label(self.ThExtract, text="Red_L")
            self.label_R_L.pack(side=LEFT, padx=0)

            self.scale_R_H = Scale(self.ThExtract,
                                   from_=255,
                                   to=0,
                                   command=self.onScale_R_H)
            self.scale_R_H.pack(side=LEFT, padx=10)

            self.varRed_H = IntVar()
            self.label_R_H = Label(self.ThExtract, text="Red_H")
            self.label_R_H.pack(side=LEFT, padx=0)

            ###
            self.scale_G_L = Scale(self.ThExtract,
                                   from_=255,
                                   to=0,
                                   command=self.onScale_G_L)
            self.scale_G_L.pack(side=LEFT, padx=10)

            self.varGreen_L = IntVar()
            self.label_G_L = Label(self.ThExtract, text="Green_L")
            self.label_G_L.pack(side=LEFT, padx=0)

            self.scale_G_H = Scale(self.ThExtract,
                                   from_=255,
                                   to=0,
                                   command=self.onScale_G_H)
            self.scale_G_H.pack(side=LEFT, padx=10)

            self.varGreen_H = IntVar()
            self.label_G_H = Label(self.ThExtract, text="Green_H")
            self.label_G_H.pack(side=LEFT, padx=0)
            ###
            self.scale_B_L = Scale(self.ThExtract,
                                   from_=255,
                                   to=0,
                                   command=self.onScale_B_L)
            self.scale_B_L.pack(side=LEFT, padx=10)

            self.varBlue_L = IntVar()
            self.label_B_L = Label(self.ThExtract, text="Blue_L")
            self.label_B_L.pack(side=LEFT, padx=0)

            self.scale_B_H = Scale(self.ThExtract,
                                   from_=255,
                                   to=0,
                                   command=self.onScale_B_H)
            self.scale_B_H.pack(side=LEFT, padx=10)

            self.varBlue_H = IntVar()
            self.label_G_H = Label(self.ThExtract, text="Blue_H")
            self.label_G_H.pack(side=LEFT, padx=0)
            ###

            Extract = Button(self.ThExtract,
                             text="OK",
                             width=5,
                             background="green",
                             command=self.getdata_Extract)
            Extract.pack(side=LEFT)

##########

    def show_Partical(self):
        print("")

    #self.ThBinary=Tk()
        #self.ThBinary.geometry("200x70+350+350")
        #self.ThBinary.title("Binary")
        #self.scale_L = Scale(self.ThBinary, from_=0, to=255, command=self.onScale_L)
        #self.scale_L.pack(side=LEFT, padx=10)

        #self.varLow = IntVar()
        #self.label1 = Label(self.ThBinary,text="LOW")
        #self.label1.pack(side=LEFT,padx=0)

        #self.scale_H = Scale(self.ThBinary, from_=0, to=255, command=self.onScale_H)
        #self.scale_H.pack(side=LEFT, padx=20)

        #self.varHigh = IntVar()
        #self.label2 = Label(self.ThBinary, text="HIGH")
        #self.label2.pack(side=LEFT,padx=1)

#########

    def confirm_SaveData(self):  ##input password

        self.master = Tk()
        self.master.title("pass")
        self.master.geometry("200x70+350+350")
        self.content = StringVar()

        self.entry = Entry(self.master, text="000", textvariable=self.content)
        self.entry.pack()

        b = Button(self.master, text="get", width=10, command=self.SaveData)
        b.pack()
        text123 = self.content.get()
        self.content.set(text123)

        print(self.content.get())
############

    def reset_Area(self):
        self.infor_Area1.delete('1.0', END)
        self.infor_Area2.delete('1.0', END)
        self.infor_Area3.delete('1.0', END)
        self.infor_Area4.delete('1.0', END)

    def set_Area(self):

        self.text1 = self.infor_Area1.get('1.0', END)

        self.x0_1 = int(self.text1[0] + self.text1[1] + self.text1[2])
        self.y0_1 = int(self.text1[4] + self.text1[5] + self.text1[6])
        self.x1_1 = int(self.text1[8] + self.text1[9] + self.text1[10])
        self.y1_1 = int(self.text1[12] + self.text1[13] + self.text1[14])

        #########

    def show_Area(self):
        #text1=self.infor_Area1.get('1.0',END)
        #x0_1=int(text1[0]+text1[1])
        #y0_1=int(text1[3]+text1[4])
        #x1_1=int(text1[6]+text1[7])
        #y1_1=int(text1[9]+text1[10])

        #text2=self.infor_Area2.get('1.0',END)
        #x0_2=int(text2[0]+text2[1])
        #y0_2=int(text2[3]+text2[4])
        #x1_2=int(text2[6]+text2[7])
        #y1_2=int(text2[9]+text2[10])

        #text3=self.infor_Area3.get('1.0',END)
        #x0_3=int(text3[0]+text3[1])
        #y0_3=int(text3[3]+text3[4])
        #x1_3=int(text3[6]+text3[7])
        #y1_3=int(text3[9]+text3[10])

        #text4=self.infor_Area4.get('1.0',END)
        #x0_4=int(text4[0]+text4[1])
        #y0_4=int(text4[3]+text4[4])
        #x1_4=int(text4[6]+text4[7])
        #y1_4=int(text4[9]+text4[10])

        img = cv2.imread("src.png", cv2.IMREAD_COLOR)
        #print self.x0_1
        cv2.rectangle(img, (self.x0_1, self.y0_1), (self.x1_1, self.y1_1),
                      (255, 0, 0), 2)
        #cv2.rectangle(img,(x0_2,y0_2),(x1_2,y1_2),(0,255,0),2)
        #cv2.rectangle(img,(x0_3,y0_3),(x1_3,y1_3),(0,0,255),2)
        #cv2.rectangle(img,(x0_4,y0_4),(x1_4,y1_4),(255,255,0),2)
        img_show_Area = img
        #img_show_Area=cv2.rectangle(img,(x0_1,y0_1),(x1_1,y1_1),(255,0,0),2)
        cv2.imwrite("show_Area.png", img_show_Area)
        img_show = PhotoImage(file="show_Area.png")
        cwgt2.img = img_show
        cwgt2.create_image(200, 200, image=img_show)
        #cv2.rectangle(img,(50,250),(100,500),(255,0,0),15)

    def AdjustBinary(self):
        if self.var1.get() == True:
            self.ThBinary.withdraw()
            self.ThBinary.deiconify()

    def AdjustExtract(self):
        if self.var2.get() == True:
            self.ThExtract.withdraw()
            self.ThExtract.deiconify()
############################################################################################   get data

    def SaveData(self):  ## get password button
        print(self.entry.get())
        self.set_Area()
        if self.entry.get() == "1111":
            self.master.destroy()
            tkMessageBox.showinfo(title="Save", message="SaveData success !!")
            print "Save"
            self.inforData_binary = "Binary : (" + self.text_binary + ")"
            self.inforData_Extract = "Extract : " + self.text_Extract
            self.inforData_Area1 = "Area1 : " + self.text1

            if self.var1.get() == 1:
                data1 = "1"
            else:
                data1 = "0"
##
            if self.var2.get() == 1:
                data2 = "1"
            else:
                data2 = "0"
            ##
            if self.var3.get() == 1:
                data3 = "1"
            else:
                data3 = "0"
##
            if self.var4.get() == 1:
                data4 = "1"
            else:
                data4 = "0"
##
            if self.var5.get() == 1:
                data5 = "1"
            else:
                data5 = "0"
##
            self.SumData = (data1 + data2 + data3 + data4 + data5)
            print self.SumData
            self.inforData = self.SumData + "\n" + self.inforData_binary + "\n" + self.inforData_Extract + "\n" + self.inforData_Area1
            print self.inforData

            #if self.var1.get()==1 :

            f = open('a.txt', 'w+')
            f.write(self.inforData)
        else:
            tkMessageBox.showinfo(title="fail", message="again")
####

    def getdata_Binary(self):
        value_low = str(self.varLow.get())
        value_high = str(self.varHigh.get())

        if self.varLow.get() > 99:
            min_binary = str(value_low)
        else:
            if self.varLow.get() > 9:
                min_binary = str("0" + value_low)
            else:
                min_binary = str("00" + value_low)

        if self.varHigh.get() > 99:
            max_binary = str(value_high)
        else:
            if self.varHigh.get() > 9:
                max_binary = str("0" + value_high)
            else:
                max_binary = str("00" + value_high)

        self.text_binary = str(min_binary + "," + max_binary)

        #if hasattr(self,'infor'):
        #	self.infor.destroy()
        #if hasattr(self,'infor_Alg1'):
        #	self.infor_Alg1.destroy()
        if self.varHigh.get() > self.varLow.get():
            self.infor_Alg1.delete('1.0', END)
            self.infor_Alg1.insert(END, self.text_binary)
            #self.ThBinary.destroy()
            self.ThBinary.withdraw()
        else:
            tkMessageBox.showinfo(title="fail", message="again")

####

    def getdata_Extract(self):

        value_R_L = str(self.varRed_L.get())
        value_R_H = str(self.varRed_H.get())

        value_G_L = str(self.varGreen_L.get())
        value_G_H = str(self.varGreen_H.get())

        value_B_L = str(self.varBlue_L.get())
        value_B_H = str(self.varBlue_H.get())
        ##
        if self.varRed_L.get() > 99:
            min_R = str(value_R_L)
        else:
            if self.varRed_L.get() > 9:
                min_R = str("0" + value_R_L)
            else:
                min_R = str("00" + value_R_L)
        ##

        if self.varRed_H.get() > 99:
            max_R = str(value_R_H)
        else:
            if self.varRed_H.get() > 9:
                max_R = str("0" + value_R_H)
            else:
                max_R = str("00" + value_R_H)
###

        if self.varGreen_L.get() > 99:
            min_G = str(value_G_L)
        else:
            if self.varGreen_L.get() > 9:
                min_G = str("0" + value_G_L)
            else:
                min_G = str("00" + value_G_L)
        ##

        if self.varGreen_H.get() > 99:
            max_G = str(value_G_H)
        else:
            if self.varGreen_H.get() > 9:
                max_G = str("0" + value_G_H)
            else:
                max_G = str("00" + value_G_H)
###

        if self.varBlue_L.get() > 99:
            min_B = str(value_B_L)
        else:
            if self.varBlue_L.get() > 9:
                min_B = str("0" + value_B_L)
            else:
                min_B = str("00" + value_B_L)
        ##

        if self.varBlue_H.get() > 99:
            max_B = str(value_B_H)
        else:
            if self.varBlue_H.get() > 9:
                max_B = str("0" + value_B_H)
            else:
                max_B = str("00" + value_B_H)
###

        self.text_Extract = str("R(" + min_R + "," + max_R + ")" + "G(" +
                                min_G + "," + max_G + ")" + "B(" + min_B +
                                "," + max_B + ")")

        #if hasattr(self,'infor'):
        #	self.infor.destroy()
        if ((self.varRed_H.get() > self.varRed_L.get())
                and (self.varGreen_H.get() > self.varGreen_L.get())
                and (self.varBlue_H.get() > self.varBlue_L.get())):
            self.infor_Alg2.delete('1.0', END)
            self.infor_Alg2.insert(END, self.text_Extract)
            self.ThExtract.withdraw()
        else:
            tkMessageBox.showinfo(title="fail", message="again")

    def confirm_LoadData(self):
        self.master = Tk()
        self.master.title("pass")
        self.master.geometry("200x70+350+350")
        self.content = StringVar()

        self.entry = Entry(self.master, text="000", textvariable=self.content)
        self.entry.pack()

        b = Button(self.master,
                   text="get",
                   width=10,
                   command=self.getdata_Load)
        b.pack()
        text123 = self.content.get()
        self.content.set(text123)

    def getdata_Load(self):

        if self.entry.get() == "1111":
            self.master.destroy()
            tkMessageBox.showinfo(title="Load", message="LoadData success !!")
            self.LoadData()
        else:
            tkMessageBox.showinfo(title="fail", message="again")

    def LoadData(self):
        print "Load"
        f = open('a.txt', 'r')

        self.SumData = f.readline()
        load_binary = f.readline()
        load_extract = f.readline()
        load_area1 = f.readline()

        #self.ThBinary.deiconify()

        text_binary = (load_binary[10] + load_binary[11] + load_binary[12] +
                       load_binary[13] + load_binary[14] + load_binary[15] +
                       load_binary[16])
        text_extract = (
            load_extract[10] + load_extract[11] + load_extract[12] +
            load_extract[13] + load_extract[14] + load_extract[15] +
            load_extract[16] + load_extract[17] + load_extract[18] +
            load_extract[19] + load_extract[20] + load_extract[21] +
            load_extract[22] + load_extract[23] + load_extract[24] +
            load_extract[25] + load_extract[26] + load_extract[27] +
            load_extract[28] + load_extract[29] + load_extract[30] +
            load_extract[31] + load_extract[32] + load_extract[33] +
            load_extract[34] + load_extract[35] + load_extract[36] +
            load_extract[37] + load_extract[38] + load_extract[39])
        text_area1 = (load_area1[8] + load_area1[9] + load_area1[10] +
                      load_area1[11] + load_area1[12] + load_area1[13] +
                      load_area1[14] + load_area1[15] + load_area1[16] +
                      load_area1[17] + load_area1[18] + load_area1[19] +
                      load_area1[20] + load_area1[21] + load_area1[22])

        value_low_binary = int(load_binary[10] + load_binary[11] +
                               load_binary[12])
        value_high_binary = int(load_binary[14] + load_binary[15] +
                                load_binary[16])
        ####
        value_low_red = int(load_extract[12] + load_extract[13] +
                            load_extract[14])
        value_high_red = int(load_extract[16] + load_extract[17] +
                             load_extract[18])

        value_low_green = int(load_extract[22] + load_extract[23] +
                              load_extract[24])
        value_high_green = int(load_extract[26] + load_extract[27] +
                               load_extract[28])

        value_low_blue = int(load_extract[32] + load_extract[33] +
                             load_extract[34])
        value_high_blue = int(load_extract[36] + load_extract[37] +
                              load_extract[38])
        ####
        value_area1_x0 = int(load_area1[8] + load_area1[9] + load_area1[10])
        value_area1_y0 = int(load_area1[12] + load_area1[13] + load_area1[14])
        value_area1_x1 = int(load_area1[16] + load_area1[17] + load_area1[18])
        value_area1_y1 = int(load_area1[20] + load_area1[21] + load_area1[22])
        #######
        self.x0_1 = value_area1_x0
        self.y0_1 = value_area1_y0
        self.x1_1 = value_area1_x1
        self.y1_1 = value_area1_y1

        #######
        self.varHigh = IntVar()
        self.varLow = IntVar()
        self.varRed_L = IntVar()
        self.varRed_H = IntVar()
        self.varGreen_L = IntVar()
        self.varGreen_H = IntVar()
        self.varBlue_L = IntVar()
        self.varBlue_H = IntVar()

        self.varLow.set(value_low_binary)
        self.varHigh.set(value_high_binary)
        self.varRed_L.set(value_low_red)
        self.varRed_H.set(value_high_red)
        self.varGreen_L.set(value_low_green)
        self.varGreen_H.set(value_high_green)
        self.varBlue_L.set(value_low_blue)
        self.varBlue_H.set(value_high_blue)

        self.text_binary = text_binary
        self.text_Extract = text_extract
        self.text_area1 = text_area1

        self.infor_Alg1.delete('1.0', END)
        self.infor_Alg1.insert(END, self.text_binary)
        self.infor_Alg2.delete('1.0', END)
        self.infor_Alg2.insert(END, self.text_Extract)

        self.infor_Area1.delete('1.0', END)
        self.infor_Area1.insert(END, self.text_area1)

        if self.SumData[0] == "1":
            self.var1.set(1)
        else:
            self.var1.set(0)

        if self.SumData[1] == "1":
            self.var2.set(1)
        else:
            self.var2.set(0)

        if self.SumData[2] == "1":
            self.var3.set(1)
        else:
            self.var3.set(0)

        if self.SumData[3] == "1":
            self.var4.set(1)
        else:
            self.var4.set(0)

        if self.SumData[4] == "1":
            self.var5.set(1)
        else:
            self.var5.set(0)

        self.set_Area()
        #self.inforData_binary="Binary : (" + self.text_binary + ")"
        #self.inforData_Extract="Extract : " + self.text_Extract
        #self.inforData=self.inforData_binary + "\n" + self.inforData_Extract
        #print self.inforData
    def Area(self):
        print "asasas"
Пример #43
0
 def test_get(self):
     v = BooleanVar(self.root, True, 'name')
     self.assertAlmostEqual(True, v.get())
     self.root.globalsetvar('name', '0')
     self.assertAlmostEqual(False, v.get())
Пример #44
0
class GrepDialog(SearchDialogBase):

    title = "Find in Files Dialog"
    icon = "Grep"
    needwrapbutton = 0

    def __init__(self, root, engine, flist):
        SearchDialogBase.__init__(self, root, engine)
        self.flist = flist
        self.globvar = StringVar(root)
        self.recvar = BooleanVar(root)

    def open(self, text, searchphrase, io=None):
        SearchDialogBase.open(self, text, searchphrase)
        if io:
            path = io.filename or ""
        else:
            path = ""
        dir, base = os.path.split(path)
        head, tail = os.path.splitext(base)
        if not tail:
            tail = ".py"
        self.globvar.set(os.path.join(dir, "*" + tail))

    def create_entries(self):
        SearchDialogBase.create_entries(self)
        self.globent = self.make_entry("In files:", self.globvar)[0]

    def create_other_buttons(self):
        f = self.make_frame()[0]

        btn = Checkbutton(f,
                          anchor="w",
                          variable=self.recvar,
                          text="Recurse down subdirectories")
        btn.pack(side="top", fill="both")
        btn.select()

    def create_command_buttons(self):
        SearchDialogBase.create_command_buttons(self)
        self.make_button("Search Files", self.default_command, 1)

    def default_command(self, event=None):
        prog = self.engine.getprog()
        if not prog:
            return
        path = self.globvar.get()
        if not path:
            self.top.bell()
            return
        from idlelib.OutputWindow import OutputWindow  # leave here!
        save = sys.stdout
        try:
            sys.stdout = OutputWindow(self.flist)
            self.grep_it(prog, path)
        finally:
            sys.stdout = save

    def grep_it(self, prog, path):
        dir, base = os.path.split(path)
        list = self.findfiles(dir, base, self.recvar.get())
        list.sort()
        self.close()
        pat = self.engine.getpat()
        print("Searching %r in %s ..." % (pat, path))
        hits = 0
        try:
            for fn in list:
                try:
                    with open(fn) as f:
                        for lineno, line in enumerate(f, 1):
                            if line[-1:] == '\n':
                                line = line[:-1]
                            if prog.search(line):
                                sys.stdout.write("%s: %s: %s\n" %
                                                 (fn, lineno, line))
                                hits += 1
                except IOError as msg:
                    print(msg)
            print(("Hits found: %s\n"
                   "(Hint: right-click to open locations.)" %
                   hits) if hits else "No hits.")
        except AttributeError:
            # Tk window has been closed, OutputWindow.text = None,
            # so in OW.write, OW.text.insert fails.
            pass

    def findfiles(self, dir, base, rec):
        try:
            names = os.listdir(dir or os.curdir)
        except os.error as msg:
            print(msg)
            return []
        list = []
        subdirs = []
        for name in names:
            fn = os.path.join(dir, name)
            if os.path.isdir(fn):
                subdirs.append(fn)
            else:
                if fnmatch.fnmatch(name, base):
                    list.append(fn)
        if rec:
            for subdir in subdirs:
                list.extend(self.findfiles(subdir, base, rec))
        return list

    def close(self, event=None):
        if self.top:
            self.top.grab_release()
            self.top.withdraw()
Пример #45
0
 def test_default(self):
     v = BooleanVar(self.root)
     self.assertIs(v.get(), False)
Пример #46
0
class TkAdmin(TkWindow, RPCComponent):
    """
    Development graphical user interface for cape systems.
    """
    
    unique = True
    directory_name = "TkAdmin"

    # TODO:
    # * Clean up user interface
    # * Develop interaction elements for all primitives

    def __init__(self):
        self.nodelist = {}
        self.messages = []
        
        self.title = "cape TkAdmin - [%s]" % identity.SystemName
        super(TkAdmin, self).__init__()

        self.Configuration['fixsender'] = False
        self.Configuration['autoclear'] = True
        self.Configuration['autoscan'] = True
        self.Configuration['showresponses'] = False

        self.autoscan.set(self.Configuration['autoscan'])
        self.fixsender.set(self.Configuration['fixsender'])
        self.autoclear.set(self.Configuration['autoclear'])
        self.showresponses.set(self.Configuration['showresponses'])

        # The invisibleroot is necessary to avoid stopping Tk's eventloop
        # upon closure of tkWindows.
        # TODO: Good idea to already activate here?
        # TODO: Don't we need a central InvisibleWindow thats kept inbetween destruction of tkinterfaces?
        self._invisibleRoot = tkInvisibleWindow().activate()
        #        self.clearInput = tkinter.BooleanVar()
        self.MapViewer = None

    def __on_ButtonClear_Press(self, Event=None):
        self.clearEntry()

    def __on_ButtonTransmit_Release(self, Event=None):
        self.usertransmit()

    def __on_EntryInput_Enter__C(self, Event=None):
        self.usertransmit()

    def __on_ButtonClearResponses_Press(self, Event=None):
        self.__TextResponses.clear()

    def showMessage(self, ev=None):
        msglb = self.__MessageLog._listbox
        sel = msglb.curselection()
        if len(sel) > 1:
            self.logwarning("Multiple messages selected to display. Can't.")
        msg = self.messages[int(sel[0])]
        msgdialog = TkMessageDialog(self.window, msg)
        
    def composeMessage(self, name="", node="", sender=None):
        if not sender:
            sender = self.name
        msg = Message(sender=sender, recipientnode=node, recipient=name)
        msgdialog = TkMessageDialog(self.window, msg, onclosecallback=self.transmit)  

    def clearEntry(self):
        self.__EntryInput.delete(0, END)
        self.__FrameInput['bg'] = self.defaultcolors['bg']

    #        self.__EntryInput['fg'] = self.defaultcolors['fg']

    def scanregistry(self, node=""):
        msg = Message(sender=self.name, 
                      recipientnode=node, 
                      recipient=self.systemregistry, 
                      func="listRegisteredComponents",
                      arg=None
                      )
        self.transmit(msg)
        msg = Message(sender=self.name,
                      recipientnode=node,
                      recipient=self.systemregistry,
                      func="listRegisteredTemplates",
                      arg=None
                      )
        self.transmit(msg)

    def scangateways(self):
        msg = Message(sender=self.name,
                      recipient=self.systemdispatcher,
                      func="listgateways"
                      )
        self.transmit(msg)

    def dumpnodelist(self):
        from pprint import pprint
        pprint(self.nodelist)        

    def scancomponent(self, name, node=""):
        self.logdebug("Scanning component '%s'." % name)
        msg = Message(sender=self.name, recipientnode=node, recipient=name, func="getComponentInfo", arg=None)
        self.transmit(msg)

    def createcomponent(self, name, node=""):
        self.loginfo("Creating component from template '%s'." % name)
        msg = Message(sender=self.name, recipientnode=node, recipient=self.systemregistry, func="createComponent", arg={'templatename': name})
        self.transmit(msg)
        
    def copystring(self, name):
        self.window.clipboard_clear()
        self.window.clipboard_append(name)        

    def callComplexMethod(self, componentname, node, func):
        self.loginfo("Creating function dialog for '%s'@'%s'." % (func, componentname))
        
        componentlist = self.nodelist[node]['componentlist']
        component = componentlist[componentname]
        componentinfo = component["info"]
        methods = componentinfo["methods"]
        methodregister = methods[func]
        
        InputDialog = TkRPCArgDialog(self.window, self.callComplexMethodFinal, componentname, node, func, methodregister)

    def callComplexMethodFinal(self, name, node, func, args):
        self.loginfo("Finally calling func '%s'@'%s' with args '%s'" % (func, name, args))
        msg = Message(sender=self.name, recipientnode=node, recipient=name, func=func, arg=args)
        self.transmit(msg)

    def callSimpleMethod(self, name, node, func):
        self.loginfo("Calling '%s'@'%s'." % (func, name))
        msg = Message(sender=self.name, recipient=name, recipientnode=node, func=func, arg=None)
        self.transmit(msg)

    def transmit(self, msg):
        self.logdebug("Transmitting Message '%s'" % msg)
        self.recordMessage(msg)
        self.send(msg, "outbox")

    def recordMessage(self, msg):
        self.messages.append(msg)
        self.updateMessageLog()

    def updateMessageLog(self):
        loglistbox = self.__MessageLog._listbox
        loglistbox.delete(0, END) # GAH. Addition should be sufficient. CHANGE!

        for msg in sorted(self.messages, key=lambda msg: msg.timestamp):
            loglistbox.insert(END, msg)
            if msg.recipient == self.name:
                loglistbox.itemconfig(END, bg='green', fg='black')
            else:
                loglistbox.itemconfig(END, bg='red', fg='black')

    def editidentity(self):
        self.logerror("Not implemented. Here is a dump of this node's identity:")
        self.loginfo(identity.Systemidentity)
        self.loginfo(identity.SystemUUID)

    def usertransmit(self):
        def send(msg):
            if self.fixsender.get() and msg.sender != self.name:
                self.loginfo("Fixing sender to '%s'." % self.name)
                msg.sender = self.name
            self.loginfo("Transmitting message '%s'" % msg)
            self.transmit(msg)
            self.__FrameInput['bg'] = self.defaultcolors['bg']

        message = self.__EntryInput.get()

        if len(message) <= 1:
            self.logdebug("No message to send entered.")
            return

        try:
            msg = jsonpickle.decode(message)
            send(msg)
        except ValueError as e:
            errmsg = 'Invalid JSON:\n%s' % e
            self.logerror(e)
            if "column" in errmsg:
                col = errmsg.split("(char ")[1].split(")")[0]
                col = col.split(" -")[0]
                self.__EntryInput.icursor(col)
            self.logwarning(errmsg)
            self.__FrameInput['bg'] = 'red'
            #            self.__FrameInput['fg'] = 'yellow'
            messagebox.showinfo("Transmit failed!", errmsg)

        if self.autoclear.get():
            self.clearEntry()

    def rebuildNodeMenu(self):
        NodeMenu = self.__MenuNodes
        NodeMenu.delete(4, END)

        for node in self.nodelist:
            NodeMenu.add_cascade(menu=self.nodelist[node]['menu'], label=node if node != "" else "LOCAL")
            

    def __handleNewNode(self, node):
        if node not in self.nodelist:
            self.loginfo("New node appeared! Hmm.")
        else:       
            self.loginfo("Node rescanned.")
            print self.__MenuNodes   
            
        componentlist = {}
        ComponentMenu = Menu(self.__MenuNodes)
        ComponentMenu.add_command(label="Scan", command=lambda node=node: self.scanregistry(node))
        ComponentMenu.add_command(label="Copy Name", command=lambda node=node: self.copystring(node))
        ComponentMenu.add_separator()

        nodeinfo = {'componentlist': componentlist,
                    'menu': ComponentMenu}
            
        self.nodelist[node] = nodeinfo



    def handleResponse(self, msg):
        self.recordMessage(msg)
        
        def __addComponents(components, node):
            componentlist = self.nodelist[node]['componentlist']
            ComponentMenu = self.nodelist[node]['menu']
            
            for comp in components:
                self.loginfo("Adding component '%s@%s'" % (comp, node))
                if self.autoscan.get() and comp not in componentlist:
                    self.scancomponent(comp, node)
                FuncMenu = Menu(ComponentMenu)
                FuncMenu.add_command(label="Scan", command=lambda (name,node)=(comp, node): self.scancomponent(name, node))
                FuncMenu.add_command(label="Copy Name", command=lambda name=comp: self.copystring(name))
                FuncMenu.add_command(label="Compose...", command=lambda (name,node)=(comp,node): self.composeMessage(name, node))
                FuncMenu.add_separator()
                FuncMenu = Menu(ComponentMenu)

                ComponentMenu.add_cascade(label=comp, menu=FuncMenu)
                componentlist[comp] = {'menu': FuncMenu}
                


        def __handleListRegisteredTemplates(msg):
            MenuTemplates = self.__MenuTemplates
            
            MenuTemplates.delete(0, END)
            
            for template in sorted(msg.arg):
                node = ''
                MenuTemplates.add_command(label=template, command=lambda (name,node)=(template, node): self.createcomponent(name, node))
            self.__MenuTemplates = MenuTemplates
            
        

        def __handleComponentInfo(msg):
            node = msg.sendernode
            if node not in self.nodelist:
                self.logerror('Node unknown')
            else:
                componentlist = self.nodelist[node]['componentlist']
            
            if msg.sender not in componentlist:
                if self.autoscan.get():
                    self.loginfo("Unknown component '%s'. Rescanning registry." % msg.senderid)
                    self.scanregistry(node)
                else:
                    self.loginfo("Unknown component's ('%s') info encountered. Ignoring.")
            else:
                self.logdebug("Got a component's ('%s') RPC info. Parsing." % msg.sender)
                if componentlist[msg.sender] == 'scanned':
                    self.logdebug("Scan from a self-created component returned.")

                component = msg.sender
                result = msg.arg

                componentlist[component]["info"] = result
                
                FuncMenu = componentlist[component]["menu"]
                FuncMenu.delete(5, END)

                mr = result['methods']

                for meth in mr:
                    self.logdebug("Got method '%s'." % meth)
                    if len(mr[meth]['args']) > 0:
                        FuncMenu.add_command(label=meth,
                                             command=lambda (node, name, meth)=(node, component, meth): self.callComplexMethod(name, node, meth))
                    else:
                        FuncMenu.add_command(label=meth,
                                             command=lambda (node, name, meth)=(node, component, meth): self.callSimpleMethod(name, node, meth))

        def __handleCreateComponent(msg):
            node = msg.sendernode
            component = msg.arg
            
            if node not in self.nodelist:
                self.__handleNewNode(node)
                
            componentlist = self.nodelist[node]['componentlist']
            
            __addComponents([component], node)


        def __handleRegisteredComponents(msg):
            node = msg.sendernode
            
            self.loginfo("Got a list of registered components from '%s'. Parsing." % node)
            
            self.__handleNewNode(node)
                     
            # Schema nodelist:
            # {nodeUUID: {'componentlist': componentlist, 'menu': ComponentMenu}
            # Schema componentlist:
            # {componentname: {'funclist': funclist, 'menu': funcmenu}
            # Schema funclist:
            # {func: menu}
            
            components = msg.arg
            
            __addComponents(components, node)
            
            self.rebuildNodeMenu() 

        def __handleGatewayList(msg):
            self.loginfo("Received a list of connected nodes.")
            
            for node in msg.arg:
                self.__handleNewNode(node)
                if self.autoscan.get():
                    self.scanregistry(node)
                
            self.rebuildNodeMenu()
            

        if isinstance(msg, Message):
            if msg.sender == self.systemdispatcher:
                if msg.func == "listgateways":
                    __handleGatewayList(msg)
            if msg.sender == self.systemregistry and not msg.error:
                if msg.func == "createComponent":
                    __handleCreateComponent(msg)
                if msg.func == "listRegisteredComponents":
                    __handleRegisteredComponents(msg)
                elif msg.func == "listRegisteredTemplates":
                    __handleListRegisteredTemplates(msg)
            if msg.func == "getComponentInfo":
                if not msg.error:
                    __handleComponentInfo(msg)
            if msg.func in ("renderArea", "renderCoord"):
                if not msg.error:
                    if self.MapViewer:
                        self.MapViewer.drawMap(msg.arg)
                    else:
                        self.MapViewer = TkMapDialog(msg.arg)
                        self.MapViewer.activate()

    def scanlinetest(self):
        polygon = [[50, 5], [100, 270], [150, 270], [220, 30]]
        ScanlineTestDialog = TkScanlineTestDialog(polygon)

    def quit(self):
        self.logcritical("Shutting down hard.")
        try:
            import cherrypy
            self.loginfo("WebGate running. Stopping cherrypy first.")
            cherrypy.engine.stop()
        except ImportError:
            self.loginfo("WebGate not running. Not killing cherrypy.")
        Scheduler.scheduler.run.stop()

    def setupWindow(self):
        self.logdebug("Setting up TkAdmin GUI")

        Pmw.initialise(self.window)

        self.window.title(self.title)


        ### Menu ###
        self.__FrameMenu = Frame(self.window)
        self.__FrameMenu.pack(anchor='n', side='top')

        self.__Menu = Menu(self.window)
        self.__MenuFile = Menu(self.__Menu)
        self.__MenuEdit = Menu(self.__Menu)
        self.__MenuMessage = Menu(self.__Menu)
        self.__MenuSettings = Menu(self.__Menu)
        self.__MenuSystem = Menu(self.__Menu)
        self.__Menu.add_cascade(menu=self.__MenuFile, label="File")
        self.__Menu.add_cascade(menu=self.__MenuEdit, label="Edit")
        self.__Menu.add_cascade(menu=self.__MenuMessage, label="Message")
        self.__Menu.add_cascade(menu=self.__MenuSettings, label="Settings")
        self.__Menu.add_cascade(menu=self.__MenuSystem, label="System")
        self.window.config(menu=self.__Menu)

        self.__MenuFile.add_command(label="Update Message Log", command=self.updateMessageLog)
        self.__MenuFile.add_command(label="Quit", command=self.quit)

        self.autoscan = BooleanVar()
        self.fixsender = BooleanVar()
        self.autoclear = BooleanVar()
        self.showresponses = BooleanVar()

        self.__MenuMessage.add_command(label="View", command=self.showMessage)
        self.__MenuMessage.add_command(label="Compose New", command=self.composeMessage)

        self.__MenuSettings.add_checkbutton(label="Fix sender", onvalue=True, offvalue=False, variable=self.fixsender)
        self.__MenuSettings.add_checkbutton(label="Autoscan", onvalue=True, offvalue=False, variable=self.autoscan)
        self.__MenuSettings.add_checkbutton(label="Autoclear", onvalue=True, offvalue=False, variable=self.autoclear)
        self.__MenuSettings.add_checkbutton(label="Show responses", onvalue=True, offvalue=False,
                                            variable=self.showresponses)
        
        self.__MenuSystem.add_command(label="View/Edit identity", command=self.editidentity)
        self.__MenuTemplates = Menu(self.__MenuSystem)
        self.__MenuSystem.add_cascade(label='Create Component', menu=self.__MenuTemplates)
        
        self.__MenuNodes = Menu(self.__Menu)
        self.__MenuNodes.add_command(label="Update connected nodes", command=self.scangateways)
        self.__MenuNodes.add_command(label="Scan Local", command=self.scanregistry)
        self.__MenuNodes.add_command(label="Dump Nodelist", command=self.dumpnodelist)

        self.__MenuNodes.add_separator()
        self.__Menu.add_cascade(menu=self.__MenuNodes, label="Nodes")


        ### /Menu ###

        ### Output ###

        self.__FrameOutput = Frame(self.window)
        self.__FrameOutput.pack(side='top', fill='both', expand='yes')

        self.__NotebookOutput = Pmw.NoteBook(self.__FrameOutput)
        self.__NotebookOutput.pack(fill='both', expand=1)

        self.__PageMessages = self.__NotebookOutput.add('Messages')
        self.__PageMap = self.__NotebookOutput.add('Map')
        self.__PageResponses = self.__NotebookOutput.add('Responses')
        #self.__PageLog = self.__NotebookOutput.add('Log') # Needs a loggercomponent and revised logging first

        self.__MessageLog = Pmw.ScrolledListBox(self.__PageMessages)
        self.__MessageLog.pack(expand='yes', fill='both')

        self.__NotebookOutput.tab('Messages').focus_set()

        self.__FrameInput = Frame(self.window, borderwidth=2)
        self.__FrameInput.pack(anchor='s', expand='no', fill='x', side='top')

        self.__FrameStatusbar = Frame(self.window, relief='raised')
        self.__FrameStatusbar.pack(anchor='sw', side='top') # ,fill='x'

        self.__LabelStatus = Label(self.__FrameStatusbar, text='Ready.')
        self.__LabelStatus.pack(anchor='w', expand='yes', side='top') # ,fill='both'

        self.__FrameResponses = Frame(self.__PageResponses, background="yellow")

        self.__FrameResponsesHeader = Frame(self.__FrameResponses)

        self.__LabelResponses = Label(self.__FrameResponsesHeader, text='Responses')
        self.__LabelResponses.pack(anchor='e', side='right', fill='x')

        self.__ButtonClearResponses = Button(self.__FrameResponsesHeader, text='Clear')
        self.__ButtonClearResponses.pack(anchor='w', side='left')

        self.__FrameResponsesHeader.pack(anchor='n', fill='x', side=TOP)

        self.__TextResponses = Pmw.ScrolledText(self.__FrameResponses)
        self.__TextResponses.pack(expand=1, fill='both', side=BOTTOM)

        self.__FrameResponses.pack(expand=1, fill="both")

        #self.__FrameLog = Frame(self.__PageLog)
        #self.__FrameLog.pack(side='left', expand=1, fill="both")

        #self.__FrameLogHeader = Frame(self.__FrameLog)
        #self.__FrameLogHeader.pack(anchor='n',expand='yes', fill='x', side='top')

        #self.__LabelLog = Label(self.__FrameLogHeader,text='Log')
        #self.__LabelLog.pack(anchor='e',side='right', fill='both')

        #self.__ButtonClearLog = Button(self.__FrameLogHeader, text='Clear')
        #self.__ButtonClearLog.pack(anchor='w',side='left')

        #self.__TextLog = Pmw.ScrolledText(self.__FrameLog)
        #self.__TextLog.pack(expand=1,fill='both')

        self.__MapCanvas = Canvas(self.__PageMap)
        self.__MapCanvas.pack(expand=1, fill='both')

        self.__NotebookOutput.setnaturalsize()

        ### /Output ###

        ### Input ###

        self.__FrameInputEntry = Frame(self.__FrameInput)

        self.__EntryInput = Entry(self.__FrameInput)
        self.__EntryInput.pack(expand='yes', fill='both', side='left')

        self.__FrameTransmitButton = Frame(self.__FrameInput)
        self.__FrameTransmitButton.pack(anchor='w', side='left')

        self.__ButtonTransmit = Button(self.__FrameTransmitButton
            , text='Transmit')
        self.__ButtonTransmit.pack(expand='yes', fill='both', side='top')
        self.__FrameClearButton = Frame(self.__FrameInput)
        self.__FrameClearButton.pack(anchor='w', side='left')
        self.__ButtonClear = Button(self.__FrameClearButton, text='Clear')
        self.__ButtonClear.pack(expand='yes', fill='both', side='top')

        self.__FrameInputEntry.pack(side='left')

        ### /Input ###

        ### Bindings ###

        self.__MessageLog._listbox.bind("<Double-Button-1>", self.showMessage)
        self.__ButtonClearResponses.bind('<ButtonRelease-1>'
            , self.__on_ButtonClearResponses_Press)
        self.__ButtonTransmit.bind('<ButtonRelease-1>'
            , self.__on_ButtonTransmit_Release)
        self.__ButtonClear.bind('<ButtonPress-1>', self.__on_ButtonClear_Press)
        self.__EntryInput.bind('<Control-Return>', self.__on_EntryInput_Enter__C)

        self.defaultcolors = {'bg': self.window['bg'], 'fg': self.__EntryInput['fg']}

    def main(self):
        """  
        Main loop. Stub method, reimplement with your own functionality.

        Must regularly call self.tkupdate() to ensure tk event processing happens.
        """

        if self.autoscan.get():
            self.loginfo("Local autoscan initiated.")
            self.scanregistry()

        while not self.isDestroyed():
            yield 1
            if self.dataReady("control"):
                msg = self.recv("control")
                if isinstance(msg, producerFinished) or isinstance(msg, shutdownMicroprocess):
                    self.send(msg, "signal")
                    self.window.destroy()
            if self.dataReady("inbox"):
                msg = self.recv("inbox")
                self.logdebug("Received message '%s'" % msg)
                self.handleRPC(msg)
                if self.showresponses.get():
                    self.__TextResponses.insert(END, "%s\n" % msg)
            self.tkupdate()
Пример #47
0
class Plotter(object):

    def __init__(self, fig):
        self._scope = None
        self.fig = fig
        self.plt = fig.add_subplot(111)
        self.ch1, self.ch2 = self.plt.plot([], [], [], [])
        self.pool = ThreadPool()

        self.ch1b = BooleanVar()
        self.ch1b.set(True)

        self.ch2b = BooleanVar()
        self.ch2b.set(True)

        self._fft = BooleanVar()
        self._fft.set(False)

        self._xy = BooleanVar()
        self._xy.set(False)

        self._USB_voltage = None

    @property
    def scope(self):
        return self._scope

    @scope.setter
    def scope(self, port):
        self._scope = DPScope(port)

    @property
    def both_channels(self):
        return self.ch1b.get() and self.ch2b.get()

    @property
    def xy(self):
        return self._xy.get()

    @property
    def fft(self):
        return self._fft.get()
    
    @property
    def USB_voltage(self):
        if not self._USB_voltage:
            self.scope.adcon_from(0)
            self.scope.set_dac(0, 3000)
            self.scope.set_dac(1, 3000)
            real_dac = sum(self.scope.measure_offset()) / 2
            self.scope.set_dac(0, 0)
            self.scope.set_dac(1, 0)
            nominal_dac = 3 * (1023 / 5.)
            self._USB_voltage = 5. * (nominal_dac / real_dac)

        return self._USB_voltage

    def to_volt(self, adc, gain=1, pregain=1):
        multiplier = (self.USB_voltage/5.) * (20./256) * pregain * gain
        return adc * multiplier

    def read_volt(self):
        return map(self.to_volt, self.scope.read_adc())

    def poll(self):
        self.arm()
        self.plot(*self.parse(self.read()))
        self.scope.abort()
        
    def read(self, nofb=205):
        data = None
        while not data:
            data = self.scope.read_back(nofb)

        return data[1:] # need first byte?

    def parse(self, data):
        ch1 = data
        ch2 = []
        if self.both_channels:
            ch1, ch2 = channels(data)

        if self.fft:
            ch1 = fft(ch1)
            ch2 = fft(ch2)

        if self.xy:
            return ch1, ch2, [], []
        else:
            return [], ch1, [], ch2

    def reader(self, nofb=205):
       while True:
           yield self.read(nofb)

    def arm(self):
        if self.both_channels:
            self.scope.arm(0)
        else:
            self.scope.arm_fft(0, self.ch1b.get() or self.ch2b.get()*2)

    def plot(self, x1=[], y1=[], x2=[], y2=[]):
        if len(y1) and not len(x1):
            x1 = range(len(y1))

        if len(y2) and not len(x2):
            x2 = range(len(y2))

        self.ch1.set_data(x1, y1)
        self.ch2.set_data(x2, y2)

        self.plt.relim()
        self.plt.autoscale_view()
        self.fig.canvas.draw()
class mSim(Frame):
  
    def __init__(self, parent):
        
        self.serialStatus = False

        #create variables
        self.startmotor = BooleanVar()
        self.logstate = BooleanVar()
        self.loggedData = []
        self.throttlevar = StringVar()
        self.throttleval = IntVar()

        #default values
        self.throttlevar.set("0%")
        self.throttleval.set(0)

        #base frame init
        Frame.__init__(self, parent)   
        self.parent = parent
        self.initUI()
        self.centerWindow()

        self.PERIOD_LENGTH_Log = 100 #milliseconds
        self.PERIOD_LENGTH_Scan = 1000 #milliseconds
        self.PERIOD_LENGTH_Refresh = 300 #milliseconds

        self.parent.after(0, self.runScan)
        self.parent.after(0, self.runLog)
        self.parent.after(0, self.runRefresh)

    def runScan(self):
        #serial port scanning function
        """ Lists serial port names

            :raises EnvironmentError:
                On unsupported or unknown platforms
            :returns:
                A list of the serial ports available on the system
        """
        if sys.platform.startswith('win'):
            ports = ['COM%s' % (i + 1) for i in range(256)]
        elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
            # this excludes your current terminal "/dev/tty"
            ports = glob.glob('/dev/tty[A-Za-z]*')
        elif sys.platform.startswith('darwin'):
            ports = glob.glob('/dev/tty.*')
        else:
            raise EnvironmentError('Unsupported platform')

        result = []
        for port in ports:
            try:
                s = serial.Serial(port)
                s.close()
                result.append(port)
            except (OSError, serial.SerialException):
                pass
        menu = self.drop["menu"]
        menu.delete(0, "end")
        menu.add_command(label="None", command=lambda value="None": self.selected_s_Port.set(value))
        for string in result:
            menu.add_command(label=string, command=lambda value=string: self.selected_s_Port.set(value))
                
        self.parent.after(self.PERIOD_LENGTH_Scan, self.runScan)

    def runLog(self):
        #this will probably not work since you're not appending to 
        if (self.logstate.get() == True) and (self.serialStatus == True): #logging data                                        
                    data = dict(zip(*[self.SC.dict.keys(), zip(*self.SC.dict.values())[-1]])) 
                    if 'l' not in locals():         # a dictionary with a deque of the recent data for each message type -Austin
                        l = []
                    if self.loggedData == []: #if empty add titles
                        l=[data.keys()]
                    data = data.values()
                    
                    self.loggedData.append(data)
                    
        self.parent.after(self.PERIOD_LENGTH_Log, self.runLog)

    def runRefresh(self):
        
        #Refresh figures function
        self.a.clear()
        self.b.clear()
        self.c.clear()
        self.d.clear()
        
        if not self.serialStatus:
            #TODO: Put SerialComm data buffer here v . Timestamps (from python?) on x axis, values on y-axis
            #Helpful Info: plot([xvals],[yvals])
            self.a.plot([0],[0])
            self.b.plot([0],[0])
            self.c.plot([0],[0])
            self.d.plot([0],[0])
        else:
            self.SC.processData(5) # This param is the number of bytes to try for a message -Austin
            timestamps = [val / 1000.0  if val != None else val for val in self.SC.dict['Timestamp']]
            self.a.plot(timestamps, self.SC.dict['Thrust'])
            self.b.plot(timestamps, self.SC.dict['Rot Speed'])
            self.c.plot(timestamps, self.SC.dict['Current'])
            self.d.plot(timestamps, self.SC.dict['Voltage'])

        #set labels for graphs (could make automatic later)
        self.a.set_xlabel('time (s)')
        self.a.set_ylabel('Thrust (N)')
        self.b.set_xlabel('time (s)')
        self.b.set_ylabel('RPM')
        self.c.set_xlabel('time (s)')
        self.c.set_ylabel('Current (A)')
        self.d.set_xlabel('time (s)')
        self.d.set_ylabel('Voltage (V)')

        #try drawing the canvas
        try:
            self.canvas.draw()
        except:
            pass #just ignore it, you'll do better next time
        
        self.parent.after(self.PERIOD_LENGTH_Refresh, self.runRefresh)

    def centerWindow(self):
      
        w = 900 #eh, who needs scaling anyways
        h = 600

        sw = self.parent.winfo_screenwidth()
        sh = self.parent.winfo_screenheight()
        
        x = (sw - w)/2
        y = (sh - h)/2
        self.parent.geometry('%dx%d+%d+%d' % (w, h, x, y))
        

    def initUI(self):

        #Parent Frame
        self.parent.title("Test Stand Control Panel")
        self.style = Style()
        self.style.theme_use("default")

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


        # Frame 1 (top)
        frame1 = Frame(self)
        frame1.pack(fill=X, expand=1)

            #Start motor button
        startButton = Button(frame1, text="Start Motor",
            command=self.startMotor)
        startButton.pack(side=LEFT, padx=5, pady=5)     


            #Throttle slider
        lbl1 = Label(frame1, text="Throttle (0-100):", width=14)
        lbl1.pack(side=LEFT, padx=5, pady=5)
        
        self.scale = Scale(frame1, from_=0, to=100, 
            command=self.onScaleThrottle)
        self.scale.pack(side=LEFT, padx=15)
        
        self.label = Label(frame1, text="throttle", textvariable=self.throttlevar, width=5)        
        self.label.pack(side=LEFT)

            #Throttlesweep checkbutton
        self.autovar = BooleanVar()
        cb = Checkbutton(frame1, text="Throttle Sweep",
            variable=self.autovar, command=self.onClickAuto)
        cb.pack(side=LEFT, padx=15)

            #Com port selection field
        droplbl = Label(frame1, text="Serial Port:", width=10)
        droplbl.pack(side=LEFT, padx=5, pady=5)
        self.selected_s_Port = StringVar()
        self.s_Ports = []
        self.drop = OptionMenu(frame1,self.selected_s_Port,"None",*self.s_Ports)
        self.drop.pack(side=LEFT, padx=5)

            #baudrate selection field (disabled)
##       drop2lbl = Label(frame1, text="Baudrate:", width=9)
##        drop2lbl.pack(side=LEFT, padx=5, pady=5)
##        self.baudrate = StringVar()
##        baudrates = [9600, 19200, 38400, 57600, 115200]
##        drop2 = OptionMenu(frame1,self.baudrate,*baudrates)
##        drop2.pack(side=LEFT, padx=5)

            #Start serial button
        comsButton = Button(frame1, text="Start Serial",
            command=self.startSerial)
        comsButton.pack(side=LEFT, padx=5, pady=5)

            #Stop serial button
        comsStopButton = Button(frame1, text="Stop Serial",
            command=self.stopSerial)
        comsStopButton.pack(side=LEFT, padx=5, pady=5)

        # Frame 2 (second line)
        frame2 = Frame(self)
        frame2.pack(fill=X, expand=1)

            #Amperage entry
        lbl2 = Label(frame2, text="Max Motor Current (A):", width=21)
        lbl2.pack(side=LEFT, padx=5, pady=5)
        
        self.MaxA_Entry = Entry(frame2)
        self.MaxA_Entry.pack(side="left", fill=X, padx=5, expand=False)
        self.MaxA_Entry.insert(0, 10)

            #Voltage entry
        lbl3 = Label(frame2, text="Max Motor Voltage (V):", width=20)
        lbl3.pack(side=LEFT, padx=5, pady=5)
        
        self.MaxV_Entry = Entry(frame2)
        self.MaxV_Entry.pack(side="left", fill=X, padx=5, expand=False)
        self.MaxV_Entry.insert(0, 14)

            #Update button
        updateButton = Button(frame2, text="Update Values",
            command=self.updateValues)
        updateButton.pack(side=LEFT, padx=5, pady=5)
        
        # Graph Frame
        framegraph = Frame(self)
        framegraph.pack(fill=X, expand=1)

            #Init figures
        f = Figure(figsize=(4,4), dpi=100)
        self.a = f.add_subplot(2, 2, 1)
        self.d = f.add_subplot(2, 2, 4)
        self.c = f.add_subplot(2, 2, 3)
        self.b = f.add_subplot(2, 2, 2)
        
        f.set_tight_layout(True)

        self.canvas = matplotlib.backends.backend_tkagg.FigureCanvasTkAgg(f, master=self)
        self.canvas.show()
        self.canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)

            #Display Toolbar
        toolbar = NavigationToolbar2TkAgg(self.canvas, framegraph)
        toolbar.update()
        self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
        
        # Frame 0 (Bottom text)
        frame0 = Frame(self)
        frame0.pack(side="bottom", fill="x", expand=1)

            #Display text (allows to give user information)
        self.textboxvar = StringVar()
        self.info = Label(frame0, textvariable=self.textboxvar)
        self.info.pack(side=LEFT, padx=5, pady=5)

        # Button Frame (large buttons, near bottom)
        s = Style() #has its own style
        s.configure('My.TFrame',background='#f7edc3') #fancy colors
        framered = Frame(self, style='My.TFrame')
        framered.pack(side="bottom", fill="x", expand=1)
        #used the tk instead of ttk library for this, allows font and color mods

            #Save Button
        self.saveButton = tk.Button(framered, text="Save Data", bg='green', font=('Arial',20,'bold'),
            command=self.saveData)
        self.saveButton.pack(side="left", padx=5, pady=5)

            #Log button
        self.logButton = tk.Button(framered, text="Start Data Logging", bg="blue", font=('Arial',20,'bold'),
            command=self.logData)
        self.logButton.pack(side="left", padx=5, pady=5)

            #Stop button
        self.stopButton = tk.Button(framered, text="Stop Motor", bg='red', font=('Arial',20,'bold'),
            command=self.stopMotor)
        self.stopButton.pack(side="right", padx=5, pady=5)
         

    #Button behavior functions (hopefully self-explanatory)
         
    def onClickAuto(self): #for the throttle sweep (should rename)
        pass #(I guess I can make it do something if I want)

    def MaxA(self):
        #self.MaxA_Entry.get()
        pass
            
    def MaxV(self):
        pass #not sure why these are even functions

    def onScaleThrottle(self, val):
        throttle = str(int(float(val)))
        self.throttlevar.set(throttle + "%")
        self.throttleval.set(throttle)
        try:
            self.SC.sendThrottleSetting(self.throttleval.get())
        except:
            self.textboxvar.set("Something went wrong, is serial connected?")

    def startSerial(self):
        COM_Port = self.selected_s_Port.get()
        #print type(COM_Port)
        #print COM_Port
        if "COM" in COM_Port:
            self.textboxvar.set("Starting Serial on port " + self.selected_s_Port.get())
            #serialThread = Thread(target=SerialComm, args=(COM_Port)) #probably want to pass the self.vars?
            #serialThread.start()
            #threads.append(serialThread)
            try:
                self.ser = serial.Serial(self.selected_s_Port.get(), 9600) #Baud rate = 9600
                self.SC = SerialComm(self.ser, 50) #Dict deques' maxlength = 50
                
                for key in self.SC.dict.keys(): #Initialize dict deques with values so no length errors -Austin
                    for i in range(self.SC.dict[key].maxlen):
                        self.SC.dict[key].append(None)
                
                self.serialStatus = True
            except Exception,e: #if the com port is wrong dont start serial
                print str(e)
                self.textboxvar.set("Error starting serial on port " + self.selected_s_Port.get() + ": " + str(e))
        else:
class FindReplacePanel(PluginPanel):
    name = 'Text Find & Replace'
    title = _("Text Find & Replace")

    def init(self, master):
        PluginPanel.init(self, master)
        top = self.panel

        top = TFrame(top, borderwidth=2, style='FlatFrame')
        top.pack(side=TOP, expand=1, fill=X)

        button_frame = TFrame(top, borderwidth=2, style='FlatFrame')
        button_frame.pack(side=BOTTOM, fill=BOTH, expand=1)

        button = TButton(button_frame, text=_('Apply'), command=self.replace)
        button.pack(side=TOP)

        #----------------------------------------------------------
        main_frame = TFrame(top, style='FlatFrame', borderwidth=3)
        main_frame.pack(side=TOP, fill=X)

        self.find_var = StringVar(top)
        self.find_var.set('')
        findField = TEntryExt(main_frame, textvariable=self.find_var)
        findField.pack(side=RIGHT)

        label = TLabel(main_frame, style='FlatLabel', text=_("Find:") + " ")
        label.pack(side=RIGHT, anchor=E)
        #---------------------------------------------------------
        main_frame = TFrame(top, style='FlatFrame', borderwidth=3)
        main_frame.pack(side=TOP, fill=X)

        self.replace_var = StringVar(top)
        self.replace_var.set('')
        replaceField = TEntryExt(main_frame, textvariable=self.replace_var)
        replaceField.pack(side=RIGHT)

        label = TLabel(main_frame,
                       style='FlatLabel',
                       text=_("Replace to:") + " ")
        label.pack(side=RIGHT, anchor=E)

        main_frame = TFrame(top, style='FlatFrame', borderwidth=3)
        main_frame.pack(side=TOP)
        #---------------------------------------------------------
        label = TLabel(top,
                       text=" " + _("Parameters") + " ",
                       style="FlatLabel")
        label.pack()

        parametersFrameLabel = TLabelframe(top,
                                           labelwidget=label,
                                           style='Labelframe',
                                           borderwidth=4)

        parametersFrameLabel.pack(side=TOP, fill=X, pady=4, padx=4)

        parametersFrame = TFrame(parametersFrameLabel, style='FlatFrame')

        self.var_case_sensitive = BooleanVar(top)
        self.var_case_sensitive.set(False)
        self.case_sensitive_check = TCheckbutton(
            parametersFrame,
            text=_("Case sensitive"),
            variable=self.var_case_sensitive)
        self.case_sensitive_check.pack(side=TOP, anchor=W, padx=5)

        self.var_whole_word = BooleanVar(top)
        self.var_whole_word.set(False)
        self.whole_word_check = TCheckbutton(parametersFrame,
                                             text=_("Whole word"),
                                             variable=self.var_whole_word)
        self.whole_word_check.pack(side=TOP, anchor=W, padx=5)

        self.var_regexp = BooleanVar(top)
        self.var_regexp.set(False)
        self.regexpCheck = TCheckbutton(parametersFrame,
                                        text=_("RegExp search"),
                                        variable=self.var_regexp,
                                        command=self.disable_enable_action)
        self.regexpCheck.pack(side=TOP, anchor=W, padx=5)

        parametersFrame.pack(side=TOP, fill=X, pady=2)
################################################################

    def replace_text(self, objects, toReplace, replaceTo):
        for object in objects:
            if object.is_Text:

                if self.var_regexp.get():
                    if self.var_case_sensitive.get():
                        p = re.compile(toReplace)
                    else:
                        p = re.compile(toReplace, re.I)
                    text = p.sub(replaceTo, object.text)
                    app.mw.document.SelectObject(object)
                    app.mw.document.CallObjectMethod(object.__class__,
                                                     _('Text Replace'),
                                                     'SetText', text)
                    continue

                if self.var_whole_word.get():
                    if not self.var_case_sensitive.get():
                        if object.text.lower() == toReplace.lower():
                            text = replaceTo
                            app.mw.document.SelectObject(object)
                            app.mw.document.CallObjectMethod(
                                object.__class__, _('Text Replace'), 'SetText',
                                text)
                    else:
                        if object.text == toReplace:
                            text = replaceTo
                            app.mw.document.SelectObject(object)
                            app.mw.document.CallObjectMethod(
                                object.__class__, _('Text Replace'), 'SetText',
                                text)

                else:
                    if object.text.lower().find(toReplace.lower(), 0,
                                                len(object.text)) != -1:
                        if not self.var_case_sensitive.get():
                            text = object.text.lower().replace(
                                toReplace.lower(), replaceTo)
                        else:
                            text = object.text.replace(toReplace, replaceTo)
                        app.mw.document.SelectObject(object)
                        app.mw.document.CallObjectMethod(
                            object.__class__, _('Text Replace'), 'SetText',
                            text)

            if object.is_Group:
                self.replace_text(object.objects)
################################################################

    def replace(self):
        textObjects = []
        textToReplace = self.find_var.get().decode('utf-8')
        replaceTo = self.replace_var.get().decode('utf-8')

        for layer in app.mw.document.layers:
            self.replace_text(layer.objects, textToReplace, replaceTo)
        app.mw.canvas.ForceRedraw()
################################################################

    def disable_enable_action(self):
        if self.var_regexp.get():
            self.whole_word_check['state'] = DISABLED
        else:
            self.whole_word_check['state'] = NORMAL
################################################################

    def whole_word_action(self):
        pass
Пример #50
0
class Example(Frame):

	def __init__(self, parent):
		Frame.__init__(self, parent)
		self.parent = parent
		self.initUI()
		self.centerUI(w=520,h=270)

	def initUI(self):

		self.parent.title("FIND SPE VALUE")
		self.pack(fill=BOTH, expand=True)

		self.columnconfigure(0, weight=1)
		#self.rowconfigure(0, weight=1)
		# weight attibute is used to make them growable

		self.graph_cb  = BooleanVar()
		self.bins      = IntVar()
		self.path      = StringVar()
		self.n_files   = IntVar()
		self.start_s   = IntVar()
		self.end_s     = IntVar()
		self.guess     = IntVar()


		search = Image.open("next_logo.jpg")
		search_temp = search.resize((160, 200), Image.ANTIALIAS)
		search_aux = ImageTk.PhotoImage(search_temp)
		label1 = Label(self, image=search_aux)
		label1.image = search_aux
		label1.grid(row=0, column=0,
				columnspan=10, rowspan=10, sticky=E+W+S+N)


		#Number of Files and Bins. Spin Box
		self.n_files.set("2000")
		sb1 = Spinbox(self, from_=1, to=10000,
				  width=6, textvariable=self.n_files)
		sb1.grid(row=1,column=4, sticky=W)
		sb1_label = Label(self, text="Files")
		sb1_label.grid(row=1,column=3, padx=5, sticky=E)

		self.bins.set("50")
		sb2 = Spinbox(self, from_=10, to=200,
				  width=6, textvariable=self.bins)
		sb2.grid(row=1,column=6, sticky=W)
		sb2_label = Label(self, text="Hist. Bins")
		sb2_label.grid(row=1,column=5, padx=5, sticky=E)

		# INTEGRATION LIMITS
		Integration_label = Label(self, text="INTEGRATION",
		                          font = "Verdana 12 bold")
		Integration_label.grid(row=3,column=4,
						padx=5,
						columnspan = 2)
		self.start_s.set("1732")
		sb3 = Spinbox(self, from_=1, to=10000,
				  width=6, textvariable=self.start_s)
		sb3.grid(row=4,column=4, sticky=W)
		sb3_label = Label(self, text="StartPoint")
		sb3_label.grid(row=4,column=3, padx=5, sticky=E)

		self.end_s.set("1752")
		sb4 = Spinbox(self, from_=1, to=10000,
				  width=6, textvariable=self.end_s)
		sb4.grid(row=4,column=6, sticky=W)
		sb4_label = Label(self, text="EndPoint")
		sb4_label.grid(row=4,column=5, padx=5, sticky=E)
		sb4_label = Label(self, text="")
		sb4_label.grid(row=4,column=7, padx=5, sticky=E)

		# FITTING PARAMETERS
		Integration_label = Label(self, text="FITTING",
		                          font = "Verdana 12 bold")
		Integration_label.grid(row=6,column=4,
						padx=5,
						columnspan = 2)
		self.guess.set("-20")
		sb5 = Spinbox(self, from_=-50, to=-1,
				  width=6, textvariable=self.guess)
		sb5.grid(row=7,column=4, sticky=W)
		sb5_label = Label(self, text="SPE guess")
		sb5_label.grid(row=7,column=5, padx=5, sticky=W)

		#Check buttons
		cb1 = Checkbutton(self, text="MultiGraph Output", variable=self.graph_cb					)
		cb1.select()
		cb1.grid(row=7,column=6, sticky=W)


		#Text Box
		#self.path.set("F:/DATOS_DAC/spe_1230/2046/pmt_0_trace_evt_")
		self.path.set("spe_1230_2046.h5.z")
		e1 = Entry(self, textvariable=self.path, width=45)
		e1.grid(row=10,column=3, sticky=W, columnspan=10, padx=10, pady=5)
		e1_label = Label(self, text="DataSet path (including name file)")
		e1_label.grid(row=9,column=3,sticky=W, columnspan=10, padx=10)


		# Main buttons
		obtn = Button(self, text="GO!!", command=self.SPE_f)
		obtn.grid(row=14, column=5, sticky=E, pady=5)

		cbtn = Button(self, text="Quit", command=self.quit)
		cbtn.grid(row=14, column=6, sticky=E, pady=5)

		hbtn = Button(self, text="Help")
		hbtn.grid(row=14, column=0, sticky=W, pady=5)

	def SPE_f(self):

		global a

		if (self.graph_cb.get()==True):
			b=a
			a=a+1
		else:
			b=0

		SPE.find_SPE_h5(base_path=self.path.get(),
				  n_files=self.n_files.get(),
				  start=self.start_s.get(),
				  end=self.end_s.get(),
				  bins=self.bins.get(),
				  guess=self.guess.get(),
				  n_figure=b)


	def centerUI(self,w,h):
		sw = self.parent.winfo_screenwidth()
		sh = self.parent.winfo_screenheight()
		x  = (sw-w)/2
		y  = (sh-h)/2
		self.parent.geometry('%dx%d+%d+%d' % (w,h,x,y))
Пример #51
0
class Tagging(Frame):
  
    def __init__(self, parent, options):
        if options == None:
            options = {}            
        DefaultOptions = {'colorspace':'RGB', 'K':6, 'km_init':'first', 'verbose':False, 'single_thr':0.6, 'metric':'basic'}
        for op in DefaultOptions:
            if not op in options:
                options[op] = DefaultOptions[op]
        self.options = options
        self.K_ant = 0        
        self.num_im=-1
        Frame.__init__(self, parent)   
        self.parent = parent
        self.parent.title("TAGGING")        

        self.F1 = Frame(parent, width=150,borderwidth=2,relief=GROOVE)
        self.F2 = Frame(parent, width=150,borderwidth=2,relief=GROOVE)
        self.F3 = Frame(parent)
        self.F4 = Frame(parent,borderwidth=2,relief=GROOVE)
        self.F5 = Frame(parent,borderwidth=2,relief=GROOVE)
        self.F1.pack(side=LEFT, fill=Y, pady = 4, padx=4)
        self.F2.pack(side=LEFT, fill=Y, pady = 4)
        self.F3.pack(side=TOP, expand=True, fill=BOTH, pady = 4, padx = 4)
        self.F4.pack(side=TOP, fill=BOTH,  expand=0, padx = 4)
        self.F5.pack(side=BOTTOM, fill=BOTH,  expand=0, pady = 4, padx = 4)
        self.F1.pack_propagate(0)
        self.F2.pack_propagate(0)
        self.F3.pack_propagate(0)

        lbl = Label(self.F1, text="Groundtruth")
        lbl.grid(row=0,sticky=W)
        Frame(self.F1,borderwidth=1,relief=GROOVE,height=2).grid(row=1,sticky=W)

        lbl = Label(self.F2, text="Detected")
        lbl.grid(row=0,sticky=W, columnspan=2)
        Frame(self.F2,borderwidth=1,relief=GROOVE,height=2).grid(row=1,sticky=W, columnspan=2)
        
        self.filename = Button(self.F3,text="filename",command=self.ChooseFile)
        self.filename.pack(side=TOP,expand=0)

#        #matplotlib setup
#        plt.ion()
        self.figure=plt.figure(figsize=(2,2), frameon=False)
        self.axes=self.figure.add_subplot(111)
        self.Canvas=FigureCanvasTkAgg(self.figure, master=self.F3)
#        self.Canvas.show()        
        self.Canvas.get_tk_widget().pack(side=TOP,fill=BOTH,expand=1 )
        plt.axis('off')


        b = Button(self.F4,text=" <<<10 ",command=self.PreviousFast)
        b.pack(side=LEFT, padx=(20,2), pady=3)
        b = Button(self.F4,text=" <<1 ",command=self.Previous)
        b.pack(side=LEFT, pady=3)
        self.im_name = Button(self.F4,text="image",bd=0, command=self.Results)
        self.im_name.pack(side=LEFT, expand=True)        
        b = Button(self.F4,text=" 1>> ",command=self.Next)
        b.pack(side=LEFT)
        b = Button(self.F4,text=" 10>>> ",command=self.NextFast)
        b.pack(side=LEFT, padx=(2,20))

        F51 = Frame(self.F5)
        F52 = Frame(self.F5)
        F53 = Frame(self.F5)
        F51.pack(fill=BOTH, expand=1, side=LEFT)
        Frame(self.F5,borderwidth=1,relief=GROOVE,width=2).pack(side=LEFT, fill=Y)
        F52.pack(fill=BOTH, expand=1, side=LEFT)
        Frame(self.F5,borderwidth=1,relief=GROOVE,width=2).pack(side=LEFT, fill=Y)
        F53.pack(fill=BOTH, expand=1, side=LEFT)

        Label(F51, text="Color space").pack()
        Frame(F51,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
        Label(F52, text="K-Means").pack()
        Frame(F52,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
        Label(F53, text="Labelling").pack()
        Frame(F53,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
        
        self.ColorMode = StringVar()
        self.ColorMode.set(self.options[COLORSSPACE['key']]) 
        for text, mode in COLORSSPACE['options_gui']:
            b = Radiobutton(F51, text=text, variable=self.ColorMode, value=mode, command=self.Results)
            b.pack(anchor=W)        

        Frame(F51,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
        Label(F51, text="Grouping", padx=20).pack()
        Frame(F51,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
        self.Group = BooleanVar()
        self.Group.set(True)
        b = Checkbutton(F51, text='Group same label colors', variable=self.Group, command=self.Results)
        b.pack(anchor=W)
        

        F521 = Frame(F52)
        F522 = Frame(F52)

        F521.pack(fill=BOTH)
        F522.pack(fill=BOTH)
#        F523 = Frame(F52)
#        F523.pack(fill=BOTH)

        self.K = StringVar()
        self.K.set(self.options['K'])
#        f = Frame(F52)
#        f.pack(side=TOP, fill=BOTH,  expand=0)
        Label(F521, text="K : ").pack(side=LEFT)
        Entry(F521, textvariable=self.K, width=3, justify=CENTER).pack(side=LEFT, padx=4)
#        Label(F52, text="Init", padx=20).pack(anchor=W)
#        Frame(F521,borderwidth=1,relief=GROOVE,width=2).pack(side=RIGHT, fill=Y, padx=2)

        self.Fitting = StringVar()
        self.Fitting.set(self.options[FITTING['key']]) 
#        f = Frame(F52)
#        f.pack(side=RIGHT, fill=BOTH,  expand=0)
        for text, mode in FITTING['options_gui']:
            b = Radiobutton(F521, text=text, variable=self.Fitting, value=mode, command=self.Results)
            b.pack(anchor=W,padx=4)        
            
        Frame(F522,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
        Label(F522, text="Centroid Init", padx=20).pack()
        Frame(F522,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
#        IM = [('First points','first'),('Randomize', 'random'),('Distribtued','distributed'),('Other','Other')]

        self.KMInit = StringVar()
        self.KMInit.set(self.options[CENTROIDSINIT['key']]) 
        for text, mode in CENTROIDSINIT['options_gui']:
            b = Radiobutton(F522, text=text, variable=self.KMInit, value=mode, command=self.Results)
            b.pack(anchor=W)        

        
        self.Thr = StringVar()
        self.Thr.set(self.options['single_thr'])
        f = Frame(F53)
        f.pack(side=TOP, fill=BOTH,  expand=0)
        Label(f, text="single\nbasic   >\ncolor", justify=LEFT).pack(side=LEFT)
        Entry(f, textvariable=self.Thr, width=4, justify=CENTER).pack(side=LEFT)
#        self.Synonymous = BooleanVar()
#        self.Synonymous.set(self.options['synonyms'])
#        b = Checkbutton(F53, text='Synonymous', variable=self.Synonymous, command=self.Results)
#        b.pack(anchor=W)
        
        Frame(F53,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
        Label(F53, text="Similarity Metric", padx=2).pack()
        Frame(F53,borderwidth=1,relief=GROOVE,height=2).pack(fill=X)
        self.Metric = StringVar()
        self.Metric.set(self.options[SIMILARITY['key']]) 
        for text, mode in SIMILARITY['options_gui']:
            b = Radiobutton(F53, text=text, variable=self.Metric, value=mode, command=self.Results)
            b.pack(anchor=W)        
            
        
    def ChooseFile(self):
        filename = tkFileDialog.askopenfilename(initialdir='Images', filetypes=[("Text files","*.txt")])
        if filename =='':
            return
        self.ImageFolder = os.path.dirname(filename)
        self.filename['text'] = os.path.basename(filename) 
        self.GT = lb.loadGT(filename)
        self.num_im = 0
        self.Results()

    def Previous(self):
        self.num_im -= 1
        if self.num_im<-1:
            self.num_im=0
        elif self.num_im<0:
            self.num_im=0
            return            
        self.Results()       

    def PreviousFast(self):
        self.num_im -= 10
        if self.num_im<0:
            self.num_im=0
        self.Results()       

    def Next(self):
        self.num_im += 1
        if self.num_im>=len(self.GT):
            self.num_im=len(self.GT)-1
            return
        self.Results()       

    def NextFast(self):
        self.num_im += 10
        if self.num_im>=len(self.GT):
            self.num_im=len(self.GT)-1
        self.Results()       

    def Results(self):        
        if self.num_im<0 or self.num_im>=len(self.GT):
            return
        #self.parent.config(cursor="wait")
        self.parent.update()
        
        self.im_name['text'] = self.GT[self.num_im][0]
        im = io.imread(self.ImageFolder+"/"+self.GT[self.num_im][0])    
        
        self.options['K']          = int(self.K.get())
        self.options['single_thr'] = float(self.Thr.get())
#        self.options['synonyms']   = self.Synonymous.get()
        self.options[COLORSSPACE['key']] = self.ColorMode.get()
        self.options[CENTROIDSINIT['key']]    = self.KMInit.get()
        self.options[SIMILARITY['key']]     = self.Metric.get()
        self.options[FITTING['key']]    = self.Fitting.get()

        if self.options['fitting'] != 'None':
            if self.K_ant==0:
                self.K_ant = self.options['K']
            self.options['K'] = 0
            self.K.set(0)
            pass
        else:
            if self.K_ant>0:
                self.K.set(self.K_ant)
                self.options['K'] = self.K_ant
                self.K_ant = 0

        self.labels, self.which, self.km = lb.processImage(im, self.options)
        if self.options['K'] == 0:
            self.K.set(self.km.K)

        if not self.Group.get():
            self.labels = [w for ww in [[w]*len(z) for w,z in zip(self.labels,self.which)] for w in ww]
            self.which = [[w] for ww in self.which for w in ww]
        
 
       # get percentages for every label
        percent = np.zeros((len(self.which),1))
        for i,w in enumerate(self.which):
            for k in w:
                percent[i] += np.sum(self.km.clusters==k)
        percent = percent*100/self.km.clusters.size

       # get color for every label from image
        
        sh = im.shape;
        im = np.reshape(im, (-1, im.shape[2]))
        colors = np.zeros((len(self.which),3))
        for i,w in enumerate(self.which):
            for k in w:
                colors[i] += np.mean(im[self.km.clusters==k,:],0)
            colors[i] /= len(w)
        im = np.reshape(im, sh)
        self.im = im
        
        self.CBgt = self.CreateCheckList(self.F1, self.GT[self.num_im][1])
        self.CBdetected = self.CreateCheckList(self.F2, self.labels, percent, colors)
        l = Label(self.F2,text='similarity: '+'%.2f' % (lb.similarityMetric(self.labels, self.GT[self.num_im][1], self.options)*100)+'%')
        l.grid(columnspan=2,sticky=W+E+N+S)
        self.F2.grid_rowconfigure(self.F2.grid_size()[1]-1, weight=1)

        self.CheckLabels()
        #self.parent.config(cursor="")
        self.parent.update()
        self.Segment()
        
#        self.ShowImage(im)
        
    def Segment(self):
        all_widgetes = self.F2.winfo_children()
        cb = [w for w in all_widgetes if w.winfo_class() == 'Checkbutton']
        lab_colors = np.zeros((len(cb),3))
        for i,c in enumerate(cb):
            lab_colors[i,0] = int(c.cget('bg')[1:3], 16)
            lab_colors[i,1] = int(c.cget('bg')[3:5], 16)
            lab_colors[i,2] = int(c.cget('bg')[5:7], 16)
        ims = np.empty_like(self.im)
        ims = np.reshape(ims, (-1, ims.shape[2]))
        for i,w in enumerate(self.which):
            for k in w:
                ims[self.km.clusters==k]=lab_colors[i]
        ims = np.reshape(ims, self.im.shape)
        self.ShowImage(np.hstack((ims,self.im)))
            
    def ShowImage(self,im):
        self.axes.imshow(im)
        plt.axis('off')
        self.Canvas.draw()        
        
    def CreateCheckList(self, frame, labels, values=None, colors=None):
       
        all_widgetes = [w for w in frame.winfo_children() if w.winfo_class() == 'Checkbutton']
        for w in all_widgetes:
            w.destroy()
        all_widgetes = [w for w in frame.winfo_children() if w.winfo_class() == 'Label']
        for w in all_widgetes[1:]:
            w.destroy()
        var = []
        if values is not None:
            add_text = ["%5.1f" % (values[i]) +'%' for i in range(len(values))]

        for i in range(len(labels)):
            var.append(BooleanVar())
            
            fgc = "black"
            if colors is not None:
                mycolor = '#%02x%02x%02x' % (colors[i,0], colors[i,1], colors[i,2])
                if (colors[i,0]+colors[i,1]+colors[i,2])/3/255<=0.5:
                    fgc = "#FFFFFF"
            else:
                mycolor = frame.cget('bg')
                
            cb = Checkbutton(frame, text=labels[i], state=DISABLED, variable=var[i], bg=mycolor, disabledforeground=fgc, anchor=W)
#            cb.pack(anchor=W, fill=X, padx=2)
            cb.grid(row=i+2,column=0,sticky=W+E)
            if values is not None:
                cb = Label(frame, text=add_text[i], bg=mycolor, fg=fgc, anchor=E)
                cb.grid(row=i+2,column=1,sticky=W+E+N+S)
            frame.grid_rowconfigure(i+2, weight=0)
                
        
        return var

    def CheckLabels(self):
        for i in range(len(self.labels)):
            if self.labels[i] in self.GT[self.num_im][1]:
                self.CBdetected[i].set(True)

        for i in range(len(self.GT[self.num_im][1])):
            if self.GT[self.num_im][1][i] in self.labels:
                self.CBgt[i].set(True)
Пример #52
0
class SearchEngine:
    """Handles searching a text widget for Find, Replace, and Grep."""

    def __init__(self, root):
        """Initialize Variables that save search state.
        
        The dialogs bind these to the UI elements present in the dialogs.
        """
        self.root = root
        self.patvar = StringVar(root, '')
        self.revar = BooleanVar(root, False)
        self.casevar = BooleanVar(root, False)
        self.wordvar = BooleanVar(root, False)
        self.wrapvar = BooleanVar(root, True)
        self.backvar = BooleanVar(root, False)

    def getpat(self):
        return self.patvar.get()

    def setpat(self, pat):
        self.patvar.set(pat)

    def isre(self):
        return self.revar.get()

    def iscase(self):
        return self.casevar.get()

    def isword(self):
        return self.wordvar.get()

    def iswrap(self):
        return self.wrapvar.get()

    def isback(self):
        return self.backvar.get()

    def setcookedpat(self, pat):
        """Set pattern after escaping if re."""
        if self.isre():
            pat = re.escape(pat)
        self.setpat(pat)

    def getcookedpat(self):
        pat = self.getpat()
        if not self.isre():
            pat = re.escape(pat)
        if self.isword():
            pat = '\\b%s\\b' % pat
        return pat

    def getprog(self):
        """Return compiled cooked search pattern."""
        pat = self.getpat()
        if not pat:
            self.report_error(pat, 'Empty regular expression')
            return None
        else:
            pat = self.getcookedpat()
            flags = 0
            if not self.iscase():
                flags = flags | re.IGNORECASE
            try:
                prog = re.compile(pat, flags)
            except re.error as what:
                args = what.args
                msg = args[0]
                col = arg[1] if len(args) >= 2 else -1
                self.report_error(pat, msg, col)
                return None

            return prog

    def report_error(self, pat, msg, col = -1):
        msg = 'Error: ' + str(msg)
        if pat:
            msg = msg + '\nPattern: ' + str(pat)
        if col >= 0:
            msg = msg + '\nOffset: ' + str(col)
        tkMessageBox.showerror('Regular expression error', msg, master=self.root)

    def search_text(self, text, prog = None, ok = 0):
        """Return (lineno, matchobj) or None for forward/backward search.
        
        This function calls the right function with the right arguments.
        It directly return the result of that call.
        
        Text is a text widget. Prog is a precompiled pattern.
        The ok parameteris a bit complicated as it has two effects.
        
        If there is a selection, the search begin at either end,
        depending on the direction setting and ok, with ok meaning that
        the search starts with the selection. Otherwise, search begins
        at the insert mark.
        
        To aid progress, the search functions do not return an empty
        match at the starting position unless ok is True.
        """
        if not prog:
            prog = self.getprog()
            if not prog:
                return None
        wrap = self.wrapvar.get()
        first, last = get_selection(text)
        if self.isback():
            if ok:
                start = last
            else:
                start = first
            line, col = get_line_col(start)
            res = self.search_backward(text, prog, line, col, wrap, ok)
        else:
            if ok:
                start = first
            else:
                start = last
            line, col = get_line_col(start)
            res = self.search_forward(text, prog, line, col, wrap, ok)
        return res

    def search_forward(self, text, prog, line, col, wrap, ok = 0):
        wrapped = 0
        startline = line
        chars = text.get('%d.0' % line, '%d.0' % (line + 1))
        while chars:
            m = prog.search(chars[:-1], col)
            if m:
                if ok or m.end() > col:
                    return (line, m)
            line = line + 1
            if wrapped and line > startline:
                break
            col = 0
            ok = 1
            chars = text.get('%d.0' % line, '%d.0' % (line + 1))
            if not chars and wrap:
                wrapped = 1
                wrap = 0
                line = 1
                chars = text.get('1.0', '2.0')

        return None

    def search_backward(self, text, prog, line, col, wrap, ok = 0):
        wrapped = 0
        startline = line
        chars = text.get('%d.0' % line, '%d.0' % (line + 1))
        while 1:
            m = search_reverse(prog, chars[:-1], col)
            if m:
                if ok or m.start() < col:
                    return (line, m)
            line = line - 1
            if wrapped and line < startline:
                break
            ok = 1
            if line <= 0:
                if not wrap:
                    break
                wrapped = 1
                wrap = 0
                pos = text.index('end-1c')
                line, col = map(int, pos.split('.'))
            chars = text.get('%d.0' % line, '%d.0' % (line + 1))
            col = len(chars) - 1

        return None
Пример #53
0
class PmaConvert:
    def __init__(self, config):
        root = Tk()

        # Root Definition
        root.geometry('1100x700')
        root.title('PMA Convert')

        # Configuration and Variables
        self.file_selection = ''
        self.is_converting = False
        self.options = config['option_definitions']
        gui_config = config['gui_config']

        # UI
        ## Frames
        self.main_frame = Frame(root)
        self.position_main_frame(gui_config['screen_orientation'])

        ## Components
        self.log = Text(self.main_frame, bd=1, relief=SUNKEN, width=140,
                        height=23, state=DISABLED, spacing3=1, wrap=WORD)

        choose_text = ('1. Choose XLSForm (.xls or .xlsx) file(s) for '
                       'conversion.')
        self.choose_files_label = Label(self.main_frame, text=choose_text)
        # TODO: Get spacing to work.
        # self.choose_files_label.grid(row=3, column=3, padx=(50, 50))
        # self.choose_files_label.grid(row=3, column=3, pady=(50, 50))
        self.choose_files_label.pack()
        self.choose_files_button = Button(self.main_frame,
                                          text='Choose file...', fg='black',
                                          command=self.on_open)
        self.choose_files_button.pack()

        out_text = 'Choose location for output file(s).'
        self.output_location_label = Label(self.main_frame, text=out_text)
        self.output_location_button = Button(self.main_frame,
                                             text='Choose location...',
                                             fg='black')
        if gui_config['output_location_on'] is True:
            self.output_location_label.pack()
            self.output_location_button.pack()

        self.choose_options_label = Label(self.main_frame,
                                          text='2. Choose conversion options.')
        self.choose_options_label.pack()

        ### Create Options Checkboxes
        # Task: Dynamically generate: http://stackoverflow.com/questions/...
        # ...553784/can-you-use-a-string-to-instantiate-a-class-in-python
        self.preexisting = BooleanVar()
        pre_text = self.options['preexisting']['label']
        self.preexisting_opt = Checkbutton(self.main_frame, text=pre_text,
                                           variable=self.preexisting)
        self.preexisting_opt.pack()
        self.regular = BooleanVar()
        reg_text = self.options['regular']['label']
        self.regular_opt = Checkbutton(self.main_frame, text=reg_text,
                                       variable=self.regular)
        self.regular_opt.pack()
        self.novalidate = BooleanVar()
        noval_text = self.options['novalidate']['label']
        self.novalidate_opt = Checkbutton(self.main_frame, text=noval_text,
                                          variable=self.novalidate)
        self.novalidate_opt.pack()
        self.ignore_version = BooleanVar()
        ig_text = self.options['ignore_version']['label']
        self.ignore_version_opt = Checkbutton(self.main_frame, text=ig_text,
                                              variable=self.ignore_version)
        self.ignore_version_opt.pack()
        self.linking_warn = BooleanVar()
        link_text = self.options['linking_warn']['label']
        self.linking_warn_option = Checkbutton(self.main_frame, text=link_text,
                                               variable=self.linking_warn)
        self.linking_warn_option.pack()
        self.debug = BooleanVar()
        debug_text = self.options['debug']['label']
        self.debug_option = Checkbutton(self.main_frame, text=debug_text,
                                        variable=self.debug)
        self.debug_option.pack()
        self.extras = BooleanVar()
        extras_text = self.options['extras']['label']
        self.extras_option = Checkbutton(self.main_frame, text=extras_text,
                                         variable=self.extras)
        self.extras_option.pack()

        self.convert_label = Label(self.main_frame, text='3. Run conversion.')
        self.convert_label.pack()

        # Task: Add xscrollcommand and yscrollcommand.
        self.convert_button = Button(self.main_frame, text='Convert',
                                     fg='black', command=self.convert)
        self.convert_button.pack()
        self.log.pack(fill=X, expand=1)
        self.log_text('PMA Convert allows you to convert .xls or .xlsx form '
                      'definition files to files which are compatible with ODK '
                      'Collect.\n\nIf you need to copy and paste from this '
                      'log, highlight the text and press CTRL+C to copy. Then '
                      'press CTRL+V to paste.\n\n'
                      '====================================================\n\n'
                      'Awaiting file selection.')

        # Task: Fix menus. They're not working.
        self.context_menu = Menu(self.main_frame, tearoff=0)
        self.context_menu.add_command(label="Convert", command=self.convert)
        self.main_frame.bind("<Button-3>", self.popup)

        # - Note: Strangely this stopped anchoring to bottom suddenly, for some
        # reason. So it is temporarily disabled.
        self.status_bar = Label(self.main_frame,
                                text='Awaiting file selection.',
                                bd=1, relief=SUNKEN, anchor=W)
        if gui_config['status_bar_on'] is True:
            self.status_bar.pack(side=BOTTOM, fill=X)

        # Run
        root.mainloop()

    # Functions
    def popup(self, event):
        # Note: Currently doesn't work.
        self.context_menu.post(event.x_root, event.y_root)
        # display the popup menu
        try:
            self.context_menu.tk_popup(event.x_root, event.y_root, 0)
        finally:
            # make sure to release the grab (Tk 8.0a1 only)
            self.context_menu.grab_release()

    def position_main_frame(self, orientation):
        if orientation == 'center':
            x, y, a = .5, .5, 'c'
            return self.main_frame.place(relx=x, rely=y, anchor=a)
        elif orientation == 'top':
            return self.main_frame.pack()
        else:
            return self.main_frame.pack()

    def on_open(self):
        file_types = [
            ('XLS Files', '*.xls'),
            ('XLSX Files', '*.xlsx'),
            ('All files', '*')
        ]
        try:
            self.file_selection = tkFileDialog.askopenfilename(
                filetypes=file_types, title='Open one or more files.',
                message='Open one or more files', multiple=1
            )
        except:
            self.file_selection = tkFileDialog.askopenfilename(
                filetypes=file_types, title='Open one or more files.', multiple=1
            )
        if self.file_selection != '':
            self.set_status('Click on Convert to convert files.')
            log_output = 'Ready for conversion: \n'
            for file in self.file_selection:
                log_output += '* ' + str(file) + '\n'
            log_output = log_output[:-1] # Removes the last '\n'.
            self.log.configure(self.log_text(log_output))

    def set_status(self, new_status):
        self.status_bar.configure(text=new_status)

    def log_text(self, new_text):
        self.log.configure(state=NORMAL)
        self.log.insert(END, str(new_text) + '\n\n')
        self.log.configure(state=DISABLED)
        self.log.bind("<1>", lambda event: self.log.focus_set())

    def convert(self):
        if self.file_selection != '':
            f = self.file_selection

            kwargs = {
                SUFFIX: u'',
                PREEXISTING: self.preexisting.get(),
                PMA: not self.regular.get(),
                CHECK_VERSIONING: not self.ignore_version.get(),
                STRICT_LINKING: not self.linking_warn.get(),
                VALIDATE: not self.novalidate.get(),
                EXTRAS: self.extras.get(),
                DEBUG: self.debug.get()
            }

            buffer = StringIO.StringIO()
            if not kwargs[DEBUG]:
                sys.stdout = buffer
                sys.stderr = buffer
            else:
                self.log_text('--> DEBUG MODE: check console output')

            try:
                xlsform_convert(f, **kwargs)
            except ConvertError as e:
                print unicode(e)
            except OSError as e:
                # Should catch WindowsError, impossible to test on Mac
                traceback.print_exc()
                print e

            if not kwargs[DEBUG]:
                sys.stdout = sys.__stdout__
                sys.stderr = sys.__stderr__

            self.log_text(buffer.getvalue())
Пример #54
0
def main(argv):
    if len(argv) == 1:
        root = Tk()
        root.title("Randominions 4")

        mapfilevar = StringVar()
        outfilevar = StringVar()
        outfilevar.set("newrandommap.map")
        modfilevar = StringVar()
        lvl1thronevar = IntVar()
        lvl1thronevar.set(0)
        lvl2thronevar = IntVar()
        lvl2thronevar.set(0)
        lvl3thronevar = IntVar()
        lvl3thronevar.set(0)

        landstartvar = IntVar()
        landstartvar.set(0)
        waterstartvar = IntVar()
        waterstartvar.set(0)
        coaststartvar = IntVar()
        coaststartvar.set(0)
        foreststartvar = IntVar()
        foreststartvar.set(0)
        swampstartvar = IntVar()
        swampstartvar.set(0)
        cavestartvar = IntVar()
        cavestartvar.set(0)

        indystrengthvar = IntVar()
        indystrengthvar.set(100)
        rarechancevar = IntVar()
        rarechancevar.set(10)
        magepowervar = IntVar()
        magepowervar.set(2)
        allowsacred = BooleanVar()
        allowsacred.set(False)

        Label(root, text="Map:").grid(row=0, sticky=E)
        Entry(root, width=50, textvariable=mapfilevar).grid(row=0, column=1)
        Label(root, text="Output map:").grid(row=4, sticky=E)
        Entry(root, width=50, textvariable=outfilevar).grid(row=4, column=1)
        Label(root, text="Nation mod file:").grid(row=5, sticky=E)
        Entry(root, width=50, textvariable=modfilevar).grid(row=5, column=1)

        Label(root, text="Rare indy chance(%):").grid(row=6, sticky=E)
        Entry(root, width=5, textvariable=rarechancevar).grid(row=6, column=1, sticky=W)
        Label(root, text="Indy strength(%):").grid(row=7, sticky=E)
        Entry(root, width=5, textvariable=indystrengthvar).grid(row=7, column=1, sticky=W)
        Label(root, text="Max nation mage power:").grid(row=8, sticky=E)
        Entry(root, width=5, textvariable=magepowervar).grid(row=8, column=1, sticky=W)
        Label(root, text="Allow sacred units:").grid(row=9, sticky=E)
        Checkbutton(root, variable=allowsacred).grid(row=9, column=1, sticky=W)

        Label(root, text="Level 1 thrones:").grid(row=0, column=3, sticky=E)
        Entry(root, width=3, textvariable=lvl1thronevar).grid(row=0, column=4)
        Label(root, text="Level 2 thrones:").grid(row=1, column=3, sticky=E)
        Entry(root, width=3, textvariable=lvl2thronevar).grid(row=1, column=4)
        Label(root, text="Level 3 thrones:").grid(row=2, column=3, sticky=E)
        Entry(root, width=3, textvariable=lvl3thronevar).grid(row=2, column=4)

        Label(root, text="Land nations:").grid(row=3, column=3, sticky=E)
        Entry(root, width=3, textvariable=landstartvar).grid(row=3, column=4)
        Label(root, text="Water nations:").grid(row=4, column=3, sticky=E)
        Entry(root, width=3, textvariable=waterstartvar).grid(row=4, column=4)
        Label(root, text="Coastal starts:").grid(row=5, column=3, sticky=E)
        Entry(root, width=3, textvariable=coaststartvar).grid(row=5, column=4)
        Label(root, text="Forest starts:").grid(row=6, column=3, sticky=E)
        Entry(root, width=3, textvariable=foreststartvar).grid(row=6, column=4)
        Label(root, text="Swamp starts:").grid(row=7, column=3, sticky=E)
        Entry(root, width=3, textvariable=swampstartvar).grid(row=7, column=4)
        Label(root, text="Cave starts:").grid(row=8, column=3, sticky=E)
        Entry(root, width=3, textvariable=cavestartvar).grid(row=8, column=4)

        Label(root, text="Indies:").grid(row=1, sticky=E)
        indylist = Listbox(root, width=50, height=4)
        indylist.grid(row=1, column=1, rowspan=3)

        Button(root, width=13, text="Choose Map", command=lambda : mapfilevar.set(askopenfilename(filetypes=[('Dominions 4 map files', '.map')]))).grid(row=0, column=2, sticky=W)
        Button(root, width=13, text="Choose Mod", command=lambda : modfilevar.set(askopenfilename(filetypes=[('Dominions 4 mod file', '.dm')]))).grid(row=5, column=2, sticky=W)
        Button(root, width=13, text="Add indies", command=lambda : indylist.insert(END,askopenfilename(filetypes=[('JSON files', '.json'), ('Domions 4 mod files', '.dm')]))).grid(row=1, column=2, sticky=W)
        Button(root, width=13, text="Remove selected", command=lambda : indylist.delete(ANCHOR)).grid(row=2, column=2, sticky=W)
        Button(root, width=10, text="Quit", command=root.destroy).grid(row=10, column=0)
        Button(root, width=10, text="Generate!", \
            command=lambda : runGenerator(mapfilevar.get(), indylist.get(0, END), outfilevar.get(), landstartvar.get(), waterstartvar.get(), \
                coaststartvar.get(), foreststartvar.get(), swampstartvar.get(), cavestartvar.get(), lvl1thronevar.get(), \
                lvl2thronevar.get(), lvl3thronevar.get(), rarechancevar.get(), indystrengthvar.get(), modfilevar.get(), magepowervar.get(), allowsacred.get())).grid(row=10, column=3)

        root.mainloop()

    elif len(argv) < 15:
        print "Usage: randominions4 mapfile targetmapfile indydefinition landnations waternations coaststarts foreststarts swampstarts cavestarts lvl1thrones lvl2thrones lvl3thrones rarechance indystrength"
    else:
        mapfile = argv[1]
        indyfile = argv[3]
        targetfile = argv[2]
        landcount = int(argv[4])
        watercount = int(argv[5])
        coaststarts = int(argv[6])
        foreststarts = int(argv[7])
        swampstarts = int(argv[8])
        cavestarts = int(argv[9])
        lvl1thrones = int(argv[10])
        lvl2thrones = int(argv[11])
        lvl3thrones = int(argv[12])
        rarechance = int(argv[13])
        strength = int(argv[14])

        runGenerator(mapfile, [indyfile], targetfile, landcount, watercount, coaststarts, foreststarts, swampstarts, cavestarts, lvl1thrones, lvl2thrones, lvl3thrones, rarechance, strength, None, None, None)
Пример #55
0
class SearchEngine:
    """Handles searching a text widget for Find, Replace, and Grep."""
    def __init__(self, root):
        """Initialize Variables that save search state.
        
        The dialogs bind these to the UI elements present in the dialogs.
        """
        self.root = root
        self.patvar = StringVar(root, '')
        self.revar = BooleanVar(root, False)
        self.casevar = BooleanVar(root, False)
        self.wordvar = BooleanVar(root, False)
        self.wrapvar = BooleanVar(root, True)
        self.backvar = BooleanVar(root, False)

    def getpat(self):
        return self.patvar.get()

    def setpat(self, pat):
        self.patvar.set(pat)

    def isre(self):
        return self.revar.get()

    def iscase(self):
        return self.casevar.get()

    def isword(self):
        return self.wordvar.get()

    def iswrap(self):
        return self.wrapvar.get()

    def isback(self):
        return self.backvar.get()

    def setcookedpat(self, pat):
        """Set pattern after escaping if re."""
        if self.isre():
            pat = re.escape(pat)
        self.setpat(pat)

    def getcookedpat(self):
        pat = self.getpat()
        if not self.isre():
            pat = re.escape(pat)
        if self.isword():
            pat = '\\b%s\\b' % pat
        return pat

    def getprog(self):
        """Return compiled cooked search pattern."""
        pat = self.getpat()
        if not pat:
            self.report_error(pat, 'Empty regular expression')
            return None
        else:
            pat = self.getcookedpat()
            flags = 0
            if not self.iscase():
                flags = flags | re.IGNORECASE
            try:
                prog = re.compile(pat, flags)
            except re.error as what:
                args = what.args
                msg = args[0]
                col = arg[1] if len(args) >= 2 else -1
                self.report_error(pat, msg, col)
                return None

            return prog

    def report_error(self, pat, msg, col=-1):
        msg = 'Error: ' + str(msg)
        if pat:
            msg = msg + '\nPattern: ' + str(pat)
        if col >= 0:
            msg = msg + '\nOffset: ' + str(col)
        tkMessageBox.showerror('Regular expression error',
                               msg,
                               master=self.root)

    def search_text(self, text, prog=None, ok=0):
        """Return (lineno, matchobj) or None for forward/backward search.
        
        This function calls the right function with the right arguments.
        It directly return the result of that call.
        
        Text is a text widget. Prog is a precompiled pattern.
        The ok parameteris a bit complicated as it has two effects.
        
        If there is a selection, the search begin at either end,
        depending on the direction setting and ok, with ok meaning that
        the search starts with the selection. Otherwise, search begins
        at the insert mark.
        
        To aid progress, the search functions do not return an empty
        match at the starting position unless ok is True.
        """
        if not prog:
            prog = self.getprog()
            if not prog:
                return None
        wrap = self.wrapvar.get()
        first, last = get_selection(text)
        if self.isback():
            if ok:
                start = last
            else:
                start = first
            line, col = get_line_col(start)
            res = self.search_backward(text, prog, line, col, wrap, ok)
        else:
            if ok:
                start = first
            else:
                start = last
            line, col = get_line_col(start)
            res = self.search_forward(text, prog, line, col, wrap, ok)
        return res

    def search_forward(self, text, prog, line, col, wrap, ok=0):
        wrapped = 0
        startline = line
        chars = text.get('%d.0' % line, '%d.0' % (line + 1))
        while chars:
            m = prog.search(chars[:-1], col)
            if m:
                if ok or m.end() > col:
                    return (line, m)
            line = line + 1
            if wrapped and line > startline:
                break
            col = 0
            ok = 1
            chars = text.get('%d.0' % line, '%d.0' % (line + 1))
            if not chars and wrap:
                wrapped = 1
                wrap = 0
                line = 1
                chars = text.get('1.0', '2.0')

        return None

    def search_backward(self, text, prog, line, col, wrap, ok=0):
        wrapped = 0
        startline = line
        chars = text.get('%d.0' % line, '%d.0' % (line + 1))
        while 1:
            m = search_reverse(prog, chars[:-1], col)
            if m:
                if ok or m.start() < col:
                    return (line, m)
            line = line - 1
            if wrapped and line < startline:
                break
            ok = 1
            if line <= 0:
                if not wrap:
                    break
                wrapped = 1
                wrap = 0
                pos = text.index('end-1c')
                line, col = map(int, pos.split('.'))
            chars = text.get('%d.0' % line, '%d.0' % (line + 1))
            col = len(chars) - 1

        return None
Пример #56
0
class Studio(Frame):
    """The Studio class is a GUI for the digital library."""
    _meter = None
    _grid = None
    _dual_box = None
    _auto_queue = None
    _entry = None
    _search_results = None
    _selected_cart = None

    def __init__(self):
        """Construct a Studio window."""
        Frame.__init__(self)

        # make the window resizable
        top = self.master.winfo_toplevel()
        for row in range(2, GRID_ROWS + 2):
            for col in range(0, GRID_COLS):
                top.rowconfigure(row, weight=1)
                top.columnconfigure(col, weight=1)
                self.rowconfigure(row, weight=1)
                self.columnconfigure(col, weight=1)

        # initialize the title
        title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
        title.grid(row=0, column=0, columnspan=GRID_COLS)

        # initialize the meter
        self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
        self._meter.grid(row=1, column=0, columnspan=GRID_COLS)

        # initialize the cart grid
        self._grid = Grid(self, GRID_ROWS, GRID_COLS, True, self._cart_start,
                          self._cart_stop, self._cart_end, self.add_cart)

        # initialize the dual box
        self._dual_box = DualBox(self)
        self._dual_box.grid(row=GRID_ROWS + 2, column=0, columnspan=4)

        # intialize the auto-queue control
        self._auto_queue = BooleanVar()
        self._auto_queue.set(False)

        control = Frame(self.master, bd=2, relief=Tkinter.SUNKEN)

        Checkbutton(control,
                    text=TEXT_AUTOSLOT,
                    variable=self._auto_queue,
                    onvalue=True,
                    offvalue=False).pack(anchor=Tkinter.NW)
        control.grid(row=GRID_ROWS + 2, column=4, columnspan=GRID_COLS - 4)

        # initialize the search box, button
        Label(control, font=FONT, text=TEXT_SEARCHBOX).pack(anchor=Tkinter.NW)
        self._entry = Entry(control, takefocus=True, width=45)
        self._entry.bind("<Return>", self.search)
        # self._entry.grid(row=GRID_ROWS + 3, column=0, columnspan=5)
        self._entry.pack(anchor=Tkinter.NW)
        self._entry.focus_set()

        button = Button(control, text=TEXT_SEARCH, command=self.search)
        # button.grid(row=GRID_ROWS + 3, column=5)
        button.pack(anchor=Tkinter.S)

        # begin the event loop
        self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
        self.master.title(TEXT_TITLE)
        self.master.mainloop()

    def _search_internal(self):
        """Search the digital library in a separate thread."""
        query = self._entry.get()

        if len(query) >= 3:
            print "Searching library with query \"%s\"..." % query

            self._search_results = database.search_library(query)
            self._dual_box.fill(self._search_results)

            print "Found %d results." % len(self._search_results)

    def search(self, *args):
        """Search the digital library.

        :param args
        """
        thread.start_new_thread(self._search_internal, ())

    def select_cart(self, index):
        """Select a cart from the search results.

        :param index: index of cart in search results
        """
        if index is not None:
            self._selected_cart = self._search_results[index]

    def add_cart(self, key):
        """Add the selected cart to the grid.

        :param key
        """
        if not self._grid.has_cart(key) and self._selected_cart is not None:
            self._grid.set_cart(key, self._selected_cart)

    def _cart_start(self):
        """Start the meter when a cart starts."""
        self._meter.start()

    def _cart_stop(self):
        """Reset the meter when a cart stops."""
        self._meter.reset()

    def _cart_end(self, key):
        """Reset the meter when a cart ends.

        Also, if auto-queue is enabled, queue the next cart.

        :param key
        """
        self._meter.reset()

        if self._auto_queue.get():
            next_key = get_next_key(GRID_ROWS, GRID_COLS, key)
            if self._grid.has_cart(next_key):
                self._grid.start(next_key)

    def _get_meter_data(self):
        """Get meter data for the currently active cart."""
        return self._grid.get_active_cell().get_cart().get_meter_data()