Python proxies.threadsafe_call函数代码示例

def setToolbarsVisible(visible):
    """Show/hide MantidPlot toolbars

    Args:
        visible: If True, make toolbars visible, if False - hidden
    """
    threadsafe_call(_qti.app.setToolbarsVisible, visible)

def stemPlot(source, index, power=None, startPoint=None, endPoint=None):
    """Generate a stem-and-leaf plot from an input table column or workspace spectrum

    Args:
        source: A reference to a workspace or a table.
        index: For a table, the column number or name. For a workspace, the workspace index.
        power: The stem unit as a power of 10. If not provided, a dialog will appear with a suggested value.
        startPoint: The first point (row or bin) to use (Default: the first one).
        endPoint: The last point (row or bin) to use (Default: the last one).

    Returns:
        A string representation of the stem plot
    """
    # Turn the optional arguments into the magic numbers that the C++ expects
    if power == None:
        power = 1001
    if startPoint == None:
        startPoint = 0
    if endPoint == None:
        endPoint = -1

    if isinstance(source, proxies.QtProxyObject):
        source = source._getHeldObject()
    elif hasattr(source, 'getName'):
        # If the source is a workspace, create a table from the specified index
        wsName = source.getName()
        source = threadsafe_call(_qti.app.mantidUI.workspaceToTable.wsName, wsName, [index], False, True)
        # The C++ stemPlot method takes the name of the column, so get that
        index = source.colName(2)
    # Get column name if necessary
    if isinstance(index, int):
        index = source.colName(index)
    # Call the C++ method
    return threadsafe_call(_qti.app.stemPlot, source, index, power, startPoint, endPoint)

def moveMouseToCentre(widget):
    """Moves the mouse over the widget
    """
    if qtest:
        QtCore.QCoreApplication.processEvents()
        threadsafe_call(QTest.mouseMove, widget)
        QtCore.QCoreApplication.processEvents()

def screenshot(widget, filename, description, png_exists=False):
    """ Take a screenshot of the widget for displaying in a html report.

    The MANTID_SCREENSHOT_REPORT environment variable must be set
    to the destination folder. Screenshot taking is skipped otherwise.

    :param widget: QWidget to grab.
    :param filename: Save to this file (no extension!).
    :param description: Short descriptive text of what the screenshot should look like.
    :param png_exists: if True, then the 'filename' already exists. Don't grab a screenshot, but add to the report.
    """
    dest = get_screenshot_dir()
    if not dest is None:
        report = os.path.join(dest, "index.html")

        if png_exists:
            pass
        else:
            # Find the widget if handled with a proxy
            if hasattr(widget, "_getHeldObject"):
                widget = widget._getHeldObject()

        if widget is not None:
            camera = Screenshot()
            threadsafe_call(camera.take_picture, widget, os.path.join(dest, filename + ".png"))

        # Modify the section in the HTML page
        section_text = '<h2>%s</h2>' % filename
        now = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
        section_text += '%s (%s)<br />' % (description, now)
        section_text += '<img src="%s.png" alt="%s"></img>' % (filename, description)

        _replace_report_text(report, filename, section_text)

def closeAllSliceViewers():
    """
    Closes all currently open SliceViewer windows. This might be useful to
    clean up your desktop after opening many windows.
    """
    import mantidqtpython
    threadsafe_call(mantidqtpython.MantidQt.Factory.WidgetFactory.Instance().closeAllSliceViewerWindows)

def plotTableColumns(table, columns, type = -1):
    """
    This plots one or more columns from a table.

    Args:
        table: a qtiplot or mantid table (not a TableWorkspace)
        columns: a list or a tuple of columns names to plot or a string for a single column.
                To plot error bars add their column name(s).
        type: curve style for plot (-1: unspecified; 0: line, default; 1: scatter/dots)
    Returns:
        A handle to the created window. None in case of error.
    """
    # This function uses qtiplot's methods for plotting tables.
    # To be able to plot error bars all column names must be prefixed
    # with the table name.
    if isinstance(columns, tuple) or isinstance(columns, list):
        columns = ['%s_%s' % (table.name(), column) for column in columns]
        columns = tuple(columns)
    else:
        columns = '%s_%s' % (table.name(), columns)

    graph = proxies.Graph(threadsafe_call(_qti.app.plot, table._getHeldObject(), columns, type))
    threadsafe_call(graph.activeLayer().setTitle, table.windowLabel())

    if graph._getHeldObject() == None:
        raise RuntimeError("Cannot create graph, see log for details.")
    else:
        return graph

def saveProjectAs(file_name, compress=False):
    """Save a mantid project

    This will serialise all associated workspaces and windows

    Args:
        file_name :: file path to save to
        compress :: whether to compress the project after saving
    """
    threadsafe_call(_qti.app.saveProjectAs, file_name, compress)

def openProject(file_name, file_version=0):
    """Open a mantid project file.

    This will load all associated workspaces and plots.

    Args:
        file_name :: file path to a mantid project file
        file_version :: file version to use when loading (default 0).
    """
    working_dir = os.path.dirname(os.path.abspath(file_name))
    threadsafe_call(_qti.app.openProject, working_dir, file_name, file_version)

