Пример #1
0
class playar(Frame):

    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.filenm=None
        self.pack(fill=BOTH, expand=1)
        self.parent = parent
        self.initplayer()

    def initplayer(self):
        self.videoFrame = Frame(self, width=800, height=480)
        self.videoFrame.pack(side="top", fill="both", expand=True)
        self.buttonframe = Frame(self, padding="2 2 11 11")
        self.buttonframe.pack(side="bottom", fill="x", expand=True)

        self.selectbutton = Button(self.buttonframe, text="Select")
        self.selectbutton.grid(column=0, row=0, sticky=W)
        self.playbutton = Button(self.buttonframe, text="Play").grid(column=1, row=0, sticky=W)
        for child in self.buttonframe.winfo_children(): child.grid_configure(padx=5, pady=5)
        self.buttonframe.rowconfigure(0, weight=1)
        self.buttonframe.columnconfigure(0, weight=1)
        self.buttonframe.columnconfigure(1, weight=1)

    def setwh(self,w,h):
        self.videoFrame.configure(width=w, height=h)

    def quit(self):
        print "QUIT CALLED"
        pg.quit()
        self.destroy()
Пример #2
0
#StartFinal = 0
#for j in range(0, int(round(math.sqrt(len(FlagsDict))))):
#    for i in range(StartFinal, EndFinal):
#        print FlagsDict.keys()[i]+'Var = tk.IntVar()'
#        print FlagsDict.keys()[i]+'Check = tk.Checkbutton(frame2, \
#        text='+"'"+FlagsDict.keys()[i]+"'"+', variable='+FlagsDict.keys()[i]+'Var)'
#        print FlagsDict.keys()[i]+'Check.grid(row='+str(i-(8*j))+', column='+str(j)+')'
#        print 'VariableList.append('+FlagsDict.keys()[i]+'Var)'
#    StartFinal = EndFinal
#    EndFinal = StartFinal + 8

######################################################
# for getting other attributes besides the flags
######################################################
frame3 = Frame(the_window)
frame3.configure(padding=30)

OverPlotVar = tk.IntVar()
OverPlotCheck = tk.Checkbutton(frame3, text='OverPlot', variable=OverPlotVar)
OverPlotCheck.grid(row=0, column=0)

StarsVar = tk.IntVar()
StarsCheck = tk.Checkbutton(frame3, text='Stars', variable=StarsVar)
StarsCheck.grid(row=0, column=1)

GalaxiesVar = tk.IntVar()
GalaxiesCheck = tk.Checkbutton(frame3, text='Galaxies', variable=GalaxiesVar)
GalaxiesCheck.grid(row=0, column=2)

