Example #1
0
    def __init__(self):
        QWidget.__init__(self)
        self.ui = Ui_Main()
        self.ui.setupUi(self)

        self.connect_ui()
        self.show()

        self._dispatcher = CommandDispatcher()

        self._who_to_call = {}

        self._response_poller = QTimer(self)
        self._response_poller.timeout.connect(self._check_core_responses)
        self._response_poller.start(100)  # milliseconds
Example #2
0
    def __init__(self, *args):
        super(Main, self).__init__(*args)
        self.ui = Ui_Main()
        self.ui.setupUi(self)
        icon = QtGui.QIcon("favicon.ico")
        self.setWindowIcon(icon)
        self.download_windows = File_Manager()

        self.date = datetime.fromisoformat('2011-11-04T00:00:00')
        self.state = True
        self.ui.time.setText(self.date.strftime('%H:%M:%S'))

        self.ui.dialog.clicked.connect(self.show_dialog)
        self.ui.video.clicked.connect(self.on_video)
        self.ui.file.clicked.connect(self.file_browser)
        self.ui.set_ip.clicked.connect(self.set_ip)
        self.ui.file_2.clicked.connect(self.show_files)

        self.record_state = QTimer()
        self.record_state.setInterval(1000)
        self.record_state.timeout.connect(self.onTimerOut)
        self.runing_state = QTimer()
        self.runing_state.setInterval(1000)
        self.stopEvent = threading.Event()
        self.stopEvent.clear()
Example #3
0
    def __init__(self):
        super(Main, self).__init__()
        self.ui = Ui_Main()
        self.ui.setupUi(self)

        self.st = SerialThread()
        self.st.dataReady.connect(self.show_string, QtCore.Qt.QueuedConnection)

        self.show()
Example #4
0
class Main(QtGui.QMainWindow):
    def __init__(self):
        super(Main, self).__init__()
        self.ui = Ui_Main()
        self.ui.setupUi(self)

        self.st = SerialThread()
        self.st.dataReady.connect(self.show_string, QtCore.Qt.QueuedConnection)

        self.show()

    def show_string(self, string):
        self.ui.lineEdit.setText(string)

    def main():
        app = QtGui.QApplication(sys.argv)
        m = Main()
        sys.exit(app.exec_())
Example #5
0
    def __init__(self, user):
        QMainWindow.__init__(self)
        self.ui = Ui_Main()
        self.ui.setupUi(self)
        self.user = user

        self.filename = ""
        self.is_change_saved = True
        self.goaltime = 300

        self.ui.actionNew.triggered.connect(self.new)
        self.ui.actionOpen.triggered.connect(self.open)
        self.ui.actionSave.triggered.connect(self.save)
        self.ui.actionSave_as.triggered.connect(self.save_as)
        self.ui.actionExit.triggered.connect(self.exitapp)
        self.ui.actionUndo.triggered.connect(self.ui.textEdit_Script.undo)
        self.ui.actionRedo.triggered.connect(self.ui.textEdit_Script.redo)
        self.ui.actionCopy.triggered.connect(self.ui.textEdit_Script.copy)
        self.ui.actionCut.triggered.connect(self.ui.textEdit_Script.cut)
        self.ui.actionPaste.triggered.connect(self.ui.textEdit_Script.paste)
        self.ui.actionSet_Time.triggered.connect(self.dialog_settime)
        self.ui.actionFont.triggered.connect(self.change_font)
        self.ui.actionColor.triggered.connect(self.fontColor)
        self.ui.actionBold.triggered.connect(self.bold)
        self.ui.actionItalic.triggered.connect(self.italic)
        self.ui.actionUnderline.triggered.connect(self.underline)
        self.ui.actionKey_Time_Line.triggered.connect(self.toggle_left)
        self.ui.actionTime.triggered.connect(self.toggle_time)
        self.ui.actionWord_Count.triggered.connect(self.toggle_word_count)
        self.ui.actionSide_Notes.triggered.connect(self.toggle_side_notes)
        self.ui.actionYour_Account.triggered.connect(self.yourAccount)
        self.ui.actionLogout.triggered.connect(self.logout)
        self.ui.actionAbout.triggered.connect(self.about)
        self.ui.actionAbout_Qt_lisence.triggered.connect(self.aboutQt)

        self.ui.btn_plus.clicked.connect(self.addlist)
        self.ui.btn_minus.clicked.connect(self.deletelist)

        self.ui.textEdit_Script.textChanged.connect(self.updateInfo)

        self.ui.current_time_label.setText("00:00")
        self.ui.word_count_label.setText(
            str(self.secondToWord(self.goaltime)) + " words to " +
            str(self.secondToTime(self.goaltime)))
