示例#1
0
文件: spy.py 项目: connoryang/1v1dec
 def __init__(self, waitables, paths, translationPaths = None):
     self.on_file_reloaded = signals.Signal()
     self.on_file_reload_failed = signals.Signal()
     self.runningCheckAt = 0
     self.startedAt = int(time.time())
     self.processed = {}
     self.waitables = waitables
     self.translationPaths = translationPaths or []
     if isinstance(paths, basestring):
         paths = [paths]
     self.handles = {}
     paths = map(os.path.abspath, paths)
     commonprefix = os.path.commonprefix(paths)
     if commonprefix:
         paths = [commonprefix]
     for path in paths:
         if not os.path.exists(path):
             log.warn("SpyFolder: Can't spy on non-existing folder %s" % path)
             continue
         handle = win32api.FindFirstChangeNotification(path, True, win32api.FILE_NOTIFY_CHANGE_LAST_WRITE)
         if handle == win32api.INVALID_HANDLE_VALUE:
             log.warn('SpyFolder: got invalid handle for  %s' % path)
             continue
         waitables.InsertHandle(handle, self)
         self.handles[handle] = path
         log.info('AutoCompiler: Now spying on %s using handle %s.', path, handle)
示例#2
0
class JobManager(plugin.DocumentPlugin):

    started = signals.Signal()  # Job
    finished = signals.Signal()  # Job, success

    def __init__(self, document):
        self._job = None

    def start_job(self, job):
        """Starts a Job on our behalf."""
        if not self.is_running():
            self._job = job
            job.done.connect(self._finished)
            job.start()
            self.started(job)
            app.jobStarted(self.document(), job)

    def _finished(self, success):
        self.finished(job, success)
        app.jobFinished(self.document(), self._job, success)

    def job(self):
        """Returns the last job if any."""
        return self._job

    def is_running(self):
        """Returns True when a job is running."""
        if self._job:
            return self._job.is_running() and not self._job.is_aborted()
示例#3
0
 def __new__(cls, *args, **kwargs):
     obj = industry.Base.__new__(cls)
     obj._typeID = None
     obj._level = None
     obj._errors = []
     obj.on_updated = signals.Signal()
     obj.on_errors = signals.Signal()
     return obj
示例#4
0
 def __init__(self, typeID, itemID, stacksize):
     self.typeID = typeID
     self.itemID = itemID
     self.stacksize = stacksize
     self.isOpening = False
     self._loot = None
     self.onOpen = signals.Signal()
     self.onFinish = signals.Signal()
示例#5
0
 def __init__(self, typeID, adapter=None):
     self._adapter = adapter or SkinPanelAdapter()
     self._lock = locks.Lock()
     self.Reset(typeID)
     self.onChange = signals.Signal()
     self.onSkinsChange = signals.Signal()
     self.onSkinsChange.connect(self.onChange)
     self._adapter.RegisterNotify(self)
 def __init__(self, flagID, parentController):
     self.flagID = flagID
     self.moduleItemID = None
     self.chargeItemID = None
     self.parentController = parentController
     self.ghostFittingExtension = ShipFittingSlotControllerGhostFittingExtension(
         self)
     self.on_online_state_change = signals.Signal()
     self.on_item_fitted = signals.Signal()
 def __init__(self, itemID):
     super(SkillExtractorControllerBase, self).__init__()
     self.itemID = itemID
     self.isCompleted = False
     self._skills = None
     self._skillsByID = None
     self._extracted = defaultdict(list)
     self.onUpdate = signals.Signal()
     self.onSkillListUpdate = signals.Signal()
     self.onSkillListUpdate.connect(self.onUpdate)
示例#8
0
文件: job.py 项目: connoryang/1v1dec
 def __new__(cls, blueprint, activityID, *args, **kwargs):
     obj = industry.Base.__new__(cls)
     obj._blueprint = blueprint
     obj._activityID = activityID
     if obj.activity is None:
         raise RuntimeError('Invalid Activity for Blueprint')
     obj.jobID = None
     obj.characterID = None
     obj.corporationID = None
     obj.status = industry.STATUS_UNSUBMITTED
     obj.installerID = None
     obj.startDate = None
     obj.endDate = None
     obj._materials = copy.deepcopy(obj.activity.materials)
     obj._modifiers = []
     obj._skills = {}
     obj._slots = {}
     obj._distance = None
     obj._materialEfficiency = None
     obj._timeEfficiency = None
     obj._random = None
     obj.request = {}
     obj.prices = {}
     obj._modifiers_cache = None
     obj.on_validate = signals.Signal()
     obj.on_updated = signals.Signal()
     obj.on_errors = signals.Signal()
     obj.on_delete = signals.Signal()
     obj.on_facility = signals.Signal()
     obj.on_input_location = signals.Signal()
     obj.on_output_location = signals.Signal()
     obj.on_dirty = signals.Signal()
     obj.on_dirty.connect(obj.update)
     return obj
