offlate

Add enrolling wizard for first-time users.

Julien LepillerMon Dec 06 00:36:49+0100 2021

4c99b39

Add enrolling wizard for first-time users. This replaces the initial setup screen that used the same window as the settings manager, which is a bit confusing. The rest of the app is unchanged.

CHANGELOG.md

 ### Improvements and features ###
 * First-time users now get a specific window to help them with initial configuration.
 * Fixed TS format not setting the obsolete flag when saving.
 * Whitespace characters are shown with a small symbol in the editor. Spaces get
   a small middle dot, no-break spaces get a line underneath. Tabs are also represented.

offlate/ui/config/settings.py

         self.welcomeWidget = SettingsWidget(self, self.manager)
         self.setCentralWidget(self.welcomeWidget)
 class SystemSettingsWindow(QDialog):
     def __init__(self, manager, system = -1, parent = None):
 class SystemSettingsWidget(QWidget):
     def __init__(self, manager, system = -1, parent=None):
         super().__init__(parent)
         self.system = systems[system]
         self.manager = manager
         formBox.setLayout(formLayout)
         vbox.addWidget(formBox)
         buttons = QHBoxLayout()
         buttons.addStretch(1)
         okbutton = QPushButton(self.tr("OK"))
         buttons.addWidget(okbutton)
         okbutton.clicked.connect(self.close)
         vbox.addLayout(buttons)
         self.setLayout(vbox)
     def update(self):
             widget = self.widgets[key][s.key]
             self.data[key][s.key] = widget.content()
 class SystemSettingsWindow(QDialog):
     def __init__(self, manager, system = -1, parent = None):
         super().__init__(parent)
         self.widget = SystemSettingsWidget(manager, system, self)
         buttons = QHBoxLayout()
         buttons.addStretch(1)
         okbutton = QPushButton(self.tr("OK"))
         buttons.addWidget(okbutton)
         okbutton.clicked.connect(self.close)
         vbox = QVBoxLayout()
         vbox.addWidget(self.widget)
         vbox.addLayout(buttons)
         self.setLayout(vbox)
 class SettingsWidget(QWidget):
     def __init__(self, parent=None, manager=None, welcome=False):
     def __init__(self, parent=None, manager=None):
         super().__init__(parent)
         self.parent = parent
         self.manager = manager
         self.welcome = welcome
         self.initUI()
     def initUI(self):
         vbox = QVBoxLayout()
         if self.welcome:
             filename = os.path.dirname(__file__) + '/../data/icon.png'
             icon = QPixmap(filename)
             label = QLabel(self)
             label.setPixmap(icon)
             label.setAlignment(Qt.AlignCenter)
             name = QLabel(self)
             name.setText("Offlate")
             name.setAlignment(Qt.AlignCenter)
             font = name.font()
             font.setPointSize(64)
             font.setBold(True)
             name.setFont(font)
             titlebox = QHBoxLayout()
             titlebox.addWidget(label)
             titlebox.addWidget(name)
             vbox.addLayout(titlebox)
             line = QFrame(self)
             line.setFrameShape(QFrame.HLine)
             line.setFrameShadow(QFrame.Sunken)
             vbox.addWidget(line)
             explain = QLabel(self)
             explain.setText(self.tr("Welcome to Offlate! Offlate is a tool for \
 software translators who don't want to use dozens of different interfaces to \
 get their job done. This first screen will help you configure Offlate for your \
 first use!"))
             explain.setWordWrap(True)
             vbox.addWidget(explain)
         formExplain = QLabel(self)
         formExplain.setText(self.tr("First, we need to know your name and email \
         form.addRow(QLabel(self.tr("Your email address:")), self.emailWidget)
         vbox.addLayout(form)
         if self.welcome:
             systemExplain = QLabel(self)
             systemExplain.setText(self.tr("Offlate is able to connect to multiple \
 translation service interfaces. Each service requires its own configuration \
 settings that you can configure later. For now, we're done with the basics! \
 When you select a new project, you will be able to configure the system if it \
 requires any additional information. You can configure each system you need now \
 +or come back later by clicking on the setting button in offlate."))
             systemExplain.setWordWrap(True)
             vbox.addWidget(systemExplain)
         systemsbox = QGridLayout()
         x = 0
         y = 0
         vbox.addStretch(1)
         buttonbox = QHBoxLayout()
         buttonbox.addStretch(1)
         if self.welcome:
             closeButton = QPushButton(self.tr("Cancel"))
             closeButton.clicked.connect(self.quit)
             buttonbox.addWidget(closeButton)
         doneButton = QPushButton(self.tr("Done!"))
         doneButton.clicked.connect(self.done)
         buttonbox.addWidget(doneButton)
         self.quit()
     def quit(self):
         if self.welcome:
             qApp.quit()
         else:
             self.parent.hide()
         self.parent.hide()
     def openSettings(self, system):
         w = SystemSettingsWindow(self.manager, system, self)

offlate/ui/data/illustration.png unknown status 1

Binary data

offlate/ui/data/illustration.xcf unknown status 1

Binary data

offlate/ui/main.py

 from PyQt5.QtCore import *
 from .manager import ProjectManagerWindow
 from .config.welcome import WelcomeWindow
 from .welcome import WelcomeWindow
 from ..data.common import REPO, EMAIL
         return
     w.projectManagerWidget.manager.setNotNew()
     w.projectManagerWidget.filter()
     try:
         w.show()
         exit = app.exec_()

offlate/ui/manager.py

                 self.tr('Fetching project {}...').format(name, progress))
     def finishReport(self, name):
         self.filter()
         self.actionProgress.setValue(0)
         self.actionProgress.setEnabled(False)
         self.actionLabel.setText("")
         else:
             self.signals.restart_required.emit(self.name, self.lang, self.system,
                     self.info, self.error)
         self.parent.filter()
 class EditRunnable(RunnableCallback):
     def __init__(self, parent, name, lang, system, info):

offlate/ui/new.py

 from ..systems.list import *
 from .multiplelineedit import MultipleLineEdit
 class NewWindow(QDialog):
     def __init__(self, manager, parent = None, name = "",
             lang = "", system = 0, info = None):
 class PredefinedProjectWidget(QWidget):
     currentItemChanged = pyqtSignal()
     def __init__(self, parent = None):
         super().__init__(parent)
         self.name = name
         self.lang = lang
         self.system = system
         self.info = info
         self.manager = manager
         self.askNew = False
         self.setProperty("data", {})
         self.initUI()
     def initUI(self):
         hbox = QHBoxLayout()
         predefinedbox = QVBoxLayout()
         self.searchfield = QLineEdit()
         self.searchfield.addAction(QIcon.fromTheme("search"), QLineEdit.LeadingPosition)
         predefinedbox.addWidget(self.searchfield)
         self.predefinedprojects = QListWidget()
         with open(os.path.dirname(__file__) + '/../data/data.json') as f:
                 self.predefinedprojects.addItem(item)
         predefinedbox.addWidget(self.predefinedprojects)
         self.predefinedprojects.currentItemChanged.connect(self.itemChanged)
         self.searchfield.textChanged.connect(self.filter)
         self.setLayout(predefinedbox)
     def itemChanged(self):
         item = self.currentItem()
         if item is None:
             self.setProperty("data", {})
         self.setProperty("data", item.data(Qt.UserRole))
         self.currentItemChanged.emit()
     def currentItem(self):
         return self.predefinedprojects.currentItem()
     def filter(self):
         search = self.searchfield.text()
         self.predefinedprojects.clear()
         regexp = re.compile(".*"+search)
         for d in self.projectdata:
             if regexp.match(d['name']):
                 item = QListWidgetItem(d['name'])
                 item.setData(Qt.UserRole, d)
                 self.predefinedprojects.addItem(item)
     def currentData(self):
         return self.property("data")
 class AdvancedProjectWidget(QWidget):
     modified = pyqtSignal()
     def __init__(self, parent = None, name = "", lang = "", system = 0, info = None):
         super().__init__(parent)
         self.name = name
         self.lang = lang
         self.system = system
         self.info = info
         self._registerAdditionalFields()
         self.initUI()
     def initUI(self):
         contentbox = QVBoxLayout()
         formbox = QGroupBox(self.tr("Project information"))
         self.formLayout = QFormLayout()
         self.nameWidget.textChanged.connect(self.modify)
         self.langWidget.textChanged.connect(self.modify)
         hhbox = QHBoxLayout()
         self.cancelbutton = QPushButton(self.tr("Cancel"))
         self.okbutton = QPushButton(self.tr("OK"))
         self.okbutton.setEnabled(False)
         hhbox.addWidget(self.cancelbutton)
         hhbox.addWidget(self.okbutton)
         contentbox.addWidget(formbox)
         contentbox.addLayout(hhbox)
         hbox.addLayout(predefinedbox)
         hbox.addLayout(contentbox)
         self.additionalFields = []
         for system in systems:
             fields = []
             for spec in system['system'].getProjectConfigSpec():
                 if isinstance(spec, StringConfigSpec):
                     widget = QLineEdit()
                     widget.textChanged.connect(self.modify)
                     if spec.placeholder is not None and spec.placeholder != '':
                         widget.setPlaceholderText(spec.placeholder)
                     label = QLabel(spec.name)
                     fields.append({'label': label, 'widget': widget})
                 else:
                     raise Exception("Unknown spec type: " + spec)
             self.additionalFields.append(fields)
         self.setLayout(hbox)
         self.predefinedprojects.currentItemChanged.connect(self.fill)
         self.cancelbutton.clicked.connect(self.close)
         self.okbutton.clicked.connect(self.ok)
         self.searchfield.textChanged.connect(self.filter)
         self.combo.currentIndexChanged.connect(self.othersystem)
         self.modify()
         self.othersystem()
     def ok(self):
         self.askNew = True
         self.close()
     def fill(self):
         item = self.predefinedprojects.currentItem()
         self.setLayout(contentbox)
         if item is None:
             return
         self.othersystem()
         data = item.data(Qt.UserRole)
     def fill(self, data):
         self.nameWidget.setText(data['name'])
         self.combo.setCurrentIndex(int(data['system']))
             if spec.key in data:
                 widget.setText(data[spec.key])
             i = i + 1
         self.modified.emit()
     def filter(self):
         search = self.searchfield.text()
         self.predefinedprojects.clear()
         regexp = re.compile(".*"+search)
         for d in self.projectdata:
             if regexp.match(d['name']):
                 item = QListWidgetItem(d['name'])
                 item.setData(Qt.UserRole, d)
                 self.predefinedprojects.addItem(item)
     def modify(self):
         enable = False
     def isComplete(self):
         complete = False
         if self.nameWidget.text() != '' and self.langWidget.text() != '':
             enable = True
             complete = True
             system = systems[self.combo.currentIndex()]
             fields = self.additionalFields[self.combo.currentIndex()]
             i = 0
                 if not spec.optional:
                     widget = fields[i]['widget']
                     if isinstance(widget, QLineEdit) and widget.text() == '':
                         enable = False
                         complete = False
                         break
                 i = i + 1
         self.okbutton.setEnabled(enable)
         return complete
     def wantNew(self):
         return self.askNew
     def _registerAdditionalFields(self):
         self.additionalFields = []
         for system in systems:
             fields = []
             for spec in system['system'].getProjectConfigSpec():
                 if isinstance(spec, StringConfigSpec):
                     widget = QLineEdit()
                     widget.textChanged.connect(self.modify)
                     if spec.placeholder is not None and spec.placeholder != '':
                         widget.setPlaceholderText(spec.placeholder)
                     label = QLabel(spec.name)
                     fields.append({'label': label, 'widget': widget})
                 else:
                     raise Exception("Unknown spec type: " + spec)
             self.additionalFields.append(fields)
     def getProjectName(self):
         return self.nameWidget.text()
             self.formLayout.addRow(widget['label'], widget['widget'])
             widget['widget'].show()
             widget['label'].show()
         self.setTabOrder(oldwidget, self.cancelbutton)
         self.setTabOrder(self.cancelbutton, self.okbutton)
         self.modify()
     def modify(self):
         data = {'name': self.getProjectName(), 'system': self.getProjectSystem(),
                 'system': self.getProjectSystem(), 'info': self.getProjectInfo()}
         self.setProperty("data", data)
         self.modified.emit()
 class NewWindow(QDialog):
     def __init__(self, manager, parent = None, name = "",
             lang = "", system = 0, info = None):
         super().__init__(parent)
         self.name = name
         self.lang = lang
         self.system = system
         self.info = info
         self.manager = manager
         self.askNew = False
         self.initUI()
     def initUI(self):
         vbox = QVBoxLayout()
         hbox = QHBoxLayout()
         self.predefinedprojects = PredefinedProjectWidget(self)
         self.advancedproject = AdvancedProjectWidget(self, self.name, self.lang,
                 self.system, self.info)
         hbox.addWidget(self.predefinedprojects)
         hbox.addWidget(self.advancedproject)
         self.cancelbutton = QPushButton(self.tr("Cancel"))
         self.okbutton = QPushButton(self.tr("OK"))
         self.okbutton.setEnabled(False)
         self.cancelbutton.clicked.connect(self.close)
         self.okbutton.clicked.connect(self.ok)
         self.predefinedprojects.currentItemChanged.connect(self.fill)
         self.advancedproject.modified.connect(self.modify)
         hhbox = QHBoxLayout()
         hhbox.addWidget(self.cancelbutton)
         hhbox.addWidget(self.okbutton)
         vbox.addLayout(hbox)
         vbox.addLayout(hhbox)
         self.setLayout(vbox)
         self.modify()
     def ok(self):
         self.askNew = True
         self.close()
     def fill(self):
         item = self.predefinedprojects.currentItem()
         if item is None:
             return
         data = item.data(Qt.UserRole)
         self.advancedproject.fill(data)
     def modify(self):
         self.okbutton.setEnabled(self.advancedproject.isComplete())
     def wantNew(self):
         return self.askNew
     def getProjectName(self):
         return self.advancedproject.getProjectName()
     def getProjectLang(self):
         return self.advancedproject.getProjectLang()
     def getProjectSystem(self):
         return self.advancedproject.getProjectSystem()
     def getProjectInfo(self):
         return self.advancedproject.getProjectInfo()

offlate/ui/welcome.py unknown status 1

 #   Copyright (c) 2021 Julien Lepiller <julien@lepiller.eu>
 #
 #   This program is free software: you can redistribute it and/or modify
 #   it under the terms of the GNU Affero General Public License as
 #   published by the Free Software Foundation, either version 3 of the
 #   License, or (at your option) any later version.
 #
 #   This program is distributed in the hope that it will be useful,
 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #   GNU Affero General Public License for more details.
 #
 #   You should have received a copy of the GNU Affero General Public License
 #   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 ####
 from PyQt5.QtWidgets import *
 from PyQt5.QtGui import *
 from PyQt5.QtCore import *
 import datetime
 import sys
 import os
 from translate.lang.data import languages, tr_lang
 from .new import PredefinedProjectWidget, AdvancedProjectWidget
 from .manager import NewRunnable
 from .config.settings import SystemSettingsWidget
 WelcomePage = 1
 CopyrightPage = 2
 LangPage = 3
 ProjectPage = 4
 DetailPage = 5
 SettingsPage = 6
 DownloadPage = 7
 SuccessPage = 8
 HintsPage = 9
 class WelcomeWindow(QWizard):
     """
     This it the class that contains the first-time welcome screen, implemented
     as a wizard, to benefit from the page logic of the class. It is mostly
     linera, but we add one optional page to add the details of a project, if
     the first project is not available in the list.
     """
     def __init__(self, manager):
         super().__init__()
         self.manager = manager
         self.initUI()
     def initUI(self):
         center = QDesktopWidget().availableGeometry().center()
         self.addPage(PageWelcome(self))
         self.addPage(PageCopyright(self))
         self.addPage(PageLang(self))
         self.addPage(PageProjectSelection(self))
         self.addPage(PageSystemSettings(self))
         self.addPage(PageDownload(self))
         self.addPage(PageSuccess(self))
         self.addPage(PageHints(self))
         self.setGeometry(center.x()-300, center.y()-225, 600, 450)
         self.setWindowTitle(self.tr('Welcome to Offlate'))
         self.setWizardStyle(QWizard.ModernStyle);
         self.setPixmap(QWizard.LogoPixmap, QPixmap(os.path.dirname(__file__) + '/data/icon.png'));
 class PageWelcome(QWizardPage):
     def __init__(self, parent=None):
         super().__init__(parent)
         self.initUI()
     def initUI(self):
         layout = QVBoxLayout()
         self.setTitle("Offlate")
         self.setPixmap(QWizard.WatermarkPixmap, QPixmap(os.path.dirname(__file__) + '/data/illustration.png'))
         #self.setSubTitle(self.tr("Welcome to Offlate!"))
         explainText = QLabel(self)
         explainText.setText(self.tr("Offlate is a tool to help you localise \
 free and open source software. Before you start contributing translations to a \
 project though, there are a few things we need to set up and talk about. Let's \
 get started!"))
         explainText.setWordWrap(True)
         layout.addWidget(explainText)
         self.setLayout(layout)
 class PageCopyright(QWizardPage):
     def __init__(self, parent):
         super().__init__(parent)
         self.initUI()
     def initUI(self):
         layout = QVBoxLayout()
         self.setTitle(self.tr("Copyright Settings"))
         self.setSubTitle(self.tr("Configuring how your copyright is added to files"))
         explainText = QLabel(self)
         explainText.setText(self.tr("In some cases, we need to add a copyright \
 line for you in the translation files we send upstream. Here, you can configure \
 how you want the copyright line to look like. This information will most likely \
 become public after your first contribution."))
         explainText.setWordWrap(True)
         layout.addWidget(explainText)
         form = QFormLayout()
         self.nameEdit = QLineEdit()
         self.emailEdit = QLineEdit()
         form.addRow(QLabel("Name:"), self.nameEdit)
         form.addRow(QLabel("Email:"), self.emailEdit)
         layout.addLayout(form)
         layout.addSpacing(15)
         previewLabel = QLabel()
         previewLabel.setText(self.tr("Here is how your copyright line will look like:"))
         layout.addWidget(previewLabel)
         layout.addSpacing(9)
         self.previewLine = QLabel()
         self.previewLine.setTextFormat(Qt.RichText)
         self.previewLine.setWordWrap(True)
         self.previewLine.setAlignment(Qt.AlignCenter)
         pal = QPalette()
         pal.setColor(QPalette.Window, Qt.white)
         self.previewLine.setAutoFillBackground(True)
         self.previewLine.setMargin(9)
         self.previewLine.setPalette(pal)
         layout.addWidget(self.previewLine)
         self.updatePreview()
         self.nameEdit.textChanged.connect(self.updatePreview)
         self.emailEdit.textChanged.connect(self.updatePreview)
         self.setLayout(layout)
         self.registerField("name*", self.nameEdit)
         self.registerField("email*", self.emailEdit)
     def updatePreview(self, _ignore=None):
         currentDateTime = datetime.datetime.now()
         date = currentDateTime.date()
         year = date.strftime("%Y")
         name = self.nameEdit.text()
         nameHolder = "<i>{}</i>".format(self.tr("Your Name"))
         email = self.emailEdit.text()
         emailHolder = "<i>{}</i>".format(self.tr("your@email"))
         self.previewLine.setText(self.tr("Copyright &copy; {} {} &lt;{}&gt;").format(year,
             name if name != "" else nameHolder, email if email != "" else emailHolder))
 class PageLang(QWizardPage):
     def __init__(self, parent):
         super().__init__(parent)
         self.initUI()
     def initUI(self):
         layout = QVBoxLayout()
         self.setTitle(self.tr("Language Settings"))
         self.setSubTitle(self.tr("Configuring the default language for new projects"))
         explainText = QLabel(self)
         explainText.setText(self.tr("Which language will you most frequently \
 translate projects into? This setting can be changed later. It can also be \
 overriden by individual projects."))
         explainText.setWordWrap(True)
         layout.addWidget(explainText)
         self.languageCombo = QComboBox()
         self.languageCombo.addItem(self.tr("None"), userData="")
         for lang in languages:
             langtag = lang
             lang = languages[lang]
             langname = lang[0]
             self.languageCombo.addItem(tr_lang()(langname), userData=langtag)
         self.languageCombo.currentIndexChanged.connect(self.comboChanged)
         layout.addWidget(self.languageCombo)
         layout.addSpacing(15)
         warnText = QLabel(self)
         warnText.setText(self.tr("Note that you should only translate into \
 native language or to a language you are extremely familiar with, to avoid \
 weird or nonsensical translations."))
         warnText.setWordWrap(True)
         layout.addWidget(warnText)
         # TODO: Add information about the selected language, to redirect users
         # to translation teams, resources, etc
         # TODO: Allow users to select an unlisted language, by providing
         # language codes.
         self.setLayout(layout)
         self.langEdit = QLineEdit()
         self.registerField("lang*", self.langEdit)
     def comboChanged(self, index):
         self.langEdit.setText(self.languageCombo.itemData(index))
 class PageProjectSelection(QWizardPage):
     def __init__(self, parent):
         super().__init__(parent)
         self.initUI()
     def initUI(self):
         layout = QVBoxLayout()
         self.setTitle(self.tr("First Project"))
         self.setSubTitle(self.tr("Choosing a first project"))
         self.predefinedprojects = PredefinedProjectWidget()
         self.advancedproject = AdvancedProjectWidget()
         self.predefinedprojects.currentItemChanged.connect(self.selected)
         layout.addWidget(self.predefinedprojects)
         self.setLayout(layout)
         self.registerField("project*", self.advancedproject, "data",
                 self.advancedproject.modified)
     def selected(self):
         self.advancedproject.fill(self.predefinedprojects.currentData())
 class PageSystemSettings(QWizardPage):
     def __init__(self, parent):
         super().__init__(parent)
         self.parent = parent
         self.initUI()
     def initUI(self):
         self.setTitle(self.tr("System Configuration"))
         self.setSubTitle(self.tr("Getting an account on the project's platform"))
     def initializePage(self):
         layout = QVBoxLayout()
         system = self.field("project")["system"]
         lang = self.field("lang")
         email = self.field("email")
         name = self.field("name")
         self.parent.manager.updateSettings({'Generic': {'name': name, 'email': email, 'lang': lang}})
         widget = SystemSettingsWidget(self.parent.manager, system, self)
         layout.addWidget(widget)
         self.setLayout(layout)
 class PageDownload(QWizardPage):
     def __init__(self, parent):
         super().__init__(parent)
         self.parent = parent
         self.threadpool = QThreadPool()
         self.initUI()
     def initUI(self):
         layout = QVBoxLayout()
         self.setTitle(self.tr("Project Fetch"))
         self.setSubTitle(self.tr("Downloading translation files"))
         explainText = QLabel(self)
         explainText.setText(self.tr("We are now attempting to fetch the \
 translation files of your project. This step should be pretty fast."))
         explainText.setWordWrap(True)
         layout.addWidget(explainText)
         self.bar = QProgressBar()
         self.bar.setEnabled(True)
         self.bar.setRange(0, 100)
         layout.addWidget(self.bar)
         layout.addSpacing(15)
         pal = QPalette()
         pal.setColor(QPalette.WindowText, Qt.red)
         self.notConfigured = QLabel(self)
         self.notConfigured.setText("The platform is not properly configured, \
 please go back.")
         self.notConfigured.setWordWrap(True)
         self.notConfigured.hide()
         self.notConfigured.setPalette(pal)
         layout.addWidget(self.notConfigured)
         self.errorLabel = QLabel(self)
         self.errorLabel.setWordWrap(True)
         self.errorLabel.hide()
         self.errorLabel.setPalette(pal)
         layout.addWidget(self.errorLabel)
         self.finishedLabel = QLabel(self)
         self.finishedLabel.setText(self.tr("Finished!"))
         self.finishedLabel.setWordWrap(True)
         self.finishedLabel.hide()
         layout.addWidget(self.finishedLabel)
         self.setLayout(layout)
         self.check = QCheckBox()
         self.check.setCheckState(Qt.Unchecked)
         self.registerField("downloaded*", self.check)
     def initializePage(self):
         self.check.setCheckState(Qt.Unchecked)
         project = self.field("project")
         lang = self.field("lang")
         email = self.field("email")
         name = self.field("name")
         self.bar.setValue(0)
         self.notConfigured.hide()
         self.errorLabel.hide()
         self.finishedLabel.hide()
         if not self.parent.manager.isConfigured(project['system'], project['info']):
             self.notConfigured.show()
             return
         self.manager = self.parent.manager
         worker = NewRunnable(self, project['name'], lang, project['system'],
                 project['info'])
         worker.signals.finished.connect(self.reportFinish)
         worker.signals.progress.connect(self.reportProgress)
         worker.signals.restart_required.connect(self.reportError)
         self.threadpool.start(worker)
     def reportProgress(self, name, progress):
         self.bar.setValue(progress)
     def reportError(self, name, lang, system, info, error):
         self.errorLabel.setText(error)
         self.errorLabel.show()
     def reportFinish(self, name):
         self.bar.setValue(100)
         self.finishedLabel.show()
         self.check.setCheckState(Qt.Checked)
 class PageSuccess(QWizardPage):
     def __init__(self, parent):
         super().__init__(parent)
         self.parent = parent
         self.initUI()
     def initUI(self):
         layout = QVBoxLayout()
         self.setTitle("Success")
         self.setPixmap(QWizard.WatermarkPixmap, QPixmap(os.path.dirname(__file__) + '/data/illustration.png'))
         explainText = QLabel(self)
         explainText.setText(self.tr("Congratulations! We've just set up your \
 first project! Initial setup is now complete, and you can always change the \
 settings you've set here from the Offlate welcome screen. After a few \
 explanations you will be able to work on your project right away!"))
         explainText.setWordWrap(True)
         layout.addWidget(explainText)
         self.setLayout(layout)
     def initializePage(self):
         self.parent.manager.updateSettings({'Generic': {'new': 'False'}})
 class PageHints(QWizardPage):
     def __init__(self, parent):
         super().__init__(parent)
         self.initUI()
     def initUI(self):
         layout = QVBoxLayout()
         self.setTitle("Offlate Hints")
         self.setPixmap(QWizard.WatermarkPixmap, QPixmap(os.path.dirname(__file__) + '/data/illustration.png'))
         explainManager = QLabel(self)
         explainManager.setText(self.tr("You can always go back to the initial \
 screen (called the project manager) from the editor, by using \
 <i>file > project manager</i>"))
         explainManager.setWordWrap(True)
         layout.addWidget(explainManager)
         layout.addSpacing(15)
         explainManager = QLabel(self)
         explainManager.setText(self.tr("Quickly switch to the next string with \
 <i>Ctrl+Enter</i>. Use <i>Ctrl+Shift+Enter</i> to go back to the previous string \
 instead."))
         explainManager.setWordWrap(True)
         layout.addWidget(explainManager)
         layout.addSpacing(15)
         explainManager = QLabel(self)
         explainManager.setText(self.tr("With these hints, you are now ready \
 to start working on your project! We will now open the project manager, from \
 which you can add more projects, change your settings, etc. Have fun!"))
         explainManager.setWordWrap(True)
         layout.addWidget(explainManager)
         self.setLayout(layout)