Example #6
0
    def __init__(self, parent=None):
        super(MainWidget, self).__init__(parent)

        self.ui = Ui_Main()
        self.ui.setupUi(self)

        self.ui.lcdTimer.display('00:00:00')

        self.loggedTime = 0
        self.bufferedTime = 0
        self.elapsed = QtCore.QTime()
        self.time = QtCore.QTime()
        self.timer = QtCore.QTimer()
        self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.updateTime)

        self.model = QtSql.QSqlQueryModel()
        self.model.setQuery("SELECT name FROM projects WHERE is_active=1")
        self.ui.cboProjects.setModel(self.model)
Example #7
0
class Main(QMainWindow):
    def __init__(self, user):
        QMainWindow.__init__(self)
        self.ui = Ui_Main()
        self.ui.setupUi(self)
        self.user = user

        self.filename = ""
        self.is_change_saved = True
        self.goaltime = 300

        self.ui.actionNew.triggered.connect(self.new)
        self.ui.actionOpen.triggered.connect(self.open)
        self.ui.actionSave.triggered.connect(self.save)
        self.ui.actionSave_as.triggered.connect(self.save_as)
        self.ui.actionExit.triggered.connect(self.exitapp)
        self.ui.actionUndo.triggered.connect(self.ui.textEdit_Script.undo)
        self.ui.actionRedo.triggered.connect(self.ui.textEdit_Script.redo)
        self.ui.actionCopy.triggered.connect(self.ui.textEdit_Script.copy)
        self.ui.actionCut.triggered.connect(self.ui.textEdit_Script.cut)
        self.ui.actionPaste.triggered.connect(self.ui.textEdit_Script.paste)
        self.ui.actionSet_Time.triggered.connect(self.dialog_settime)
        self.ui.actionFont.triggered.connect(self.change_font)
        self.ui.actionColor.triggered.connect(self.fontColor)
        self.ui.actionBold.triggered.connect(self.bold)
        self.ui.actionItalic.triggered.connect(self.italic)
        self.ui.actionUnderline.triggered.connect(self.underline)
        self.ui.actionKey_Time_Line.triggered.connect(self.toggle_left)
        self.ui.actionTime.triggered.connect(self.toggle_time)
        self.ui.actionWord_Count.triggered.connect(self.toggle_word_count)
        self.ui.actionSide_Notes.triggered.connect(self.toggle_side_notes)
        self.ui.actionYour_Account.triggered.connect(self.yourAccount)
        self.ui.actionLogout.triggered.connect(self.logout)
        self.ui.actionAbout.triggered.connect(self.about)
        self.ui.actionAbout_Qt_lisence.triggered.connect(self.aboutQt)

        self.ui.btn_plus.clicked.connect(self.addlist)
        self.ui.btn_minus.clicked.connect(self.deletelist)

        self.ui.textEdit_Script.textChanged.connect(self.updateInfo)

        self.ui.current_time_label.setText("00:00")
        self.ui.word_count_label.setText(
            str(self.secondToWord(self.goaltime)) + " words to " +
            str(self.secondToTime(self.goaltime)))

    def new(self):
        if not self.is_change_saved:
            popup = QtWidgets.QMessageBox(self)
            popup.setWindowTitle("Save")
            popup.setIcon(QtWidgets.QMessageBox.Warning)
            popup.setText("The document has been modified.")
            popup.setInformativeText("Do you want to save your changes?")
            popup.setStandardButtons(QtWidgets.QMessageBox.Save
                                     | QtWidgets.QMessageBox.Cancel
                                     | QtWidgets.QMessageBox.Discard)
            popup.setDefaultButton(QtWidgets.QMessageBox.Save)
            answer = popup.exec_()

            if answer == QtWidgets.QMessageBox.Save:
                self.save()
            elif answer == QtWidgets.QMessageBox.Discard:
                pass
            else:
                return

        self.ui.textEdit_Script.clear()
        self.ui.textEdit_Sidenotes.clear()
        self.ui.TimeList.clear()
        self.ui.TimeList.addItem("Introduction")
        self.ui.TimeList.addItem("Body")
        self.ui.TimeList.addItem("Conclusion")
        for index in range(self.ui.TimeList.count()):
            item = self.ui.TimeList.item(index)
            item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)
        self.filename = ""
        self.setWindowTitle("Script Spinner")

    def open(self):
        self.filename = QtWidgets.QFileDialog.getOpenFileName(
            self, 'Open', ".", "Script Spinner File (*.ssp)")[0]

        if self.filename:
            with open(self.filename, 'rb') as f:
                timelist, script, sidenotes = pickle.load(f)
                self.ui.TimeList.clear()
                [
                    self.ui.TimeList.addItem(timelist[i])
                    for i in range(0, len(timelist))
                ]
                for index in range(self.ui.TimeList.count()):
                    item = self.ui.TimeList.item(index)
                    item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)
                self.ui.textEdit_Script.setText(script)
                self.ui.textEdit_Sidenotes.setText(sidenotes)

                self.setWindowTitle("Script Spinner - " + self.filename)

    def save(self):
        timelist = [
            str(self.ui.TimeList.item(i).text())
            for i in range(self.ui.TimeList.count())
        ]
        script = self.ui.textEdit_Script.toHtml()
        sidenotes = self.ui.textEdit_Sidenotes.toHtml()

        if not self.filename:
            self.filename = QtWidgets.QFileDialog.getSaveFileName(
                self, 'Save', None, "Script Spinner File (*.ssp)")[0]

        if self.filename:
            if not self.filename.endswith(".ssp"):
                self.filename += ".ssp"

            with open(self.filename, 'wb') as f:
                pickle.dump([timelist, script, sidenotes], f)

            self.setWindowTitle("Script Spinner - " + self.filename)
            self.is_change_saved = True

    def save_as(self):
        timelist = [
            str(self.ui.TimeList.item(i).text())
            for i in range(self.ui.TimeList.count())
        ]
        script = self.ui.textEdit_Script.toHtml()
        sidenotes = self.ui.textEdit_Sidenotes.toHtml()

        self.filename = QtWidgets.QFileDialog.getSaveFileName(
            self, 'Save', None, "Script Spinner File (*.ssp)")[0]

        if self.filename:
            if not self.filename.endswith(".ssp"):
                self.filename += ".ssp"

            with open(self.filename, 'wb') as f:
                pickle.dump([timelist, script, sidenotes], f)

            self.setWindowTitle("Script Spinner - " + self.filename)
            self.is_change_saved = True

    def exitapp(self):
        self.close()

    def bold(self):
        if self.ui.textEdit_Script.fontWeight() == QtGui.QFont.Bold:
            self.ui.textEdit_Script.setFontWeight(QtGui.QFont.Normal)
        else:
            self.ui.textEdit_Script.setFontWeight(QtGui.QFont.Bold)

    def italic(self):
        state = self.ui.textEdit_Script.fontItalic()
        self.ui.textEdit_Script.setFontItalic(not state)

    def underline(self):
        state = self.ui.textEdit_Script.fontUnderline()
        self.ui.textEdit_Script.setFontUnderline(not state)

    def change_font(self):
        ok, font = QFontDialog.getFont()
        if ok:
            self.ui.textEdit_Script.setCurrentFont(font)

    def fontColor(self):
        color = QtWidgets.QColorDialog.getColor()
        self.ui.textEdit_Script.setTextColor(color)

    def toggle_left(self):
        if self.ui.Left_widget.isVisible():
            self.ui.Left_widget.hide()
        else:
            self.ui.Left_widget.show()

    def toggle_right(self):
        if not self.ui.Right_widget.isVisible():
            self.ui.Right_widget.show()

        if not (self.ui.time.isVisible() or self.ui.word_count.isVisible()
                or self.ui.sidenotes.isVisible()):
            self.ui.Right_widget.hide()

    def toggle_time(self):
        if self.ui.time.isVisible():
            self.ui.time.hide()
        else:
            self.ui.time.show()

        self.toggle_right()

    def toggle_word_count(self):
        if self.ui.word_count.isVisible():
            self.ui.word_count.hide()
        else:
            self.ui.word_count.show()

        self.toggle_right()

    def toggle_side_notes(self):
        if self.ui.sidenotes.isVisible():
            self.ui.sidenotes.hide()
        else:
            self.ui.sidenotes.show()

        self.toggle_right()

    def logout(self):
        self.user.logout()
        self.close()

    def yourAccount(self):
        QDesktopServices.openUrl(QUrl("https://scriptspinner.com/account/"))

    def about(self):
        QMessageBox.information(
            self, "About",
            "Script Spinner is simple and complete software solution for your presentation needs\nCOPYRIGHT 2020 Script Spinner. All rights reserved"
        )

    def aboutQt(self):
        QApplication.instance().aboutQt()

    def addlist(self):
        text, ok = QInputDialog.getText(self, 'Add New Time Line',
                                        'Enter the name:')
        if ok:
            self.ui.TimeList.addItem(text)
            for index in range(self.ui.TimeList.count()):
                item = self.ui.TimeList.item(index)
                item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)

    def deletelist(self):
        listItems = self.ui.TimeList.selectedItems()
        if not listItems:
            return
        for item in listItems:
            self.ui.TimeList.takeItem(self.ui.TimeList.row(item))

    def dialog_settime(self):
        sec, ok = QInputDialog.getInt(self, "Set Time",
                                      "Enter a goal time in seconds")
        if ok:
            self.goaltime = sec
        self.updateInfo()

    def wordcount(self):
        text = self.ui.textEdit_Script.toPlainText()
        words = len(text.split())
        return words

    def howManyWord(self, word, second, wpm=130):
        self.secondToWord(word, wpm)

    def wordToSecond(self, word, wpm=130, base=15):
        return base * round((word / wpm * 60) / base)

    def secondToWord(self, second, wpm=130, base=15):
        return base * round((second * wpm / 60) / base)

    def secondToTime(self, second):
        if second > 3600:
            sec = time.strftime("%H:%M:%S", time.gmtime(second))
        else:
            sec = time.strftime("%M:%S", time.gmtime(second))
        return sec

    def updateInfo(self):
        wc_sec = self.wordToSecond(self.wordcount())
        wc_time = self.secondToTime(wc_sec)
        self.ui.current_time_label.setText(str(wc_time))

        goal_word = self.secondToWord(self.goaltime)
        rm_word = goal_word - self.wordcount()

        self.ui.word_count_label.setText(
            str(rm_word) + " words to " +
            str(self.secondToTime(self.goaltime)))

        self.is_change_saved = False

    def closeEvent(self, event):
        if self.is_change_saved:
            event.accept()
        else:
            popup = QtWidgets.QMessageBox(self)
            popup.setWindowTitle("Save")
            popup.setIcon(QtWidgets.QMessageBox.Warning)
            popup.setText("The document has been modified.")
            popup.setInformativeText("Do you want to save your changes?")
            popup.setStandardButtons(QtWidgets.QMessageBox.Save
                                     | QtWidgets.QMessageBox.Cancel
                                     | QtWidgets.QMessageBox.Discard)
            popup.setDefaultButton(QtWidgets.QMessageBox.Save)
            answer = popup.exec_()

            if answer == QtWidgets.QMessageBox.Save:
                self.save()
            elif answer == QtWidgets.QMessageBox.Discard:
                event.accept()
            else:
                event.ignore()