示例#9
0
 def __new__(cls, *args, **kwargs):
     obj = industry.Base.__new__(cls)
     obj._typeID = None
     obj._quantity = 0
     obj._available = 0
     obj._original = 0
     obj._errors = []
     obj._options = []
     obj._modifiers = []
     obj._probability = 1
     obj.on_updated = signals.Signal()
     obj.on_errors = signals.Signal()
     obj.on_select = signals.Signal()
     return obj
示例#10
0
class EditorDocument(AbstractDocument):
    """A Frescobaldi document for use in the main editor view.
    Basically this is an AbstractDocument with signals added."""

    urlChanged = signals.Signal()  # new url, old url
    closed = signals.Signal()
    loaded = signals.Signal()
    saving = signals.SignalContext()
    saved = signals.Signal()

    @classmethod
    def new_from_url(cls, url, encoding=None):
        d = super(EditorDocument, cls).new_from_url(url, encoding)
        if not url.isEmpty():
            d.loaded()
            app.documentLoaded(d)
        return d

    def __init__(self, url=None, encoding=None):
        super(EditorDocument, self).__init__(url, encoding)
        self.modificationChanged.connect(self.slotModificationChanged)
        app.documents.append(self)
        app.documentCreated(self)

    def slotModificationChanged(self):
        app.documentModificationChanged(self)

    def close(self):
        self.closed()
        app.documentClosed(self)
        app.documents.remove(self)

    def load(self, url=None, encoding=None, keepUndo=False):
        super(EditorDocument, self).load(url, encoding, keepUndo)
        self.loaded()
        app.documentLoaded(self)

    def save(self, url=None, encoding=None):
        url, filename = super().save(url, encoding)
        with self.saving(), app.documentSaving(self):
            self._save(url, filename)
        self.saved()
        app.documentSaved(self)

    def setUrl(self, url):
        old = super(EditorDocument, self).setUrl(url)
        if url != old:
            self.urlChanged(url, old)
            app.documentUrlChanged(self, url, old)
示例#11
0
 def __init__(self, groupID, filterSettings, **kw):
     label = kw.pop('label', evetypes.GetGroupNameByGroup(groupID))
     super(SkillGroupData, self).__init__(label=label, **kw)
     self.filterSettings = filterSettings
     self.onChildUpdated = signals.Signal()
     for child in self.GetChildren():
         child.skill.onUpdate.connect(self.onChildUpdated)
示例#12
0
class DocumentIconProvider(plugin.DocumentPlugin):
    """Provides an icon for a Document."""
    iconChanged = signals.Signal()
    
    def __init__(self, doc):
        doc.modificationChanged.connect(self._send_icon)
        mgr = jobmanager.manager(doc)
        mgr.started.connect(self._send_icon)
        mgr.finished.connect(self._send_icon)
    
    def _send_icon(self):
        self.iconChanged()
    
    def icon(self, mainwindow=None):
        doc = self.document()
        job = jobmanager.job(doc)
        if job and job.is_running() and not jobattributes.get(job).hidden:
            icon = 'lilypond-run'
        elif mainwindow and doc is engrave.Engraver.instance(mainwindow).stickyDocument():
            icon = 'pushpin'
        elif doc.isModified():
            icon = 'document-save'
        elif job and not job.is_running() and not job.is_aborted() and job.success:
            icon = 'document-compile-success'
        elif job and not job.is_running() and not job.is_aborted():
            icon = 'document-compile-failed'
        else:
            icon = 'text-plain'
        return icons.get(icon)
示例#13
0
class VariableManager(plugin.DocumentPlugin):
    """Caches variables in the document and monitors for changes.

    The changed() Signal is emitted some time after the list of variables has been changed.
    It is recommended to not change the document itself in response to this signal.

    """
    changed = signals.Signal()  # without argument

    def __init__(self, doc):
        self._updateTimer = QTimer(singleShot=True, timeout=self.slotTimeout)
        self._variables = self.readVariables()
        if doc.__class__ == document.EditorDocument:
            doc.contentsChange.connect(self.slotContentsChange)
            doc.closed.connect(self._updateTimer.stop)  # just to be sure

    def slotTimeout(self):
        variables = self.readVariables()
        if variables != self._variables:
            self._variables = variables
            self.changed()

    def slotContentsChange(self, position, removed, added):
        """Called if the document changes."""
        if (self.document().findBlock(position).blockNumber() < _LINES
                or self.document().findBlock(position + added).blockNumber() >
                self.document().blockCount() - _LINES):
            self._updateTimer.start(500)

    def variables(self):
        """Returns the document variables (cached) as a dictionary. This method is recommended."""
        if self._updateTimer.isActive():
            # an update is pending, force it
            self._updateTimer.stop()
            self.slotTimeout()
        return self._variables

    def readVariables(self):
        """Reads the variables from the document and returns a dictionary. Internal."""
        count = self.document().blockCount()
        blocks = [self.document().firstBlock()]
        if count > _LINES * 2:
            blocks.append(self.document().findBlockByNumber(count - _LINES))
            count = _LINES

        def lines(block):
            for i in range(count):
                yield block.text()
                block = block.next()

        variables = {}
        for block in blocks:
            variables.update(m.group(1, 2) for n, m in positions(lines(block)))
        return variables