def runPythonScript(code, asynchronous=False, quiet=False, redirect=True):
    """
        Redirects the runPythonScript method to the app object
        @param code :: A string of code to execute
        @param asynchronous :: If the true the code is executed in a separate thread
        @param quiet :: If true no messages reporting status are issued
        @param redirect :: If true then output is redirected to MantidPlot
    """
    if asynchronous and QtCore.QThread.currentThread() != QtGui.qApp.thread():
        asynchronous = False
    threadsafe_call(_qti.app.runPythonScript, code, asynchronous, quiet, redirect)

def selectMultiPeak(source, showFitPropertyBrowser=True, xmin=None, xmax=None):
    """Switch on the multi-peak selecting tool for fitting with the Fit algorithm.

    Args:
        source: A reference to a MultiLayer with the data to fit.
        showFitPropertyBrowser: Whether to show the FitPropertyBrowser or not.
        xmin: An optionall minimum X value to select
        xmax: An optionall maximum X value to select
    """
    if xmin is not None and xmax is not None:
        threadsafe_call(_qti.app.selectMultiPeak, source._getHeldObject(), showFitPropertyBrowser, xmin, xmax)
    else:
        threadsafe_call(_qti.app.selectMultiPeak, source._getHeldObject(), showFitPropertyBrowser)

def copyFolder(source, destination):
    """Copy a folder (and its contents) into another.

    Returns:
        True on success.
    """
    return threadsafe_call(_qti.app.copyFolder, source._getHeldObject(), destination._getHeldObject())

def plot2D(source, style=DEFAULT_2D_STYLE, window=None):
    """Open a 2D plot of the given workspace(s)

    Produces a 2D histogram for each of the given workspaces

    Args:
        source: workspace or name of a workspace
        style: Indicates the type of plot required. Default=ColorMap
        window: window used for plotting. If None a new one will be created
    Returns:
        If a single workspace is specified then the handle is returned, otherwise a list
        of handles for each new window is returned
    """
    names = getWorkspaceNames(source)
    if len(names) == 0:
        raise ValueError("No workspace names given to plot")

    # Unwrap the window object, if any specified
    if window != None:
        window = window._getHeldObject()

    handles = []
    cfunc = _qti.app.mantidUI.drawSingleColorFillPlot
    for name in names:
        g = proxies.Graph(threadsafe_call(cfunc, name, style, window))
        if g:
            handles.append(g)
        else:
            raise RuntimeError("Cannot create graph from workspace '%s'" % name)

    if len(handles) == 1:
        return handles[0]
    else:
        return handles

def screenshot_to_dir(widget, filename, screenshot_dir):
    """Take a screenshot_to_dir of a widget

    @param widget :: QWidget to take an image of
    @param filename :: Destination filename for that image
    @param screenshot_dir :: Directory to put the screenshots into.
    """
    # Find the widget if handled with a proxy
    if hasattr(widget, "_getHeldObject"):
        widget = widget._getHeldObject()

    if widget is not None:
        camera = Screenshot()
        imgpath = os.path.join(screenshot_dir, filename)
        threadsafe_call(camera.take_picture, widget, imgpath)
        return imgpath
    else:
        raise RuntimeError("Unable to retrieve widget. Has it been deleted?")

def changeFolder(folder, force=False):
    """Changes the current folder.

    Args:
        folder: A reference to the folder to change to.
        force: Whether to do stuff even if the new folder is already the active one (default: no).

    Returns:
        True on success.
    """
    return threadsafe_call(_qti.app.changeFolder, folder._getHeldObject(), force)

def plotSubplots(source, indices, distribution = mantidqtpython.MantidQt.DistributionDefault, error_bars=False, window=None):
    """Open a tiled plot.

    This plots one or more spectra, with X as the bin boundaries,
    and Y as the counts in each bin.
    
    If one workspace, each spectrum gets its own tile.
    Otherwise, each workspace gets its own tile.

    Args:
        source: list of workspace names
        indices: workspace index, or tuple or list of workspace indices to plot
        distribution: whether or not to plot as a distribution
        error_bars: bool, set to True to add error bars.
        window: window used for plotting. If None a new one will be created
    Returns:
        A handle to window if one was specified, otherwise a handle to the created one. None in case of error.
    """

    workspace_names = getWorkspaceNames(source)
   
    # Deal with workspace groups that may contain various types:
    # Only want to plot MatrixWorkspaces
    to_plot = []
    for name in workspace_names:
        if isinstance(mantid.api.mtd[name], mantid.api.MatrixWorkspace):
            to_plot.append(name)
            
    __checkPlotWorkspaces(to_plot)
    # check spectrum indices
    index_list = __getWorkspaceIndices(indices)
    if len(index_list) == 0:
        raise ValueError("No spectrum indices given")
    for idx in index_list:
        if idx < 0:
            raise ValueError("Wrong spectrum index (<0): %d" % idx)
    for name in to_plot:
        max_spec = workspace(name).getNumberHistograms() - 1
        for idx in index_list:
            if idx > max_spec:
                raise ValueError("Wrong spectrum index for workspace '%s': %d, which is bigger than the"
                                 " number of spectra in this workspace - 1 (%d)" % (name, idx, max_spec))
    
    # Unwrap the window object, if any specified
    if window != None:
        window = window._getHeldObject()
    
    graph = proxies.Graph(threadsafe_call(_qti.app.mantidUI.plotSubplots,
                                          to_plot, index_list, distribution, error_bars, window))
    if graph._getHeldObject() == None:
        raise RuntimeError("Cannot create graph, see log for details.")
    else:
        return graph