Example #8
0
class Main(QWidget):
    def __init__(self):
        QWidget.__init__(self)
        self.ui = Ui_Main()
        self.ui.setupUi(self)

        self.connect_ui()
        self.show()

        self._dispatcher = CommandDispatcher()

        self._who_to_call = {}

        self._response_poller = QTimer(self)
        self._response_poller.timeout.connect(self._check_core_responses)
        self._response_poller.start(100)  # milliseconds

    def closeEvent(self, event):
        print("[UI] closeEvent")
        self._dispatcher.stop()
        QWidget.closeEvent(self, event)

    def connect_ui(self):
        self.ui.pbLogin.clicked.connect(self.user_login)
        self.ui.pbLogout.clicked.connect(self.user_logout)

        self.ui.pbEIPStart.clicked.connect(self.eip_start)
        self.ui.pbEIPStop.clicked.connect(self.eip_stop)
        # self.ui.pbEIPStatus.clicked.connect(self.eip_status)

        self.ui.pbMailStart.clicked.connect(self.mail_start)
        self.ui.pbMailStop.clicked.connect(self.mail_stop)
        self.ui.pbMailStatus.clicked.connect(self.mail_status)

        self.ui.pbCoreStatus.clicked.connect(self.core_status)

    def _on(self, uid, callme):
        """
        On given `uid` ready, call `callme`
        """
        print("Scheduled uid, callable: {0!r}".format((uid, callme)))
        self._who_to_call[uid] = callme

    def _check_core_responses(self):
        """
        Check if the core has responses for us and call the specified callable
        if it has.
        """
        try:
            uid, callme = self._who_to_call.popitem()
        except KeyError:  # dict empty
            return
        except Exception as e:
            print("Unexpected error: {0!r}".format(e))

        try:
            r = self._dispatcher.get_response(uid)
        except KeyError:  # no such uid
            return

        if r is not None:
            callme(r)
        else:
            # there is no response yet, add it again
            self._who_to_call[uid] = callme

    def user_login(self):
        print("[UI] User: login")
        username = self.ui.leUsername.text()
        password = self.ui.lePassword.text()
        ruid = self._dispatcher.user_login(username, password)
        self._on(ruid, self._update_login_status)

    def _update_login_status(self, data):
        print("[UI] login status: {0!r}".format(data))
        self.ui.lblLoginStatus.setText(data.decode('utf-8'))

    def user_logout(self):
        print("[UI] User: logout")
        username = self.ui.leUsername.text()
        password = self.ui.lePassword.text()
        self._dispatcher.user_logout(username, password)

    def eip_start(self):
        print("[UI] EIP: start")
        self._dispatcher.eip_start()

    # def eip_status(self):
    #     print("[UI] EIP: status")
    #     self._dispatcher.eip_status()

    def eip_stop(self):
        print("[UI] EIP: stop")
        self._dispatcher.eip_stop()

    def mail_start(self):
        print("[UI] Mail: start")
        # self._dispatcher.mail_start()

    def mail_stop(self):
        print("[UI] Mail: stop")
        # self._dispatcher.mail_stop()

    def mail_status(self):
        print("[UI] Mail: status")
        ruid = self._dispatcher.mail_status()
        self._on(ruid, self._update_mail_status)

    def _update_mail_status(self, data):
        print("[UI] mail status: {0!r}".format(data))
        self.ui.lblMailStatus.setText(data.decode('utf-8'))

    def core_start(self):
        # TODO: this should run a subprocess for the core
        print("[UI] Core: start - NOT IMPLEMENTED")
        # self._dispatcher.core_start()

    def core_status(self):
        print("[UI] Core: status")
        ruid = self._dispatcher.core_get_status()
        self._on(ruid, self._update_core_status)

    def _update_core_status(self, data):
        print("[UI] core status: {0!r}".format(data))
        self.ui.lblCoreStatus.setText(data.decode('utf-8'))

    def core_stop(self):
        print("[UI] Core: stop")
        self._dispatcher.core_shutdown()