示例#14
0
    def __init__(self, parent_statement=None, event_loop=eventLoop()):
        """Initialize the ThreadExecutor object

        @param parent_statement: prievous statement defining the execution environment for the first statement

        """
        import signals
        self.sig_statement_executing = signals.Signal()
        self.sig_statement_complete = signals.Signal()
        self.sig_complete = signals.Signal()

        self.parent_statement = parent_statement
        self.statements = []
        self.lock = thread.allocate_lock()

        self.event_loop = event_loop
        self.last_complete = -1
        self.last_signalled = -1
        self.complete = False
        self.interrupted = False
 def __init__(self, typeID, points):
     super(SkillBase, self).__init__()
     self._typeID = typeID
     self._points = points
     self._unmodifiedPoints = points
     self._isRequired = False
     self._isQueued = False
     self._isRestricted = False
     self._rank = None
     self._level = None
     self._dirty = False
     self.onUpdate = signals.Signal()
示例#16
0
class Dialog(widgets.dialog.Dialog):
    """Dialog to run arbitrary external job.Job commands and show the log."""

    job_done = signals.Signal()

    def __init__(self, parent, auto_accept=False):
        super(Dialog, self).__init__(parent, buttons=(
            'cancel',
            'ok',
        ))
        self.setWindowModality(Qt.WindowModal)
        self.setIconSize(32)
        self.auto_accept = auto_accept
        self.log = log.Log(self)
        self.job = None
        self.setMainWidget(self.log)
        qutil.saveDialogSize(self, "job-dialog/dialog/size", QSize(480, 800))

    def abort_job(self):
        self.job.abort()
        self.reject()

    def run(self, j, msg=_("Run external command")):
        """Run the given job."""
        self.job = j
        self.job.done.connect(self.slot_job_done)
        self.log.connectJob(j)
        self.setWindowTitle(j.title())
        self.setMessage(msg)
        self.button('ok').setEnabled(False)
        self.button('cancel').clicked.connect(self.abort_job)
        j.start()
        self.exec()

    def slot_job_done(self):
        if self.job.success:
            if self.auto_accept:
                self.accept()
            self.button('ok').setEnabled(True)
        else:
            self.setMessage(_("Job failed! Please inspect log"))
            self.setIcon('critical')
        self.button('cancel').clicked.connect(self.reject)
        self.job_done.emit()
示例#17
0
 def __init__(self):
     self.state = structures.STATE_UNKNOWN
     self.damage = (None, None, None)
     self.vulnerable = None
     self.timerStart = None
     self.timerEnd = None
     self.timerPaused = None
     self.firstAggressed = None
     self.lastAggressed = None
     self.repairing = None
     self.unanchoring = None
     self.schedule = structures.Schedule(
         required=self.GetRequiredHours(),
         timeZoneOffset=8 if boot.region == 'optic' else 0)
     self.OnStateChanged = signals.Signal()
     self.OnDamageChanged = signals.Signal()
     self.OnVulnerabilityChanged = signals.Signal()
     self.OnScheduleChanged = signals.Signal()
     self.OnTimerChanged = signals.Signal()
     self.OnRepairingChanged = signals.Signal()
     self.OnAggressionChanged = signals.Signal()
     self.OnUnanchoringChanged = signals.Signal()
     self.OnFirstAggressed = signals.Signal()
     self.schedule.OnChange.connect(self.HandleScheduleChanged)
示例#18
0
    def AttachComponent(cls):
        if not hasattr(cls, '_attached_ui_components'):
            setattr(cls, '_attached_ui_components', [])
        cls._attached_ui_components.append(component)
        for methodName in component.__observed_methods__:
            method = getattr(cls, methodName, None)
            if method is None:
                continue
            signal = getattr(method, '_component_method_observers', None)
            if signal is None:
                signal = signals.Signal()

                def GetWrapper(_method, _signal):
                    @functools.wraps(method)
                    def Wrapper(*args, **kwargs):
                        try:
                            result = _method(*args, **kwargs)
                        except:
                            logger.exception(
                                'Method %s raised an exception before signal could emit',
                                methodName)
                            raise

                        try:
                            _signal(*args, **kwargs)
                        except Exception:
                            logger.exception(
                                'Failed while notifying observers for method %s',
                                methodName)

                        return result

                    return Wrapper

                wrapper = GetWrapper(method, signal)
                setattr(wrapper, '_component_method_observers', signal)
                setattr(cls, methodName, wrapper)
            signal.connect(getattr(component, methodName))

        return cls