##  starting the GUI APP  ###
frame.pack()
Пример #3
0
    class Bill():
        """LOST: Класс, содержащий в себе виджеты списока блюд и ингредиентов,
        подлежащих списанию, набора кнопок управления, односящихся к этому
        списку."""

        def __init__(self, master):

            self.frame = Frame(master)
            self.frame.pack(side = LEFT)
            self.frame_lower_button = Frame(self.frame)
            self.frame_lower_button.pack(side=BOTTOM, fill=Y)
            #------------------------ Поле под списком --------#7
            self.memo = Text(self.frame, height=LOST_COMMENT_HEIGHT,
                  width = LOST_WIDTH+1, font=('Lucida Console', BILL_FONT_SIZE))
            self.memo.pack(side=BOTTOM)
            Label(self.frame, text=u'Дополнительный комментарий:',
                font=('Lucida Console', FONT_SIZE)).pack(side=BOTTOM, pady=5)
            #------------------------ Кнопки слева от списка ---------#
            self.frame_left_button = Frame(self.frame)
            self.frame_left_button.pack(side=LEFT, fill=Y)
            self.button_up = Button(self.frame_left_button,
                               image=data.IMG_INTERFACE[2], command=self.b_up)
            self.button_up.pack(side=TOP, padx=5, pady=10)
            self.button_down = Button(self.frame_left_button,
                               image=data.IMG_INTERFACE[1], command=self.b_down)
            self.button_down.pack(side=TOP, padx=5, pady=0)
            #------------------------ Собственно список ---------------#
            self.scrollbar = Scrollbar(self.frame)
            self.listbox = Listbox(self.frame,
                                   yscrollcommand=self.scrollbar.set,
                                   width = LOST_WIDTH, height=LOST_HEIGHT,
                                   activestyle='dotbox',
                                   font=('Lucida Console', BILL_FONT_SIZE))
            self.listbox.pack(side=LEFT, fill=BOTH)
            self.scrollbar.config(command=self.listbox.yview)
            self.scrollbar.pack(side=LEFT, fill=Y)
            #------------------------ Кнопки справа от списка --------#
            self.frame_right_button = Frame(self.frame)
            self.frame_right_button.pack(side=LEFT, fill=Y)
            self.button_plus = Button(self.frame_right_button,
                              image=data.IMG_INTERFACE[6],command=self.b_plus)
            self.button_plus.pack(side=TOP, padx=5, pady=2)
            self.button_minus = Button(self.frame_right_button,
                              image=data.IMG_INTERFACE[7],command=self.b_minus)
            self.button_minus.pack(side=TOP, padx=5, pady=2)
            self.button_info = Button(self.frame_right_button,
                              image=data.IMG_INTERFACE[9],command=self.b_info)
            self.button_info.pack(side=TOP, padx=5, pady=2)
            self.button_del = Button(self.frame_right_button,
                              image=data.IMG_INTERFACE[5],command=self.b_del,
                              state=DISABLED)
            self.button_del.pack(side=TOP, padx=5, pady=25)
            #-------------------------- Кнопки снизу от списка ------------№
            self.button_clear = Button(self.frame_lower_button,
                                text=u'Очистить\nсписок',
                                style='Little.TButton',command=self.b_clear)
            self.button_clear.pack(side=LEFT, padx=10, pady=10, fill=X)
            self.button_save = Button(self.frame_lower_button,
                                text=u'Сохранить\nсписок', style='Little.TButton',
                                command=self.b_save, state=DISABLED)
            self.button_save.pack(side=LEFT, padx=10, pady=10, fill=X)
            self.button_accept = Button(self.frame_lower_button,
                                text=u'Провести\nсписание',
                                style='Little.TButton', command=self.b_accept)
            self.button_accept.pack(side=LEFT, padx=10, pady=10, fill=X)
            #------------------- Причина списания под списком -----------------#
            self.lost_reason_frame = Frame(self.frame_lower_button,
                            relief=GROOVE, width=LOST_REASON_WIDTH, height=50)
            self.lost_reason_frame.pack_propagate(False)
            self.lost_reason_frame.pack(side=LEFT, fill=X)
            self.lostReasonsMenu = Menubutton(self.lost_reason_frame,
                                          text=u'Причина: ----',
                                          direction='below',style='TMenubutton')
            self.lostReasonsMenu.pack(fill=X, pady=5, padx=5)
            self.lostReasonsMenu.update()   #Подгонка по высоте
            self.lost_reason_frame.configure(
                                height=self.lostReasonsMenu.winfo_height() + 10)
            self.lostReasonsMenu.menu  =  Menu(self.lostReasonsMenu, tearoff=0)
            self.lostReasonsMenu['menu'] = self.lostReasonsMenu.menu

            for item in queries.lost_reasons_list():
                self.lostReasonsMenu.menu.add_command(label=item.reason,
                    font=('Verdana', FONT_SIZE_MENU),
                    command=lambda key=item.id: self.reason_change(key))
                                                               # Текущая скидка.
            if queries.lost_reasons_list():
                self.reason = queries.lost_reasons_list()[0]
                self.lostReasonsMenu.configure(text=u'Причина: %s' %
                                                             self.reason.reason)
            else:
                self.reason = None

            self.bill = []        # Содержание текущего списка (Wasted)

    #-----------------------------------------------------------

        def verify_calc(self, item, item_quantity):
            """Подсобная функция для работы функции verify(). Проверяет наличие
            на складе ингредиентов, входящих в сложный товар на момент списания.
            Возвращает True или False в зависимости от  наличия необходиомого
            количества товара на складе для списания."""

            result = True
            for calc in queries.item_calculation(item):

                if calc.ingredient.calculation:

                    for calc2 in queries.item_calculation(calc.ingredient):

                        quantity = int(queries.items_in_storage(
                                                              calc2.ingredient))
                        need_quantity = (item_quantity * calc2.quantity *
                                                                  calc.quantity)
                        if quantity < need_quantity:
                            tkMessageBox.showwarning(u'Внимание!',
                            u'Вы пытаетесь списать %d единицы товара "%s".' %
                            (need_quantity, calc2.ingredient.name) +
                            u'\nНа складе имеется всего %d единицы!'% quantity)
                            result = False

                else:
                    quantity = int(queries.items_in_storage(calc.ingredient))
                    need_quantity = item_quantity * calc.quantity

                    if quantity < need_quantity:
                        tkMessageBox.showwarning(u'Внимание!',
                        u'Вы пытаетесь списать %d единицы товара "%s".' %
                        (need_quantity, calc.ingredient.name) +
                        u'\nНа складе имеется всего %d единицы!'% quantity)
                        result = False

            return result


        def verify(self):
            """Проверяет наличие на складе товаров, входящих в счет, на момент
            списания. Возвращает True или False в зависимости от наличия
            необходиомого количества товара на складе для продажи."""

            all_present = True

            for element in self.bill:
                if element.item.calculation:
                    if not self.verify_calc(element.item, element.quantity):
                        all_present = False

                else:
                    quantity = int(queries.items_in_storage(element.item))

                    if quantity < element.quantity:
                        tkMessageBox.showwarning(u'Внимание!',
                    u'Вы пытаетесь списать %d единицы товара "%s".' %
                        (element.quantity, element.item.name) +
                    u'\nНа складе имеется всего %d единицы!' % quantity)
                        all_present = False

            return all_present


        def reason_change(self, key):
            """Меняет текущую причину для списания."""

            self.lostReasonsMenu.configure(text=u'Причина: %s' %
                               queries.get_lost_reason_by_id(key).reason)
            self.reason = queries.get_lost_reason_by_id(key)


        def make_list_string(self, lost):
            """Вспомогательная функция создания строки для списка списания"""

            string = u' %-' + unicode(27 +
                        (LOST_WIDTH - 63) /2) + u's %6d %3s  -  %s'
            string = string % (lost.item.name, lost.quantity,
                            lost.item.measure, lost.reason.reason)
            return string


        def add_eat(self, eat, number):
            """Добавляет товар в текущий список. Изменяет как отображение в
            списке виджета, так и данные в self.bill"""

            if self.reason:
                self.button_del.configure(state=NORMAL)
                lost = Wasted(eat, number, self.reason)
                self.bill.append(lost)
                string = self.make_list_string(lost)
                self.listbox.insert(END, string)
            else:
                tkMessageBox.showwarning('Однако!',
                'Списание невозможно, так как в настоящий момент\n' +
                'не предусмотрено ни одной причины для списания!')


        def b_up(self):
            """Срабатывает при нажатии кнопки "вверх" на панели списка.
            Поднимаем выделение в списке на предыдущую позицию (вверх)"""

            selected = self.listbox.curselection()
            if selected:
                index = int(selected[0])
                if index > 0:
                    self.listbox.selection_clear(index)
                    self.listbox.selection_set(index-1)
                    self.listbox.see(index-2)
            else:
                count = self.listbox.size()
                if count:
                    self.listbox.selection_set(count - 1)
                    self.listbox.see(count - 1)


        def b_down(self):
            """Срабатывает при нажатии кнопки "вниз" на панели списка.
            Опускаем выделение в списке на следующую позицию (вниз)"""

            selected = self.listbox.curselection()
            if selected:
                index = int(selected[0])
                if index < self.listbox.size() - 1:
                    self.listbox.selection_clear(index)
                    self.listbox.selection_set(index + 1)
                    self.listbox.see(index + 1)
            else:
                if self.listbox.size():
                    self.listbox.selection_set(0)
                    self.listbox.see(0)


        def b_plus(self):
            """Срабатывает при нажатии кнопки "+" на панели списка.
            Добавляет +1 к позиции в списке"""

            selected = self.listbox.curselection()
            if selected:
                index = int(selected[0])
                lost = self.bill[index]
                lost.quantity += 1
                self.listbox.delete(index)
                string = self.make_list_string(lost)
                self.listbox.insert(index, string)
                self.listbox.selection_set(index)
                self.listbox.see(index)


        def b_minus(self):
            """Срабатывает при нажатии кнопки "-" на панели списка.
            Убирает 1 к позиции в списке или удаляет, если и так была 1"""

            selected = self.listbox.curselection()
            if selected:
                index = int(selected[0])
                lost = self.bill[index]
                if lost.quantity == 1:
                    self.b_del()
                else:
                    lost.quantity -= 1
                    self.listbox.delete(index)
                    string = self.make_list_string(lost)
                    self.listbox.insert(index, string)
                    self.listbox.selection_set(index)
                    self.listbox.see(index)


        def b_del(self):
            """Срабатывает при нажатии кнопки "удалить" на панели списка.
            Полностью удаляем позицию в списка"""

            selected = self.listbox.curselection()
            if selected:
                index = int(selected[0])
                del self.bill[index]
                self.listbox.delete(index)
                if self.listbox.size() == 0:
                    self.button_del.configure(state=DISABLED)
                self.listbox.see(index)


        def b_info(self):
            """Срабатывает при нажатии кнопки "инфо" на панели списка.
            Меняет причину списания выделенного элемента списка на текущую"""

            selected = self.listbox.curselection()
            if selected:
                index = int(selected[0])
                lost = self.bill[index]
                lost.reason = self.reason
                self.listbox.delete(index)
                string = self.make_list_string(lost)
                self.listbox.insert(index, string)
                self.listbox.selection_set(index)
                self.listbox.see(index)


        def b_clear(self):
            """Срабатывает при нажатии кнопки "Очистить список".
            Соответственно, очищает список."""

            self.bill = []
            self.listbox.delete(0, END)
            self.button_del.configure(state=DISABLED)


        def b_save(self):
            """Срабатывает при нажатии кнопки "Сохранить список".
            Сохраняет чек в файл на диске"""

            pass                                                            #Не дописано.


        def b_accept(self):
            """Срабатывает при нажатии "Провести операцию" на панели списка.
            Полностью проводит списание по бухгалтерии, и убирая соответствющий
            товар. Изменяет базу данных"""

            if not self.bill:
                tkMessageBox.showwarning('Однако!',
                                        'Список пуст, списывать нечего.')

            elif not self.reason:
                tkMessageBox.showwarning('Однако!',
                                'Повторно напоминаю, что у вас не\n', +
                                'предусмотрено ни одной причины для списания!')

            elif self.verify() and tkMessageBox.askokcancel('Внимание!',
                              'Вы подтверждаете операцию проведения списания?'):

                list_item, list_quantity, list_reason = [], [], []
                for lost in self.bill:
                    list_item.append(lost.item)
                    list_quantity.append(lost.quantity)
                    list_reason.append(lost.reason)
                queries.execute_lost(list_item, list_quantity, list_reason,
                                                         self.memo.get(1.0,END))
                self.b_clear()

                #Возвращаем панель категорий на место

                show_lost.master.destroy()
                lostBottomFrame = Canvas(MasterFrame, highlightthickness=0)
                show_lost.master = lostBottomFrame

                if USE_BACKGROUND:
                    lostBottomFrame.create_image(0,0, anchor='nw',
                                                               image=data.photo)
                lostBottomFrame.pack(side=LEFT, fill=BOTH, expand=YES)
                show_lost_cathegory(lostBottomFrame)