Example #9
0
class MainWidget(QtGui.QWidget):
    def __init__(self, parent=None):
        super(MainWidget, self).__init__(parent)

        self.ui = Ui_Main()
        self.ui.setupUi(self)

        self.ui.lcdTimer.display('00:00:00')

        self.loggedTime = 0
        self.bufferedTime = 0
        self.elapsed = QtCore.QTime()
        self.time = QtCore.QTime()
        self.timer = QtCore.QTimer()
        self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.updateTime)

        self.model = QtSql.QSqlQueryModel()
        self.model.setQuery("SELECT name FROM projects WHERE is_active=1")
        self.ui.cboProjects.setModel(self.model)

    @QtCore.Slot()
    def on_btnStartStop_clicked(self):
        if self.timer.isActive():
            self.ui.btnStartStop.setText('S&tart')
            self.ui.btnReset.setEnabled(True)
            self.bufferedTime += self.time.elapsed()
            self.timer.stop()
        else:
            self.ui.btnStartStop.setText('S&top')
            self.ui.btnReset.setEnabled(False)
            self.time.restart()
            self.timer.start(41)

    @QtCore.Slot()
    def on_btnReset_clicked(self):
        self.resetTimer()

    @QtCore.Slot()
    def on_btnSave_clicked(self):
        project_name = self.ui.cboProjects.currentText()
        q = "SELECT id FROM projects WHERE name='%s'" % project_name
        query = QtSql.QSqlQuery()
        query.exec_(q)
        query.next()
        project_id = query.value(0)
        used_time = (self.elapsed.hour() * 60 * 60) + (self.elapsed.minute() * 60) + self.elapsed.second()
        if used_time > 0:
            q = "INSERT INTO logs VALUES(%d, %d, '%s')" % (project_id, used_time, datetime.datetime.now())
            query.exec_(q)

        self.resetTimer()

    @QtCore.Slot()
    def on_btnQuit_clicked(self):
        QtGui.qApp.quit()

    @QtCore.Slot()
    def on_btnManage_clicked(self):
        dialog = ProjectsManagementDialog()
        if not dialog.exec_():
            self.updateProjectsList()

    def resetTimer(self):
        self.bufferedTime = 0
        self.time.restart()
        self.ui.lcdTimer.display('00:00:00')

    def updateTime(self):
        self.elapsed.setHMS(0, 0, 0, 0)
        self.elapsed = self.elapsed.addMSecs(self.time.elapsed())
        self.elapsed = self.elapsed.addMSecs(self.bufferedTime)
        text = self.elapsed.toString('hh:mm:ss')
        self.ui.lcdTimer.display(text)

        usedTime = (self.elapsed.hour() * 60 * 60) + (self.elapsed.minute() * 60) + self.elapsed.second()
        if usedTime - self.loggedTime == 300:  # logs every 5 minutes
            self.loggedTime = usedTime
            usedTimeStr = self.elapsed.toString('hh:mm:ss')
            data_dir = create_data_dir()
            to_file = '%s/mywela.log' % data_dir
            f = open(to_file, 'a')
            text = '%s => %s (%s seconds)\n' % (datetime.datetime.now(), usedTimeStr, usedTime)
            f.write(text)
            f.close()

    def updateProjectsList(self):
        self.model.setQuery("SELECT name FROM projects WHERE is_active=1")
        self.ui.cboProjects.setModel(self.model)