示例#19
0
 def __init__(self, fightersSvc):
     self.fightersSvc = fightersSvc
     sm.RegisterNotify(self)
     self.fightersInLaunchTubes = {}
     self.fightersInSpaceByID = {}
     self.fightersInSpaceByTube = {}
     self.statusByTube = {}
     self.activeAbilities = {}
     self.abilityChargeCounts = {}
     self.abilityCooldowns = {}
     self.incomingEwarByFighterID = defaultdict(dict)
     self.abilityTargetTracker = AbilityTargetTracker()
     if session.shipid:
         self._UpdateStateForShip()
     self.signalOnFighterTubeStateUpdate = signals.Signal()
     self.signalOnFighterTubeContentUpdate = signals.Signal()
     self.signalOnFighterInSpaceUpdate = signals.Signal()
     self.signalOnAbilityActivationStatusUpdate = signals.Signal()
     self.signalOnIncomingEwarStarted = signals.Signal()
     self.signalOnIncomingEwarEnded = signals.Signal()
示例#20
0
class Job(object):
    """Manages a process.

    Set the command attribute to a list of strings describing the program and
    its arguments.
    Set the directory attribute to a working directory.
    The environment attribute is a dictionary; if you set an item it will be
    added to the environment for the process (the rest will be inherited from
    the system); if you set an item to None, it will be unset.

    Call start() to start the process.
    The output() signal emits output (stderr or stdout) from the process.
    The done() signal is always emitted when the process has ended.
    The history() method returns all status messages and output so far.

    When the process has finished, the error and success attributes are set.
    The success attribute is set to True When the process exited normally and
    successful. When the process did not exit normally and successfully, the
    error attribute is set to the QProcess.ProcessError value that occurred
    last. Before start(), error and success both are None.

    The status messages and output all are in one of five categories:
    STDERR, STDOUT (output from the process) or NEUTRAL, FAILURE or SUCCESS
    (status messages). When displaying these messages in a log, it is advised
    to take special care for newlines, esp when a status message is displayed.
    Status messages normally have no newlines, so you must add them if needed,
    while output coming from the process may continue in the same line.

    Jobs that run LilyPond will use objects of job.lilypond.Job or derived
    special classes.

    """
    output = signals.Signal()
    done = signals.Signal()
    started = signals.Signal()
    title_changed = signals.Signal()  # title (string)

    def __init__(self,
                 command=[],
                 args=None,
                 directory="",
                 environment={},
                 title="",
                 input="",
                 output="",
                 priority=1,
                 runner=None,
                 decode_errors='strict',
                 encoding='latin1'):
        self.command = command if type(command) == list else [command]
        self._input = input
        self._output = output
        self._runner = runner
        self._arguments = args if args else []
        self._directory = directory
        self.environment = environment
        self._encoding = encoding
        self.success = None
        self.error = None
        self._title = ""
        self._priority = priority
        self._aborted = False
        self._process = None
        self._history = []
        self._starttime = 0.0
        self._elapsed = 0.0
        self.decoder_stdout = self.create_decoder(STDOUT)
        self.decoder_stderr = self.create_decoder(STDERR)
        self.decode_errors = decode_errors  # codecs error handling

    def add_argument(self, arg):
        """Append an additional command line argument if it is not
        present already."""
        if not arg in self._arguments:
            self._arguments.append(arg)

    def arguments(self):
        """Additional (custom) arguments, will be inserted between
        the -d options and the include paths. May for example stem
        from the manual part of the Engrave Custom dialog."""
        return self._arguments

    def create_decoder(self, channel):
        """Return a decoder for the given channel (STDOUT/STDERR).

        This method is called from the constructor. You can re-implement this
        method to return another decoder, or you can set the decoders manually
        by setting the `decoder_stdout` and `decoder_stderr` manually after
        construction.

        This decoder is then used to decode the 8bit bytestrings into Python
        unicode strings. The default implementation returns a 'latin1'
        decoder for both channels.

        """
        return codecs.getdecoder(self._encoding)

    def directory(self):
        return self._directory

    def set_directory(self, directory):
        self._directory = directory

    def filename(self):
        """File name of the job's input document.
        May be overridden for 'empty' jobs."""
        return self._input

    def set_input(self, filename):
        self._input = filename

    def set_input_file(self):
        """configure the command to add an input file if one is specified."""
        filename = self.filename()
        if filename:
            self.command.append(filename)

    def output_argument(self):
        return self._output

    def output_file(self):
        return self._output_file

    def runner(self):
        """Return the Runner object if the job is run within
        a JobQueue, or None if not."""
        return self._runner

    def set_runner(self, runner):
        """Store a reference to a Runner if the job is run within
        a JobQueue."""
        self._runner = runner

    def title(self):
        """Return the job title, as set with set_title().

        The title defaults to an empty string.

        """
        return self._title

    def set_title(self, title):
        """Set the title.

        If the title changed, the title_changed(title) signal is emitted.

        """
        old, self._title = self._title, title
        if title != old:
            self.title_changed(title)

    def priority(self):
        return self._priority

    def set_priority(self, value):
        self._priority = value

    def start(self):
        """Starts the process."""
        self.configure_command()
        self.success = None
        self.error = None
        self._aborted = False
        self._history = []
        self._elapsed = 0.0
        self._starttime = time.time()
        if self._process is None:
            self.set_process(QProcess())
        self._process.started.connect(self.started)
        self.start_message()
        if os.path.isdir(self._directory):
            self._process.setWorkingDirectory(self._directory)
        if self.environment:
            self._update_process_environment()
        self._process.start(self.command[0], self.command[1:])

    def configure_command(self):
        """Process the command if necessary.
        In a LilyPondJob this is the essential part of composing
        the command line from the job options.
        This implementation simply creates a list from the main
        command, any present arguments, the input and the output
        (if present).
        """
        self.command.extend(self._arguments)
        if self._input:
            if type(self._input) == list:
                self.command.extend(self._input)
            else:
                self.command.append(self._input)
        if self._output:
            if type(self._output) == list:
                self.command.extend(self._output)
            else:
                self.command.append(self._output)

    def start_time(self):
        """Return the time this job was started.

        Returns 0.0 when the job has not been started yet.

        """
        return self._starttime

    def elapsed_time(self):
        """Return how many seconds this process has been running."""
        if self._elapsed:
            return self._elapsed
        elif self._starttime:
            return time.time() - self._starttime
        return 0.0

    def abort(self):
        """Abort the process."""
        if self._process:
            self._aborted = True
            self.abort_message()
            if os.name == "nt":
                self._process.kill()
            else:
                self._process.terminate()

    def is_aborted(self):
        """Returns True if the job was aborted by calling abort()."""
        return self._aborted

    def is_running(self):
        """Returns True if this job is running."""
        return bool(self._process)

    def failed_to_start(self):
        """Return True if the process failed to start.

        (Call this method after the process has finished.)

        """
        return self.error == QProcess.FailedToStart

    def set_process(self, process):
        """Sets a QProcess instance and connects the signals."""
        self._process = process
        if process.parent() is None:
            process.setParent(QCoreApplication.instance())
        process.finished.connect(self._finished)
        process.error.connect(self._error)
        process.readyReadStandardError.connect(self._readstderr)
        process.readyReadStandardOutput.connect(self._readstdout)

    def _update_process_environment(self):
        """(internal) initializes the environment for the process."""
        se = QProcessEnvironment.systemEnvironment()
        for k, v in self.environment.items():
            se.remove(k) if v is None else se.insert(k, v)
        self._process.setProcessEnvironment(se)

    def message(self, text, type=NEUTRAL):
        """Output some text as the given type (NEUTRAL, SUCCESS, FAILURE, STDOUT or STDERR)."""
        self.output(text, type)
        self._history.append((text, type))

    def history(self, types=ALL):
        """Yield the output messages as two-tuples (text, type) since the process started.

        If types is given, it should be an OR-ed combination of the status types
        STDERR, STDOUT, NEUTRAL, SUCCESS or FAILURE.

        """
        for msg, type in self._history:
            if type & types:
                yield msg, type

    def stdout(self):
        """Return the standard output of the process as unicode text."""
        return "".join([line[0] for line in self.history(STDOUT)])

    def stderr(self):
        """Return the standard error of the process as unicode text."""
        return "".join([line[0] for line in self.history(STDERR)])

    def _finished(self, exitCode, exitStatus):
        """(internal) Called when the process has finished."""
        self.finish_message(exitCode, exitStatus)
        success = exitCode == 0 and exitStatus == QProcess.NormalExit
        self._bye(success)

    def _error(self, error):
        """(internal) Called when an error occurs."""
        self.error_message(error)
        if self._process.state() == QProcess.NotRunning:
            self._bye(False)

    def _bye(self, success):
        """(internal) Ends and emits the done() signal."""
        self._elapsed = time.time() - self._starttime
        if not success:
            self.error = self._process.error()
        self.success = success
        self._process.deleteLater()
        self._process = None
        self.done(success)

    def _readstderr(self):
        """(internal) Called when STDERR can be read."""
        output = self._process.readAllStandardError()
        self.message(
            self.decoder_stderr(output, self.decode_errors)[0], STDERR)

    def _readstdout(self):
        """(internal) Called when STDOUT can be read."""
        output = self._process.readAllStandardOutput()
        self.message(
            self.decoder_stdout(output, self.decode_errors)[0], STDOUT)

    def start_message(self):
        """Called by start().

        Outputs a message that the process has started.

        """
        name = self.title() or os.path.basename(self.command[0])
        self.message(_("Starting {job}...").format(job=name), NEUTRAL)

    def abort_message(self):
        """Called by abort().

        Outputs a message that the process has been aborted.

        """
        name = self.title() or os.path.basename(self.command[0])
        self.message(_("Aborting {job}...").format(job=name), NEUTRAL)

    def error_message(self, error):
        """Called when there is an error (by _error()).

        Outputs a message describing the given QProcess.Error.

        """
        if error == QProcess.FailedToStart:
            self.message(
                _("Could not start {program}.\n"
                  "Please check path and permissions.").format(
                      program=self.command[0]), FAILURE)
        elif error == QProcess.ReadError:
            self.message(_("Could not read from the process."), FAILURE)
        elif self._process.state() == QProcess.NotRunning:
            self.message(_("An unknown error occurred."), FAILURE)

    def finish_message(self, exitCode, exitStatus):
        """Called when the process finishes (by _finished()).

        Outputs a message on completion of the process.

        """
        if exitCode:
            self.message(
                _("Exited with return code {code}.").format(code=exitCode),
                FAILURE)
        elif exitStatus:
            self.message(
                _("Exited with exit status {status}.").format(
                    status=exitStatus), FAILURE)
        else:
            time = self.elapsed2str(self.elapsed_time())
            self.message(
                _("Completed successfully in {time}.").format(time=time),
                SUCCESS)

    @staticmethod
    def elapsed2str(seconds):
        """Return a short display for the given time period (in seconds)."""
        minutes, seconds = divmod(seconds, 60)
        if minutes:
            return "{0:.0f}'{1:.0f}\"".format(minutes, seconds)
        return '{0:.1f}"'.format(seconds)