Пример #4
0
class mainframe(Frame):

    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.filenm=None
        self.streamnm = None
        self.pack(fill=BOTH, expand=1)
        self.parent = parent
        self.initplayer()
        self.player_process = None
        self.seekthread = None
        self.fstate = False
        self.paused = True
        self.trackmouse = True
        self.stdout_thread = None
        self.stream = False
        self.inhibit_slider_trigger = False
        self.q = LifoQueue()
        self.currtime = 0
        self.endtime = -1

    def initplayer(self):
        self.parentframe = Frame(self)
        self.parentframe.pack(fill=BOTH, expand=True)
        self.videoFrame = Frame(self.parentframe, width=800, height=480)
        self.videoFrame.pack(side="top", fill="both", expand=True)
        self.buttonframe = Frame(self.parentframe, padding="2 2 1 1")
        self.buttonframe.pack(side="bottom", fill="x", expand=False)

        self.seekbar = Scale(self.buttonframe, from_= 0, to=100, orient=HORIZONTAL)
        self.seekbar.grid(column=0, columnspan=4, row=0, sticky=[N, E, S, W])
        self.seekbar.configure(command=self.seeked)

        self.selectbutton = Button(self.buttonframe, text="Select File")
        self.selectbutton.grid(column=0, row=1, sticky=[E,W])
        self.streambutton = Button(self.buttonframe, text="Open HTTP", command=self.streamopen)
        self.streambutton.grid(column=1, row=1, sticky=[E,W])
        self.playbutton = Button(self.buttonframe, text="Play")
        self.playbutton.config(command=self.playpause)
        self.playbutton.grid(column=2, row=1, sticky=[E,W])
        self.fullscreenbutton = Button(self.buttonframe, text="Fullscreen", command=self.togglefullscreen)
        self.fullscreenbutton.grid(column=3, row=1, sticky=[E,W])
        for child in self.buttonframe.winfo_children(): child.grid_configure(padx=5, pady=5)
        self.buttonframe.rowconfigure(0, weight=1)
        self.buttonframe.rowconfigure(1, weight=1)
        self.buttonframe.columnconfigure(0, weight=1)
        self.buttonframe.columnconfigure(1, weight=1)
        self.buttonframe.columnconfigure(2, weight=1)
        self.buttonframe.columnconfigure(3, weight=1)

        self.selectbutton.configure(command=self.fileopen)
        self.videoFrame.bind("<Button-1>",self.playpause)
        self.parent.bind("<F11>", self.togglefullscreen)
        self.parent.bind("<Motion>",self.mouseops)

    def mouseops(self,event=None):
        self.videoFrame.config(cursor="")
        self.videoFrame.after(5000,self.cursorhandler)
        if self.trackmouse:
            x, y = self.parent.winfo_pointerx(), self.parent.winfo_pointery()
            windowx, windowy = self.parent.winfo_width(), self.parent.winfo_height()
            if windowy - 30 <= y:
                if self.fstate:
                    self.buttonframe.pack(side="bottom", fill="x", expand=False)
                    self.trackmouse = False
                    self.parent.after(5000, self.mousetracker)
                self.inhibit_slider_trigger = False
            elif self.fstate:
                self.buttonframe.pack_forget()
                self.inhibit_slider_trigger = True
            else:
                self.inhibit_slider_trigger = True

    def mousetracker(self):
        print 'Mouse Tracker'
        self.trackmouse = True
        self.videoFrame.after(0,self.mouseops)

    def cursorhandler(self):
        self.videoFrame.config(cursor="none")

    def togglefullscreen(self, event=None):
        self.fstate = not self.fstate
        self.parent.attributes("-fullscreen",self.fstate)
        if self.fstate:
            self.fullscreenbutton.config(text="Exit Fullscreen")
            self.buttonframe.pack_forget()
            self.videoFrame.config(cursor="none")
        else:
            self.fullscreenbutton.config(text="Fullscreen")
            self.buttonframe.pack(side="bottom", fill="x", expand=False)
            self.videoFrame.after(5000, self.cursorhandler)

    def fileopen(self):
        self.filenm = askopenfilename(filetypes=[("Supported Files","*.mp4;*.mkv;*.mpg;*.avi;*.mov"),("All Files","*.*")])
        self.stream = False
        self.play()

    def streamopen(self):
        self.streamnm = Dlog(self.parent)
        if self.streamnm.result is not None:
            s = str(self.streamnm)
        else:
            return
        if s.startswith('http'):
            self.stream = True
            self.play()
        else:
            self.stream = False
            showerror("Error","Incorrect Entry")

    def play(self):
        global fifofilename
        if self.filenm is not None and self.filenm != "":
            winid = self.videoFrame.winfo_id()
            if self.mplayer_isrunning():
                self.stop()
            try:
                self.paused = False
                self.playbutton.configure(text="Pause")
                if not self.stream:
                    self.player_process = Popen(["mplayer","-fs","-slave","-quiet","-wid",str(winid),self.filenm],stdin=PIPE, stdout=PIPE)
                else:
                    self.player_process = Popen(["mplayer","-fs","-slave","-quiet","-wid",str(winid),self.streamnm], stdin=PIPE, stdout=PIPE)
                self.stdout_thread = Thread(target=self.enqueue_pipe, args=(self.player_process.stdout, self.q))
                self.stdout_thread.daemon = True
                self.stdout_thread.start()
                self.emptypipe()
                self.seekthread = Thread(target=self.seekbar_setup, args=())
                self.seekthread.daemon = True
                self.seekthread.start()
            except:
                showerror("Error","".join(["Couldn't play video:\n",str(sys.exc_info()[:])]))

    def getvidtime(self):
        if self.mplayer_isrunning():
            self.command_player("get_time_length")
            output = self.readpipe()
            while "ANS_LENGTH" not in output:
                output = self.readpipe()
            if "ANS_LENGTH" in output:
                return output.split('ANS_LENGTH=')[1]
            else:
                return 0

    def playpause(self, event=None):
        if self.player_process is None:
            return
        self.paused = not self.paused
        if self.paused:
            print "VIDEO IS PAUSED /B/RO"
            self.playbutton.configure(text="Play")
        else:
            self.playbutton.configure(text="Pause")
        self.command_player("pause")

    def setwh(self,w,h):
        self.videoFrame.configure(width=w, height=h)

    def quit(self):
        print "QUIT CALLED"
        self.destroy()

    def mplayer_isrunning(self):
        if self.player_process is not None:
            return (self.player_process.poll() is None)
        else:
            return False

    def command_player(self, comd):
        global fifofilename
        if self.mplayer_isrunning():
            try:
                self.player_process.stdin.flush()
                self.player_process.stdin.write("\r\n%s\r\n"%comd)
                # for _ in itertools.repeat(None,8192):
                #     self.player_process.stdin.write("\n")
                self.player_process.stdin.flush()
            except:
                showerror("Error","Error passing command to mplayer\n%s"%sys.exc_info()[1])

    def enqueue_pipe(self, out, q):
        print 'Working on reading mplayer pipe output...'
        for line in iter(out.readline, b''):
            q.put(line)
        out.close()

    def seekbar_setup(self):
        pos = '0'
        trial = 0
        while float(pos)<1:
            trial += 1
            pos = self.getvidtime()
        self.seekbar.config(to=int(float(pos)))
        self.endtime = int(float(pos))
        Timer(1, self.seekbar_updater).start()

    def seekbar_updater(self):
        if not self.paused and self.inhibit_slider_trigger:
            self.currtime += 1
            self.seekbar.set(self.currtime)
        else:
            self.currtime = self.seekbar.get()
        Timer(1, self.seekbar_updater).start()

    def seeked(self,e):
        pos = self.seekbar.get()
        print "We changed pos to :%d"% pos

        x, y = self.parent.winfo_pointerx(), self.parent.winfo_pointery()
        windowx, windowy = self.parent.winfo_width(), self.parent.winfo_height()
        if not self.inhibit_slider_trigger and windowy - 30 <= y:
            self.command_player("seek %d 2"%pos)
            if self.paused:
                self.command_player("pause")

    def startmousetrack(self):
        self.trackmouse = True

    def readpipe(self):
        line = ""
        try:
            line = self.q.get_nowait()
        except Empty:
            print "Empty PIPE"
        finally:
            return line

    def emptypipe(self):
        str = ''
        try:
            while not self.q.empty():
                str += self.q.get_nowait()
        except Empty:
            print "Empty Pipe"
        finally:
            return str

    def stop(self):
        if self.mplayer_isrunning():
            self.player_process.stdin.write("quit\n")
            self.player_process.stdin.flush()
            print self.emptypipe()
        self.player_process = None