コード例 #1
0
ファイル: SrtWindow.py プロジェクト: tml/SafetyPlay
    def __init__(self, parent=None):
        super(SrtList, self).__init__(parent)
        self.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
        self.setAcceptDrops(True)
        self.safelist = ['.srt',
                         '.lrc',
                         '.txt']
        self.segments = []
        self.srt = ''
        self.segment_editor = SegmentEditor()
        self.offset_editor = OffsetEditor()
        self.offset_editor.setWindowTitle('Safety Play - SRT Offset Editor')

        self.save_closer = SaveCloser()
        self.save_closer.start()

        self.save_message = Saved(self)
        self.save_message.hide()

        self.reds, self.oranges, self.yellows, self.greens = self.get_vulgars()

        self.setupActions()
コード例 #2
0
ファイル: SrtWindow.py プロジェクト: tml/SafetyPlay
class SrtList(QtGui.QListWidget):
    time_clicked = QtCore.Signal(str)
    deleted = QtCore.Signal(int)

    start_time_request = QtCore.Signal(int)
    end_time_request = QtCore.Signal(int)
    edit_segment_request = QtCore.Signal(Segment)
    inserted = QtCore.Signal(Segment, int)

    edited = QtCore.Signal()
    save_completed = QtCore.Signal()
    
    def __init__(self, parent=None):
        super(SrtList, self).__init__(parent)
        self.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
        self.setAcceptDrops(True)
        self.safelist = ['.srt',
                         '.lrc',
                         '.txt']
        self.segments = []
        self.srt = ''
        self.segment_editor = SegmentEditor()
        self.offset_editor = OffsetEditor()
        self.offset_editor.setWindowTitle('Safety Play - SRT Offset Editor')

        self.save_closer = SaveCloser()
        self.save_closer.start()

        self.save_message = Saved(self)
        self.save_message.hide()

        self.reds, self.oranges, self.yellows, self.greens = self.get_vulgars()

        self.setupActions()

    def setupActions(self):
        self.itemDoubleClicked.connect(self.goto)
        self.save_closer.time_up.connect(self.hide_save)
        self.segment_editor.ok_signal.connect(self.edit_segment)
        self.segment_editor.cancel.clicked.connect(self.set_enabled)
        self.offset_editor.ok_signal.connect(self.change_time)

    def get_vulgars(self):
        file = open(path() + '/' + 'vulgar.txt', 'r')
        lines = file.readlines()
        file.close()
        redgroup = []
        orangegroup = []
        yellowgroup = []
        greengroup = []
        doing_red = False
        doing_orange = False
        doing_yellow = False
        doing_green = False
        for i in range(len(lines)):
            if lines[i].rstrip() == '#--RED--#':
                doing_red = True
                doing_orange = False
                doing_yellow = False
                doing_green = False
            elif lines[i].rstrip() == "#--ORANGE--#":
                doing_red = False
                doing_orange = True
                doing_yellow = False
                doing_green = False
            elif lines[i].rstrip() == "#--YELLOW--#":
                doing_red = False
                doing_orange = False
                doing_yellow = True
                doing_green = False
            elif lines[i].rstrip() == "#--GREEN--#":
                doing_red = False
                doing_orange = False
                doing_yellow = False
                doing_green = True

            if (not lines[i].startswith('#')
                and not lines[i] == '\n'
                and not lines[i] == ''):
                if doing_red:
                    redgroup.append(lines[i].rstrip())
                elif doing_orange:
                    orangegroup.append(lines[i].rstrip())
                elif doing_yellow:
                    yellowgroup.append(lines[i].rstrip())
                elif doing_green:
                    greengroup.append(lines[i].rstrip())
        return redgroup, orangegroup, yellowgroup, greengroup
        
    def goto(self, item):
        removed_spaces = item.text().split(' ')[0]
        removed_start_bracket = removed_spaces.replace('[','')
        removed_end_bracket = removed_start_bracket.replace(']','')
        self.time_clicked.emit(removed_end_bracket)

    def add_srt(self, srt):
        self.clear()
        if srt.endswith('.srt'):
            self.srt = srt
            self.segments = parse_srt(srt)
            self.add_segments(self.segments)

        elif srt.endswith('.lrc'):
            self.edited.emit()
            self.srt = srt[:len(srt) - 4] + '.srt'
            self.segments = parse_lrc(srt)
            split_lines(self.segments)
            self.add_segments(self.segments)

        elif srt.endswith('.txt'):
            self.edited.emit()
            srt[:len(srt) - 4] + '.srt'
            self.segments = parse_txt(srt)
            split_lines(self.segments)
            self.add_segments(self.segments)

    def set_enabled(self):
        self.setEnabled(True)
        
    def add_segments(self, segments):
        for i in range(len(segments)):
            start = '[' + sec_to_hms(segments[i].start_time) + '] '
            end = ' [' + sec_to_hms(segments[i].end_time) + ']'
            if not segments[i].topline == '':
                words = segments[i].topline + ' ' + segments[i].bottomline
            else:
                words = segments[i].bottomline

            new_item = QtGui.QListWidgetItem()
            new_item.setText(start + words + end)
            r = self.reds
            o = self.oranges
            y = self.yellows
            g = self.greens
            new_item.setBackground(QtGui.QColor(check_vulgar(r, o, y, g, words)))
            self.addItem(new_item)
        self.setCurrentItem(self.item(0))

    def change_time(self, time):
        max_time = convert_to_seconds('23:59:59,999')
        if not self.segments == []:
            self.clear()
            for i in range(len(self.segments)):
                if not self.segments[i].start_time + time < 0:
                    if self.segments[i].start_time + time > max_time:
                        self.segments[i].start_time = max_time
                    else:
                        new_start = self.segments[i].start_time + time
                        self.segments[i].start_time = new_start
                else:
                    self.segments[i].start_time = 0
                if not self.segments[i].end_time + time < 0:
                    if self.segments[i].end_time + time > max_time:
                        self.segments[i].end_time = max_time
                    else:
                        new_end = self.segments[i].end_time + time
                        self.segments[i].end_time = new_end
                else:
                    self.segments[i].end_time = 0

            self.add_segments(self.segments)
            self.edited.emit()

    def save_to_file(self):
        if self.srt != '':
            write_srt(self.segments, self.srt)
            self.save_completed.emit()
            self.show_save_message()
        else:
            self.browse_to_srt()

    def browse_to_srt(self):
        userhome = os.path.expanduser('~')
        file, _ = QtGui.QFileDialog.getSaveFileName(
            self, 'Save SRT File', userhome, "*.srt")
        if not file == '':
            self.srt = file
            self.save_to_file()

    def show_save_message(self):
        self.save_message.resize(self.width(), self.height())
        self.save_message.show()
        self.save_closer.start()

    def hide_save(self):
        self.save_message.hide()

    def dragEnterEvent(self, event):
        if event.mimeData().hasUrls:
            path = str(event.mimeData().urls()[0].toLocalFile())
            ending = path[len(path)-4::]
            if ending in self.safelist:
                event.accept()
            else:
                event.ignore()

    def dragMoveEvent(self, event):
        if event.mimeData().hasUrls:
            event.setDropAction(QtCore.Qt.CopyAction)
            event.accept()
        else:
            event.ignore()

    def dropEvent(self, event):
        if event.mimeData().hasUrls:
            self.add_srt(str(event.mimeData().urls()[0].toLocalFile()))
        else:
            event.ignore()

    def redo_segment_numbers(self):
        for i in range(len(self.segments)):
            self.segments[i].segment_number = i + 1

    def insert_item(self, bottom):
        #bottom = 1, top = 0       
        item = QtGui.QListWidgetItem()
        item.setText('[00:00:00,000][00:00:00,000]')
        seg = Segment()
        
        seg.topline = ''
        seg.bottomline = ''
        seg.start_time = 0
        seg.end_time = 0
        
        if len(self.selectedItems()) > 0:
            index = self.row(self.selectedItems()[0])
            self.insertItem(index + bottom, item)
            seg.segment_number = index + bottom + 1
            self.segments.insert(index + bottom, seg)
            self.inserted.emit(seg, index + bottom)
            self.clearSelection()
            self.setCurrentItem(self.item(index + bottom))
        else:
            self.addItem(item)
            seg.segment_number = 1
            self.segments.append(seg)
            self.setCurrentItem(self.item(0))
            self.inserted.emit(seg, 0)
            self.clearSelection()
            self.setCurrentItem(self.item(0))

        self.redo_segment_numbers()
        self.edited.emit()

    def edit_segment(self, segment):
        self.edit_segment_request.emit(segment)

    def open_edit_window(self):
        if len(self.selectedItems()) > 0:
            item = self.selectedItems()[0]
            index = self.row(item)
            self.segment_editor.set_segment(self.segments[index])
            self.segment_editor.show()
            self.segment_editor.topline_text.setFocus()
            self.setEnabled(False)

    def delete_selected(self):
        for i in self.selectedItems():
            self.deleted.emit(self.row(i))
            self.segments.pop(self.row(i))
            self.takeItem(self.row(i))
        self.redo_segment_numbers()
        self.edited.emit()

    def go_down(self):
        if self.count() > 0:
            r = self.row(self.currentItem())
            if r < self.count() - 1:
                self.setCurrentItem(self.item(r + 1))

    def go_up(self):
        if self.count() > 0:
            r = self.row(self.currentItem())
            if r > 0:
                self.setCurrentItem(self.item(r - 1))

    def dispense(self):
        if self.count() > 0:
            r = self.row(self.currentItem())
            self.start_time_request.emit(r)

    def finito(self):
        if self.count() > 0:
            r = self.row(self.currentItem())
            self.end_time_request.emit(r)

    def keyPressEvent(self, event):
        key = event.key()
        delete = QtCore.Qt.Key_Delete
        #Deleting an item
        if key == delete and len(self.selectedItems()) > 0:
            self.delete_selected()