示例#21
0
"""
Manages the history of the open documents of a MainWindow.
Contains smart logic to switch documents if the active document is closed.

If no documents remain, listen to other HistoryManager instances and
make the document set-current there also current here.
"""

import weakref

import app
import signals

# This signal is emitted whenever a MainWindow sets a document current (active)
# Any HistoryManager can listen to it and follow it if no document is current
_setCurrentDocument = signals.Signal()  # Document


class HistoryManager(object):
    """Keeps the history of document switches by the user.
    
    If a document is closed, the previously active document is set active.
    If no documents remain, nothing is done.
    
    """
    def __init__(self, mainwindow, othermanager=None):
        self.mainwindow = weakref.ref(mainwindow)
        self._documents = list(othermanager._documents if othermanager else app.documents)
        self._has_current = bool(self._documents)
        mainwindow.currentDocumentChanged.connect(self.setCurrentDocument)
        app.documentCreated.connect(self.addDocument, 1)
示例#22
0
try:
    import popplerqt5
except ImportError:
    popplerqt5 = None

import app
import plugin
import resultfiles
import signals
import popplertools

_cache = weakref.WeakValueDictionary()

# This signal gets emitted when a finished Job has created new PDF document(s).
documentUpdated = signals.Signal()  # Document


@app.jobFinished.connect
def _on_job_finished(document, job):
    if group(document).update():
        documentUpdated(document, job)


def group(document):
    """Returns a DocumentGroup instance for the given text document."""
    return DocumentGroup.instance(document)


def load(filename):
    """Returns a Poppler.Document for the given filename, caching it (weakly).
示例#23
0
different ways (via a Python extension module or by embedding the PortMIDI
C library directly).

The available() method returns True if portmidi is available, False if not.

Inside Frescobaldi, interact with this module to get input and outputs etcetera,
not with portmidi directly.

"""

import portmidi
import signals

portmidi.init()

aboutToRestart = signals.Signal()  # emitted before re-init PortMIDI
settingsChanged = signals.Signal()  # emitted when ports are changed, etc


def available():
    """Returns True if portmidi is available, False if not."""
    return portmidi.available()


def restart():
    """Restarts PortMIDI."""
    aboutToRestart()
    portmidi.quit()
    portmidi.init()
    settingsChanged()
示例#24
0
"""

from __future__ import unicode_literals

import contextlib
import os

from PyQt4.QtCore import QFileSystemWatcher, QUrl

import app
import plugin
import signals

__all__ = ['documentChangedOnDisk', 'DocumentWatcher', 'start', 'stop']

documentChangedOnDisk = signals.Signal()  # Document

# one global QFileSystemWatcher instance
watcher = None


class DocumentWatcher(plugin.DocumentPlugin):
    """Maintains if a change was detected for a document."""
    def __init__(self, d):
        self.changed = False

    def isdeleted(self):
        """Return True if some change has occurred, the document has a local
        filename, but the file is not existing on disk.
        
        """
示例#25
0
 def __init__(self, offer, store):
     self.offer = offer
     self.store = store
     self.account = store.GetAccount()
     self.onAurBalanceChanged = signals.Signal()
     self.account.SubscribeToAurumBalanceChanged(self.onAurBalanceChanged)
示例#26
0
class TextFonts(QObject):
    """Provide information about available text fonts. These are exactly the
    fonts that can be seen by LilyPond.
    This is only produced upon request but then stored permanently during the
    program's runtime.
    load_fonts() will run LilyPond to determine the list of fonts, optionally
    reporting to a log.Log widget if given.
    Since this is an asynchronous process GUI elements that want to use the
    results have to connect to the 'loaded' signal which is emitted after
    LilyPond has completed and the results been parsed.

    A Fonts() object is immediately available as fonts.available_fonts, and
    its is_loaded member can be requested to test if fonts have already been
    loaded.
    """

    loaded = signals.Signal()

    def __init__(self, lilypond_info):
        super(TextFonts, self).__init__()
        self.lilypond_info = lilypond_info
        self._tree_model = FontTreeModel(self)
        self._misc_model = MiscTreeModel(self)
        self.job = None
        self.load_fonts()

    def reset(self, log_widget=None):
        self._log = []
        self._tree_model.reset()
        self._misc_model.reset()
        # needs to be reset for the LilyPond-dependent fonts
        self.font_db = QFontDatabase()

        self._is_loaded = False

    def log(self):
        return self._log

    def acknowledge_lily_fonts(self):
        """Add the OpenType fonts in LilyPond's font directory
        to Qt's font database. This should be relevant (untested)
        when the fonts are not additionally installed as system fonts."""
        # TODO: Move the the filtering here.
        # It's not correct to first add the notation fonts to the font debug
        # only to filter them again later. Besides, there might be other valid
        # fonts caught by the filter.
        font_dir = os.path.join(self.lilypond_info.datadir(), 'fonts', 'otf')
        for lily_font in os.listdir(font_dir):
            self.font_db.addApplicationFont(os.path.join(font_dir, lily_font))

    def add_style_to_family(self, families, family_name, input):
        """Parse a font face definition provided by LilyPond.
        There is some guesswork involved since there may be
        discrepancies between the fonts/styles reported by
        LilyPond and those available in QFontDatabase.
        To discuss this the function is heavily commented.
        See also
        http://lists.gnu.org/archive/html/lilypond-user/2018-07/msg00338.html
        """
        def un_camel(style):
            """
            Try to 'fix' a class of errors when LilyPond reports
            e.g. 'BoldItalic' instead of 'Bold Italic'.
            It is unclear if this actually fixes the source of the
            issue or just one arbitrary example.
            """
            # The following regular expression would be a 'proper'
            # un-camel-ing, but this seems not to be relevant.
            #un_cameled = re.sub('([^ ])([A-Z][a-z])', r'\1 \2', style)
            #return re.sub('([A-Za-z])([0-9])', r'\1 \2', un_cameled)
            return ("Bold Italic" if style == "BoldItalic" else style)

        if not family_name in families.keys():
            families[family_name] = {}
        family = families[family_name]
        input = input.strip().split(':')
        # This is a safeguard against improper entries
        if len(input) == 2:
            # The first segment has always one or two entries:
            # - The font family name
            # - The font subfamily name if it differs from the base name.
            # Therefore the series is always the *last* entry in the list.
            # We "unescape" hyphens because this escape is not necessary
            # for our purposes.
            sub_family = input[0].split(',')[-1].replace('\\-', '-')
            if not sub_family in family.keys():
                family[sub_family] = []
            qt_styles = self.font_db.styles(sub_family)
            lily_styles = input[1][6:].split(',')
            match = ''
            if not qt_styles:
                # In some cases Qt does *not* report available styles.
                # In these cases it seems correct to use the style reported
                # by LilyPond. In very rare cases it seems possible that
                # LilyPond reports multiple styles for such fonts, and for now
                # we have to simply ignore these cases so we take the first
                # or single style.
                match = un_camel(lily_styles[0])
            else:
                # Match LilyPond's reported styles with those reported by Qt.
                # We need to un-camel the LilyPond-reported style name, but
                # this may not be a final fix (see comment to un_camel()).
                # If no match is found we simply hope that the style
                # reported by LilyPond will do.
                for style in lily_styles:
                    style = un_camel(style)
                    if style in qt_styles:
                        match = style
                        break
                if not match:
                    match = un_camel(lily_styles[0])
            if not match in family[sub_family]:
                family[sub_family].append(match)
        else:
            pass
            # TODO: issue a warning?
            # In my examples *some* fonts were parsed improperly
            # and therefore skipped.
            # I *think* this happens at the stage of splitting the
            # LilyPond log into individual lines.
            #print("Error when parsing font entry:")
            #print(name)
            #print(input)

    def flatten_log(self):
        """Flatten job history into flat string list."""
        for line in self.job.history():
            # lines in Job.history() are tuples of text and type,
            # we're only interested in the text.
            lines = line[0].split('\n')
            for l in lines:
                self._log.append(l)

    def is_loaded(self):
        return self._is_loaded

    def load_fonts(self, log_widget=None):
        """Run LilyPond to retrieve a list of available fonts.
        Afterwards process_results() will parse the output and build
        info structures to be used later.
        If a log.Log widget is passed as second argument this will
        be connected to the Job to provide realtime feedback on the process.
        Any caller should connect to the 'loaded' signal because this
        is an asynchronous task that takes long to complete."""
        self.reset()
        self.acknowledge_lily_fonts()
        self.run_lilypond(log_widget)

    def misc_model(self):
        return self._misc_model

    def model(self):
        return self._tree_model

    def parse_entries(self):
        """Parse the LilyPond log and push entries to the various
        lists and dictionaries. Parsing the actual font style
        definition is deferred to add_style_to_family()."""
        regexp = re.compile('(.*)\\-\d+')
        families = {}
        config_files = []
        config_dirs = []
        font_dirs = []
        last_family = None
        for e in self._log:
            if e.startswith('family'):
                # NOTE: output of this process is always English,
                # so we can hardcode the splice indices
                original_family = e[7:]
                # filter size-indexed font families
                basename = regexp.match(original_family)
                last_family = basename.groups(
                )[0] if basename else original_family
            elif last_family:
                # We're in the second line of a style definition
                if not last_family.endswith('-brace'):
                    self.add_style_to_family(families, last_family, e)
                last_family = None
            elif e.startswith('Config files:'):
                config_files.append(e[14:])
            elif e.startswith('Font dir:'):
                font_dirs.append(e[10:])
            elif e.startswith('Config dir:'):
                config_dirs.append(e[12:])

        return families, config_files, config_dirs, font_dirs

    def process_results(self):
        """Parse the job history list to dictionaries."""

        self.flatten_log()
        families, config_files, config_dirs, font_dirs = self.parse_entries()

        self._tree_model.populate(families)
        self._misc_model.populate(config_files, config_dirs, font_dirs)

        self._is_loaded = True
        self.job = None
        self.loaded.emit()

    def run_lilypond(self, log_widget=None):
        """Run lilypond from info with the args list, and a job title."""
        # TODO: Use the global JobQueue
        info = self.lilypond_info
        j = self.job = job.Job([info.abscommand() or info.command] +
                               ['-dshow-available-fonts'])
        j.set_title(_("Available Fonts"))
        j.done.connect(self.process_results)
        if log_widget:
            log_widget.connectJob(j)
        j.start()
示例#27
0
import os

from PyQt5.QtCore import QSettings, QUrl

import app
import util
import signals
import qsettings

from . import documentation

# cache the LilyPond Documentation instances
_documentations = None

allLoaded = signals.Signal()


def docs():
    """Returns the list of Documentation instances that are found."""
    global _documentations
    if _documentations is None:
        _documentations = [documentation.Documentation(url) for url in urls()]
        _sort_docs()
        # check whether they need to fully load their version number yet
        _check_doc_versions()
    return list(_documentations)


def clear():
    """Clears the cached documentation instances."""
示例#28
0
 def __init__(self):
     sm.RegisterNotify(self)
     self.ball = None
     self.on_new_itemID = signals.Signal()
     self.wantedspeed = None
示例#29
0
    class State(object):
        signal = signals.Signal()

        def __init__(self):
            self.value = None
            self.running = False
示例#30
0
 def __init__(self, vgsCrestConnection):
     self.vgsCrestConnection = vgsCrestConnection
     self.aurumBalance = None
     self.transactionHref = None
     self.accountAurumBalanceChanged = signals.Signal()
     self.redeemingTokensUpdated = signals.Signal()