# -*- coding=UTF-8 -*-
# This typing file was generated by typing_from_help.py
# pyright: reportUndefinedVariable=information,reportUnusedImport=false
"""
hiero.ui - # Copyright (c) 2011 The Foundry Visionmongers Ltd.  All Rights Reserved.

"""

import typing
from wulifang.vendor.Qt import QtGui, QtWidgets
import hiero.core

class ApplicationSettings(Shiboken.Object):
    """
    Helper object to set and get application settings.
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    def boolValue(self, key, defaultValue) -> typing.Text:
        """
        Note: use self.value(key, defaultValue) if you just want to retrieve a string setting

        Args:
            key: string name of the value to retrieve
            defaultValue: the value to return if this setting hasn't been saved before. Does not save the value to the default.

        Returns:
            the previously stored value as True or False, named by the key parameter, or the defaultValue parameter

        Overloads:
            self.boolValue(key) ->  returns the previously stored value as True or False, named by the key parameter, or the default value as configured (if configured) by the Hiero code. Use this method if you're looking up a value used by Hiero internally.
        """
        ...
    def setBoolValue(self, key, value):
        """
        saves the value as True or False with the application's settings using the key

        Args:
            key: string name of the value to retrieve
            value: the bool (True or False) value to save.
        """
        ...
    def setValue(self, key, value):
        """
        alias of setValueOverride
        saves the value with the application's settings using the key

        Args:
            key: string name of the value to save
            value: the value to store
        """
        ...
    def value(self, key, defaultValue=None):
        """
        alias of getValueOverride

        Args:
            key: string name of the value to retrieve
            defaultValue: the value to return if this setting hasn't been saved before. Does not save the value to the default

        Returns:
            the previously stored string value named by the key parameter, or the defaultValue parameter
            string, unless the defaultValue is set, in which case, the return value will be the same type as the defaultValue (string, int or bool)
        """
        ...
    ...

class BinView(Shiboken.Object):
    """
    Object representing the Bin View. Passed as the sender object to the event handler callbacks registered for hiero.core.events.EventType.kShowContextMenu type events. Can also be retrieved using hiero.ui.currentContextMenuView when active during the context menu events.
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def getSelection(self, *args, **kwargs) -> typing.Tuple[hiero.core.BinItem, ...]:
        """
        Deprecated; please use the selection method instead.
        """
        ...
    def selection(self) -> typing.Tuple[hiero.core.BinItem, ...]:
        """

        Returns:
            a tuple with the currently selected items.
        """
        ...
    def window(self):
        """
        Return the bin view window
        """
        ...
    ...

class CodecSettings(Shiboken.Object):
    """
    Object to manage codec specific settings. Currently only supports quicktime settings, and only on Mac and Windows.
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    def codecList(self) -> typing.Tuple[typing.Text, ...]:
        """

        Returns:
            a list of available QuickTime codecs.
        """
        ...
    def getQuickTimeCodec(self, settings) -> typing.Text:
        """
        deprecated; please use hiero.ui.CodecSettings.quickTimeCodec instead.
        """
        ...
    def getQuickTimeSettingsAsString(self, settings) -> typing.Text:
        """
        deprecated; please use hiero.ui.CodecSettings.quickTimeSettingsAsString instead.
        """
        ...
    def quickTimeCodec(self) -> typing.Text:
        """

        Returns:
            the human readable codec name encoded in the settings string, which will have been set with a call to showQuickTimeSettingsDialog previously.
        """
        ...
    def quickTimeFrameRate(self) -> float:
        """

        Returns:
            the frame rate setting, which will have been set with a call to showQuickTimeSettingsDialog previously.
        """
        ...
    def quickTimeKeyFrameRate(self) -> int:
        """

        Returns:
            the rate at which to encode key frames, which will have been set with a call to showQuickTimeSettingsDialog previously.
        """
        ...
    def quickTimeQuality(self) -> int:
        """

        Returns:
            the quality setting, which will have been set with a call to showQuickTimeSettingsDialog previously.
        """
        ...
    def quickTimeSettingsAsString(self, settings):
        """
        converts a QuickTime format settings string (as returned from self.showQuickTimeSettingsDialog()) into a human readable string.

        Args:
            settings: string of QuickTime encoded settings, as returned at some point in the past from hiero.ui.CodecSettings.showQuickTimeSettingsDialog

        Returns:
            human readable settings string
        """
        ...
    def showQuickTimeSettingsDialog(
        self, settings, fps, quality, keyframerate, codec
    ) -> typing.Text:
        """
        brings up the QuickTime settings dialog box, on Mac and Windows only. Returns a string representing the settings, in a QuickTime specific (non-human-readable) format.
        To see the return value in a human readable form, pass it to self.quickTimeSettingsAsString(settings). You can also retrieve other values set from this method, with quickTimeCodec, quickTimeKeyFrameRate and quickTimeQuality

        Args:
            settings: a settings string previously returned from this method, or a 0-length string ()
            fps: frame rate to default the dialog to
            quality: integer value indicating quality slider setting
            keyframerate: integer value indicating when to generate key-frames
            codec: string name of the codec to preselect

        Overloads:
            self.showQuickTimeSettingsDialog(settings, fps) -> same as the above, but takes in a QuickTime formatted settings string and an fps to set for the initial values in the dialog.
            self.showQuickTimeSettingsDialog(settings, fps, quality, keyframerate, codec) -> same as the above, but with more parameters.
        """
        ...
    ...

class DisclosureButton(PySide.QtGui.QCheckBox):
    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    def addWidget(self, *args, **kwargs):
        """ """
        ...
    def paintEvent(self, *args, **kwargs):
        """ """
        ...
    def removeWidget(self, *args, **kwargs):
        """ """
        ...
    def setVisible(self, *args, **kwargs):
        """ """
        ...
    def showOrHideWidgets(self, *args, **kwargs):
        """ """
        ...
    ...

class ExportStructureViewer(PySide.QtGui.QWidget):
    EditMode: ...
    """
    """

    Full: ... = ui.Foundry.Storm.UI.ExportStructureViewer.EditMode.Full
    """
    """

    Limited: ... = ui.Foundry.Storm.UI.ExportStructureViewer.EditMode.Limited
    """
    """

    ReadOnly: ... = ui.Foundry.Storm.UI.ExportStructureViewer.EditMode.ReadOnly
    """
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    kAddFileToolTip: ...
    """
    """

    kAddFolderToolTip: ...
    """
    """

    kRemoveToolTip: ...
    """
    """

    kStructureContentToolTip: ...
    """
    """

    kStructurePathToolTip: ...
    """
    """

    selectionChanged: ...
    """
    Signal
    """

    structureModified: ...
    """
    Signal
    """
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    def addFile(self, *args, **kwargs):
        """ """
        ...
    def addFolder(self, *args, **kwargs):
        """ """
        ...
    def allowNodeDelete(self, *args, **kwargs):
        """ """
        ...
    def clearResolveEntries(self, *args, **kwargs):
        """ """
        ...
    def copy(self, *args, **kwargs):
        """ """
        ...
    def cut(self, *args, **kwargs):
        """ """
        ...
    def exportRootChanged(self, *args, **kwargs):
        """ """
        ...
    def filenameField(self, *args, **kwargs):
        """ """
        ...
    def getWidget(self, *args, **kwargs):
        """ """
        ...
    def handleSelectionChanged(self, *args, **kwargs):
        """ """
        ...
    def initUI(self, *args, **kwargs):
        """ """
        ...
    def itemTypes(self, *args, **kwargs):
        """ """
        ...
    def keyPressEvent(self, *args, **kwargs):
        """ """
        ...
    def paste(self, *args, **kwargs):
        """ """
        ...
    def refresh(self, *args, **kwargs):
        """ """
        ...
    def refreshContentField(self, *args, **kwargs):
        """ """
        ...
    def removeNode(self, *args, **kwargs):
        """ """
        ...
    def selectFileIfOnlyOne(self, *args, **kwargs):
        """ """
        ...
    def selectFirstFile(self, *args, **kwargs):
        """ """
        ...
    def selection(self, *args, **kwargs):
        """ """
        ...
    def selectionAnchor(self, *args, **kwargs):
        """ """
        ...
    def selectionRect(self, *args, **kwargs):
        """ """
        ...
    def setAllowNodeDelete(self, *args, **kwargs):
        """ """
        ...
    def setExportStructure(self, *args, **kwargs):
        """ """
        ...
    def setItemTypes(self, *args, **kwargs):
        """ """
        ...
    def setProject(self, *args, **kwargs):
        """ """
        ...
    def setResolveEntry(self, *args, **kwargs):
        """ """
        ...
    ...

class FormatChooser(PySide.QtGui.QComboBox):
    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    formatChanged: ...
    """
    Signal
    """
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    def currentFormat(self, *args, **kwargs):
        """ """
        ...
    def setCurrentFormat(self, *args, **kwargs):
        """ """
        ...
    ...

class IExporterUIRegistry(Shiboken.Object):
    """
    IExporterUIRegistry provides a simple interface for our C++ Application to access the Python instance of TaskUIRegistry.

    This class should not be used directly; use hiero.ui.TaskUIRegistry instead.
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    def aquireProcessorUI(self, preset: hiero.core.ITaskPreset):
        """
        Called from Hiero Application to aquire a reference to an instance of the ProcessorUI object related to the specified hiero.core.TaskPreset.

        Args:
            preset: hiero.core.ITaskPreset
        """
        ...
    def getProcessorUI(self, *args, **kwargs):
        """ """
        ...
    def getProcessorUIForPreset(self, *args, **kwargs):
        """ """
        ...
    def getTaskUI(self, *args, **kwargs):
        """ """
        ...
    def getTaskUIForPreset(self, *args, **kwargs):
        """ """
        ...
    def numProcessorUIs(self, *args, **kwargs):
        """ """
        ...
    def numTaskUIs(self, *args, **kwargs):
        """ """
        ...
    def registerme(self):
        """
        Called from python implimentation of TaskUIRegistry to register instance as the Application TaskUI Registry.
        """
        ...
    def releaseProcessorUI(self, processorUI: IProcessorUI):
        """
        Called from Hiero Application to release the reference to a IProcessorUI object previously aquired using IExporterUIRegistry.aquireProcessorUI.

        Args:
            processorUI: IProcessorUI
        """
        ...
    ...

class IProcessorUI(Shiboken.Object):
    """
    IProcessorUI provides a simple interface for our C++ Application to access Python instances of ProcessorUIBase.

    This class should not be used directly; use hiero.ui.ProcessorUIBase instead.
    """

    EditMode: ...
    """
    """

    Full: ... = ui.Hiero.Python.IProcessorUI.EditMode.Full
    """
    """

    Limited: ... = ui.Hiero.Python.IProcessorUI.EditMode.Limited
    """
    """

    ReadOnly: ... = ui.Hiero.Python.IProcessorUI.EditMode.ReadOnly
    """
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    def displayName(self) -> typing.Text:
        """
        called by Hiero to get the Display name of a task for displaying in UI.
        """
        ...
    def populateUI(
        self,
        processorUIWidget: PySide.QtGui.QWidget,
        taskUIWidget: PySide.QtGui.QWidget,
        items: typing.Optional[hiero.core.ItemWrapper],
        editMode: IProcessorUI.EditMode,
    ):
        """
        called by Hiero to allow the IProcessorUI to populate a QWidget with the ui widgets necessary to reflect the current preset.
        The EditMode is used to instruct the UI generation code to build in ReadOnly mode

        Args:
            processorUIWidget: PySide.QtGui.QWidget
            taskUIWidget: PySide.QtGui.QWidget
            items: typing.Optional[hiero.core.ItemWrapper]
            editMode: IProcessorUI.EditMode
        """
        ...
    def preset(self) -> hiero.core.ITaskPreset:
        """
        called by Hiero to get the TaskPreset which this TaskUI is currently reflecting.
        """
        ...
    def refreshContent(self, *args, **kwargs):
        """ """
        ...
    def savePreset(self, *args, **kwargs):
        """ """
        ...
    def setPreset(self, preset: hiero.core.ITaskPreset):
        """
        called by Hiero to set the TaskPreset which this TaskUI will reflect.

        Args:
            preset: hiero.core.ITaskPreset
        """
        ...
    def toolTip(self) -> typing.Text:
        """
        called by Hiero to get the desciption of a task for displaying in UI as a tooltip.
        """
        ...
    def validate(
        self,
        param1: typing.Optional[
            hiero.core.ItemWrapper,
        ],
    ) -> bool:
        """
        called by Hiero to get .

        Args:
            param1: typing.Optional[hiero.core.ItemWrapper,]
        """
        ...
    def validateSelection(self, *args, **kwargs):
        """ """
        ...
    ...

class ITaskUI(Shiboken.Object):
    """
    ITaskUI provides a simple interface for our C++ Application to access Python instances of TaskUIBase.

    This class should not be used directly; use hiero.ui.TaskUIBase instead.
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    def displayName(self) -> typing.Text:
        """
        called by Hiero to get the Display name of a task for displaying in UI.
        """
        ...
    def ident(self) -> typing.Text:
        """
        called by Hiero to get a unique identifier linking this TaskUI with a Task and TaskPreset.
        """
        ...
    def populateUI(
        self, widget: PySide.QtGui.QWidget, exportTemplate: hiero.core.IExportStructure
    ):
        """
        called by Hiero to allow the TaskUI to populate a QWidget with the ui widgets neccessary to reflect the current preset.

        Args:
            widget: PySide.QtGui.QWidget
            exportTemplate: hiero.core.IExportStructure
        """
        ...
    def preset(self) -> hiero.core.ITaskPreset:
        """
        called by Hiero to get the TaskPreset which this TaskUI is currently reflecting.
        """
        ...
    def setPreset(self, preset: hiero.core.ITaskPreset):
        """
        called by Hiero to set the TaskPreset which this TaskUI will reflect.

        Args:
            preset: hiero.core.ITaskPreset
        """
        ...
    ...

class MediaFlagsChooser(PySide.QtGui.QWidget):
    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    flagsChanged: ...
    """
    Signal
    """
    def __init__(self, *args, **kwargs):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """
        ...
    ...

class Player(Shiboken.Object):
    """
    Object representing a video player in Hiero. Players are used by Viewer objects, and can be retrieved using the player() method of Viewer objects.
    """

    Channels: ...
    """
    """

    MaskOverlayStyle: ...
    """
    """

    ProxyResolution: ...
    """
    """

    WarningOverlay: ...
    """
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    eChannelA: ... = ui.Hiero.Python.Player.Channels.eChannelA
    """
    """

    eChannelB: ... = ui.Hiero.Python.Player.Channels.eChannelB
    """
    """

    eChannelG: ... = ui.Hiero.Python.Player.Channels.eChannelG
    """
    """

    eChannelLuma: ... = ui.Hiero.Python.Player.Channels.eChannelLuma
    """
    """

    eChannelR: ... = ui.Hiero.Python.Player.Channels.eChannelR
    """
    """

    eChannelRGB: ... = ui.Hiero.Python.Player.Channels.eChannelRGB
    """
    """

    eMaskOverlayFull: ...
    """
    """

    eMaskOverlayHalf: ...
    """
    """

    eMaskOverlayLines: ...
    """
    """

    eMaskOverlayNone: ...
    """
    """

    eProxy16: ... = ui.Hiero.Python.Player.ProxyResolution.eProxy16
    """
    """

    eProxy2: ... = ui.Hiero.Python.Player.ProxyResolution.eProxy2
    """
    """

    eProxy32: ... = ui.Hiero.Python.Player.ProxyResolution.eProxy32
    """
    """

    eProxy4: ... = ui.Hiero.Python.Player.ProxyResolution.eProxy4
    """
    """

    eProxy8: ... = ui.Hiero.Python.Player.ProxyResolution.eProxy8
    """
    """

    eProxyAuto: ... = ui.Hiero.Python.Player.ProxyResolution.eProxyAuto
    """
    """

    eProxyFull: ... = ui.Hiero.Python.Player.ProxyResolution.eProxyFull
    """
    """

    eWarningExposure: ...
    """
    """

    eWarningNTSC: ... = ui.Hiero.Python.Player.WarningOverlay.eWarningNTSC
    """
    """

    eWarningNone: ... = ui.Hiero.Python.Player.WarningOverlay.eWarningNone
    """
    """

    eWarningPAL: ... = ui.Hiero.Python.Player.WarningOverlay.eWarningPAL
    """
    """
    def LUT(self) -> typing.Text:
        """

        Returns:
            the name of the LUT currently in use by the player.
        """
        ...
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def alphaIsTransparent(self) -> bool:
        """

        Returns:
            whether the player treats the alpha channel as premultiplied transparency (True) or not (False).
        """
        ...
    def centerImage(self):
        """
        centers the player, resetting the pan values.
        """
        ...
    def channels(self) -> Player.Channels:
        """

        Returns:
            channel(s) that the player is currently displaying.
        """
        ...
    def displayGain(self) -> float:
        """

        Returns:
            the current gain of the player. Defaults to 1.0
        """
        ...
    def displayGamma(self) -> float:
        """

        Returns:
            the current gamma of the player. Since the viewer displays pixels in linear space, this value defaults to 1.0.
        """
        ...
    def guideOverlay(self):
        """

        Returns:
            the guide overlays displayed in the player.
            sequence of foundry.ui.Drawing
        """
        ...
    def ignorePixelAspectRatio(self) -> bool:
        """

        Returns:
            whether the player ignores the pixel aspect ratio or not.
        """
        ...
    def maskOverlay(self) -> foundry.ui.Drawing:
        """

        Returns:
            the drawing used as the mask overlay in the player.
        """
        ...
    def maskOverlayStyle(self) -> Player.MaskOverlayStyle:
        """

        Returns:
            the current drawing style of the mask overlay used by the player.
        """
        ...
    def pan(self, dx, dy):
        """
        pans the player by (dx, dy).

        Args:
            dx: float value to pan in x by
            dy: float value to pan in y by
        """
        ...
    def proxyResolution(self) -> Player.ProxyResolution:
        """
        get the current proxy resolution setting for the player
        """
        ...
    def sequence(self):
        """

        Returns:
            the object currently being played.
            hiero.core.Clip object or hiero.core.Sequence object, depending on what is currently playing
        """
        ...
    def setAlphaIsTransparent(self, alphaIsTransparent):
        """
        sets whether the player treats the alpha channel as premultiplied transparency.

        Args:
            alphaIsTransparent: True to have the player treat alpha as premultiplied transparency, False otherwise
        """
        ...
    def setChannels(self, channels):
        """
        sets the channels to display in the player. It's currently either one of the channels or red, green and blue.

        Args:
            channels: Player.Channels
        """
        ...
    def setDisplayGain(self, gain):
        """
        sets the gain of the player.

        Args:
            gain: float
        """
        ...
    def setDisplayGamma(self, gamma):
        """
        sets the gamma of the player.

        Args:
            gamma: float
        """
        ...
    def setGuideOverlay(self, guideOverlays):
        """
        sets the guide overlays to display in the player.

        Args:
            guideOverlays: sequence of foundry.ui.Drawing
        """
        ...
    def setIgnorePixelAspectRatio(self, ignorePixelAspectRatio):
        """
        tells the player whether or not to display in anamorphic mode.

        Args:
            ignorePixelAspectRatio: True to have the player ignore the pixel aspect ratio, False otherwise
        """
        ...
    def setLUT(self, lut):
        """
        sets the LUT to use in the player. If the lut doesn't exist, it will have no effect on what's displayed by the player.

        Args:
            lut: string name of the lut to use
        """
        ...
    def setMaskOverlay(self, aspect):
        """
        sets the drawing to use for the mask overlay.

        Args:
            aspect: foundry.ui.Drawing
        """
        ...
    def setMaskOverlayStyle(self, style):
        """
        sets the drawing style of the mask overlay.
        @param hiero.ui.Player.MaskOverlayStyle style
        """
        ...
    def setProxyResolution(self, resolution):
        """
        set the player proxy resolution.

        Args:
            resolution: Player.ProxyResolution
        """
        ...
    def setSequence(self, clip):
        """
        sets the clip to be played back by the Player object.
        The clip/sequence must have a parent BinItem, which itself must belong to a Project.

        Args:
            clip: hiero.core.Clip object to play
            sequence: hiero.core.Sequence object to play

        Overloads:
            self.setSequence(sequence) -> sets the sequence to be played back by the Player object.
        """
        ...
    def setWarningOverlay(self, warningOverlay):
        """
        sets the warning overlay.

        Args:
            warningOverlay: One of the following enums: eWarningNone, eWarningExposure, eWarningPAL or eWarningNTSC
        """
        ...
    def time(self):
        """
        gets the time of the playhead.

        Returns:
            frame number
        """
        ...
    def warningOverlay(self):
        """

        Returns:
            player's warningOverlay.
            One of the following enums: eWarningNone, eWarningExposure, eWarningPAL or eWarningNTSC
        """
        ...
    def zoomAbsolute(self, centerX, centerY, zoom):
        """
        scales the image to an absolute value. The centerX and centerY values are currently ignored.

        Args:
            zoom: float value scale by
            centerX: unused
            centerY: unused

        Overloads:
            self.zoomAbsolute(zoom) -> scales the image to an absolute value
        """
        ...
    def zoomRelative(self, centerX, centerY, zoomFactor):
        """
        scales the image relatively and repositions the image.

        Args:
            centerX: new x center of the image, in image pixels
            centerY: new y center of the image, in image pixels
            zoom: float value scale by
        """
        ...
    def zoomToActualSize(self):
        """
        scales and centers the image to the full size of the image.
        """
        ...
    def zoomToFill(self):
        """
        scales the image so that it fills the player window.
        """
        ...
    def zoomToFit(self):
        """
        scales the image so that it fits in the player window, maintaining the pixel aspect ratio.
        """
        ...
    def zoomToFitHeight(self):
        """
        scales the image so that the height of the image fits in the player window, maintaining the pixel aspect ratio.
        """
        ...
    def zoomToFitWidth(self):
        """
        scales the image so that the width of the image fits in the player window, maintaining the pixel aspect ratio.
        """
        ...
    def zoomToHalfSize(self, *args, **kwargs):
        """
        self.zoomToActualSize() -> scales and centers the image to half the size of the image.
        """
        ...
    ...

class ProcessorUIBase(ui.Hiero.Python.IProcessorUI):
    """
    ProcessorUIBase is the base class from which all Processor UI components must derive.  Defines the UI structure followed
    by the specialised processor UIs.
    """

    def __init__(self, preset, itemTypes):
        """ """
        ...
    def checkOfflineMedia(self, exportItems):
        """ """
        ...
    def checkUnrenderedComps(self, exportItems):
        """
        Check for unrendered comps selected for export and ask the user what to do.
        """
        ...
    def createPathPreviewWidget(self):
        """
        Create a widget for showing a preview of the expanded export path.
        """
        ...
    def createProcessorSettingsWidget(self, exportItems):
        """
        Create the UI for processor-specific settings.  To be reimplemented by subclasses.
        """
        ...
    def createVersionWidget(self):
        """
        Create a widget for selecting the version number for export.
        """
        ...
    def findCompItems(self, items):
        """
        Search for comp clips and track items in a list of ItemWrappers.
        """
        ...
    def findOfflineMedia(self, exportItems):
        """ """
        ...
    def findTagsForItems(self, exportItems):
        """
        Find tags for the export items.
        """
        ...
    def getTaskItemType(self):
        """ """
        ...
    def isTranscodeExport(self):
        """
        Check if there are transcode tasks in this export.
        """
        ...
    def offlineMediaPrompt(self, messageText, messageDetails, hasOnline):
        """ """
        ...
    def onExportStructureModified(self):
        """
        Callback when the export structure is modified by the user.
        """
        ...
    def onExportStructureSelectionChanged(self):
        """
        Callback when the selection in the export structure viewer changes.
        """
        ...
    def onExportStructureViewerDestroyed(self):
        """
        Callback when the export structure viewer is destroyed.  Qt will delete it while we still
        have a reference, so reset to None when the destroyed() signal is emitted.
        """
        ...
    def onVersionIndexChanged(self, value):
        """
        Callback when the version index changes.
        """
        ...
    def onVersionPaddingChanged(self, padding):
        """
        Callback when the version padding changes.
        """
        ...
    def populateUI(self, processorUIWidget, taskUIWidget, exportItems):
        """
        Build the processor UI and add it to widget.
        """
        ...
    def preset(self):
        """
        Get the export preset.
        """
        ...
    def processorSettingsLabel(self):
        """
        Get the label which is put on the tab for processor-specific settings.  To be reimplemented by subclasses.
        """
        ...
    def projectFromSelection(self, items):
        """ """
        ...
    def refreshContent(self):
        """
        Refresh the content area of this ProcessorUI
        """
        ...
    def savePreset(self):
        """
        Save the export template to the preset.
        """
        ...
    def setPreset(self, preset):
        """
        Set the export preset.
        """
        ...
    def setTaskContent(self, preset):
        """
        Get the UI for a task preset and add it in the 'Content' tab.
        """
        ...
    def skipOffline(self):
        """ """
        ...
    def toTrackItems(self, items):
        """ """
        ...
    def updatePathPreview(self):
        """
        Update the path preview widget for the currently selected item in the
        tree view.
        """
        ...
    def validate(self, exportItems):
        """
        Validate settings in UI. Return False for failure in order to abort export.
        """
        ...
    ...

class RenderTaskUIBase(TaskUIBase):
    """
    RenderTaskUIBase is a specialization of TaskUIBase which reflects the codec properties in RenderTaskPreset into UI
    """

    staticMetaObject: ...
    """
    """
    def __init__(self, taskType, preset, displayName):
        """
        A task base that includes functionality for displaying output selection UI.
        """
        ...
    def buildCodecUI(self, layout, itemTaskType):
        """
        Populate layout with widgets reflected from the RenderPresetBase class
        """
        ...
    def buildEncoderPropertiesWidget(self, file_type):
        """
        Create the encoder properties widget.  This is only used for the settings in the mov32/64 encoders.
        """
        ...
    def codecTypeComboBoxChanged(self, value):
        """ """
        ...
    def createChannelsWidget(self, layout):
        """ """
        ...
    def createCodecOptionsPlaceholder(self, layout):
        """ """
        ...
    def createCodecPropertyWidgets(self, file_type, propertyDictionaries):
        """
        Create widgets for the given property dictionaries, and add them to the given layout.
        """
        ...
    def createColourSpaceWidget(self, layout):
        """ """
        ...
    def createFileTypeWidget(self, layout):
        """ """
        ...
    def createReformatWidgets(self, layout, itemTaskType):
        """ """
        ...
    def deleteFirstChildFromWidget(self, widget):
        """
        Get the first child added to the widget's layout, and delete it, if it exists.
        """
        ...
    def encoderComboBoxChanged(self):
        """ """
        ...
    def formatChanged(self):
        """ """
        ...
    def movCodecComboBoxChanged(self):
        """ """
        ...
    def propertyChanged(self):
        """ """
        ...
    def reformatChanged(self):
        """
        Callback when the Reformat combo box selection has changed. Enable/disable
        the reformat property widgets as appropriate.
        """
        ...
    def setFormat(self, format):
        """ """
        ...
    def updateChannelsForFileType(self, fileType):
        """ """
        ...
    def updateCodecPropertiesWidget(self, file_type):
        """
        Update the codec properties widget. If applicable, also updates the encoder properties (for movs).
        """
        ...
    ...

class SpreadsheetView(Shiboken.Object):
    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def beginSelectionUpdate(self):
        """
        Call beginSelectionUpdate before, and endSelectionUpdate after, making multiple setSelection.
        """
        ...
    def endSelectionUpdate(self):
        """
        Call beginSelectionUpdate before, and endSelectionUpdate after, making multiple setSelection.
        """
        ...
    def selectAll(self):
        """
        Select All TrackItems within current sequence.
        """
        ...
    def selectNone(self):
        """
        Unselect all TrackItems.
        """
        ...
    def selection(self, *args, **kwargs):
        """ """
        ...
    def sequence(self, *args, **kwargs):
        """ """
        ...
    def setSelection(self, arg1: hiero.core.TrackItem):
        """
        Will throw exception if selection is not subset of current sequence.

        Args:
            selection: track item(s) to be selected.

        Overloads:
            self.setSelection( [hiero.core.TrackItem] )
        """
        ...
    def window(self):
        """
        Return the spreadsheet view window
        """
        ...
    ...

class TaskUIBase(ui.Hiero.Python.ITaskUI, PySide.QtCore.QObject):
    """
    TaskUIBase is the base class from hich all TaskUI components should derrive
    """

    propertiesChanged: ...
    """
    Signal
    """

    staticMetaObject: ...
    """
    """
    def __init__(self, taskType, preset, displayName):
        """
        Initialise Exporter Preset Base Class
        """
        ...
    def displayName(self):
        """
        Exporter name to be displayed in the UI
        """
        ...
    def ident(self):
        """ """
        ...
    def initializeAndPopulateUI(self, widget, exportTemplate):
        """ """
        ...
    def initializeUI(self, widget):
        """ """
        ...
    def parentType(self):
        """ """
        ...
    def populateUI(self, widget, exportTemplate):
        """
        populateUI() Export dialog to allow the TaskUI to populate a QWidget with the ui widgets neccessary to reflect the current preset.
        """
        ...
    def preset(self):
        """
        Return Preset currently assigned to ExporterUI
        """
        ...
    def setPreset(self, preset):
        """
        Assign Preset to ExporterUI
        """
        ...
    def setProject(self, project):
        """
        Set the project being used for the current export.
        """
        ...
    def setTags(self, tags):
        """
        setTags passes the subset of tags associated with the selection for export
        """
        ...
    def setTaskItemType(self, type):
        """ """
        ...
    def taskItemType(self):
        """ """
        ...
    ...

class TaskUIRegistry(ui.Hiero.Python.IExporterUIRegistry):
    """
    Registry/factory for ITaskUI and IProcessorUI objects.
    """

    def __init__(self):
        """ """
        ...
    def getNewTaskUIForPreset(self, preset):
        """
        Get a new instance of the task UI class for the preset.
        """
        ...
    def getProcessorUI(self, index):
        """
        Return ProcessorUI registered at specified index
        """
        ...
    def getProcessorUIForPreset(self, preset):
        """
        Return ProcessorUI object associated with the preset type.  Note that
        this returns a stored instance of the preset.
        """
        ...
    def getTaskUI(self, index):
        """
        Return TaskUI registered at specified index
        """
        ...
    def getTaskUIForPreset(self, preset):
        """
        Return TaskUI object associated with the preset type.  Note that this
        returns a stored instance of the preset, which is suitable for calling
        from C++ code.  For actually constructing UIs, getNewTaskUIForPreset()
        should be called to create a new object.
        """
        ...
    def numProcessorUIs(self):
        """
        Get the number of registered IProcessorUI classes.
        """
        ...
    def numTaskUIs(self):
        """
        Get the number of registered ITaskUI classes.
        """
        ...
    def processorUIByIndex(self, index):
        """
        Return ProcessorUI registered at specified index
        """
        ...
    def registerProcessorUI(self, processorPreset, processorUI):
        """
        Register IProcessorUI class and associate with IProcessorPreset class
        """
        ...
    def registerTaskUI(self, taskPreset, taskUI):
        """
        Register an ITaskUI class and associate with an ITaskPreset class
        """
        ...
    ...

class TimelineEditor(Shiboken.Object):
    """
    Object representing the Timeline Editor.
    """

    __new__: ...
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def beginSelectionUpdate(self):
        """
        Call beginSelectionUpdate before, and endSelectionUpdate after, making multiple setSelection.
        """
        ...
    def endSelectionUpdate(self):
        """
        Call beginSelectionUpdate before, and endSelectionUpdate after, making multiple setSelection.
        """
        ...
    def getSelection(
        self, *args, **kwargs
    ) -> typing.Tuple[TrackItem and Transition, ...]:
        """
        Deprecated; please use the selection method instead.
        """
        ...
    def selectAll(self):
        """
        Select All TrackItems within current sequence.
        """
        ...
    def selectNone(self):
        """
        Unselect all TrackItems and Tracks.
        """
        ...
    def selection(
        self,
    ) -> typing.Tuple[
        typing.Union[
            hiero.core.TrackItem, hiero.core.VideoTrack, hiero.core.AudioTrack
        ],
        ...,
    ]:
        """

        Returns:
            a tuple with the currently selected items.
        """
        ...
    def sequence(self) -> hiero.core.Sequence:
        """

        Returns:
            the Sequence currently being edited in the timeline editor.
        """
        ...
    def setSelection(self, arg1: hiero.core.TrackItem):
        """
        Will throw exception if selection is not subset of current sequence.

        Args:
            selection: track item(s) to be selected.

        Overloads:
            self.setSelection( [hiero.core.TrackItem] )
        """
        ...
    def setTrackSelection(self, arg1: hiero.core.TrackBase):
        """
        Will throw exception if selection is not subset of current sequence.

        Args:
            selection: Tracks to be selected.

        Overloads:
            self.setTrackSelection( [hiero.core.TrackBase] )
        """
        ...
    def window(self):
        """
        Return the timeline editor window
        """
        ...
    ...

class VersionWidget(PySide.QtGui.QSpinBox):
    """
    Widget for editing version indices and padding. This extends QSpinbox to
    allow the user to add leading zeroes to specify padding.
    """

    paddingChanged: ...
    """
    Signal
    """

    staticMetaObject: ...
    """
    """
    def __init__(self):
        """ """
        ...
    def padding(self):
        """ """
        ...
    def setPadding(self, padding):
        """ """
        ...
    def sizeHint(self):
        """ """
        ...
    def textFromValue(self, value):
        """ """
        ...
    def valueFromText(self, text):
        """ """
        ...
    ...

class Viewer(Shiboken.Object):
    """
    Object for manipulating viewers in Hiero. Get the currently active viewer by calling hiero.ui.currentViewer().
    """

    CompareMode: ...
    """
    """

    LayoutMode: ...
    """
    """

    eCompareDifference: ...
    """
    """

    eCompareInvertAndAdd: ...
    """
    """

    eCompareMinus: ... = ui.Hiero.Python.Viewer.CompareMode.eCompareMinus
    """
    """

    eCompareNoBlend: ... = ui.Hiero.Python.Viewer.CompareMode.eCompareNoBlend
    """
    """

    eCompareOnionSkin: ...
    """
    """

    eCompareOver: ... = ui.Hiero.Python.Viewer.CompareMode.eCompareOver
    """
    """

    eCompareUnder: ... = ui.Hiero.Python.Viewer.CompareMode.eCompareUnder
    """
    """

    eLayoutFree: ... = ui.Hiero.Python.Viewer.LayoutMode.eLayoutFree
    """
    """

    eLayoutGrid: ... = ui.Hiero.Python.Viewer.LayoutMode.eLayoutGrid
    """
    """

    eLayoutHorizontal: ...
    """
    """

    eLayoutStack: ... = ui.Hiero.Python.Viewer.LayoutMode.eLayoutStack
    """
    """

    eLayoutVertical: ... = ui.Hiero.Python.Viewer.LayoutMode.eLayoutVertical
    """
    """

    eLayoutWipe: ... = ui.Hiero.Python.Viewer.LayoutMode.eLayoutWipe
    """
    """

    eNumLayoutModes: ... = ui.Hiero.Python.Viewer.LayoutMode.eNumLayoutModes
    """
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def cachedFrames(self):
        """
        get the frames which are currently cached in the viewer.

        Returns:
            set containing the indices of the cached frames
        """
        ...
    def compareMode(self) -> Viewer.CompareMode:
        """

        Returns:
            the compare mode for the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def enterFullScreen(self):
        """
        puts the viewer into full screen mode. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def exitFullScreen(self):
        """
        takes the viewer out of full screen mode. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def flushCache(self):
        """
        flush the cache on the viewer and pause caching.
        """
        ...
    def frameIncrement(self):
        """

        Returns:
            the frame increment for the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
            the number of frames to skip or nudge
        """
        ...
    def getAchievedFPS(self):
        """

        Returns:
            the average fps achieved by the viewer.
            floating point frames per second average
        """
        ...
    def goToInTime(self):
        """
        alias of _goToInTime
        Move playhead to In point
        """
        ...
    def goToNextEdit(self):
        """
        Move playhead to next edit. Can only be called from the user interface thread.
        """
        ...
    def goToNextTag(self):
        """
        Move playhead to next tag. Can only be called from the user interface thread.
        """
        ...
    def goToOutTime(self):
        """
        alias of _goToOutTime
        Move playhead to Out point
        """
        ...
    def goToPrevEdit(self):
        """
        Move playhead to previous edit. Can only be called from the user interface thread.
        """
        ...
    def goToPrevTag(self):
        """
        Move playhead to previous tag. Can only be called from the user interface thread.
        """
        ...
    def goToTag(self, tag):
        """
        alias of _goToTag
        Move playhead to Tag.
        If Tag (Tag Object or Tag name) does not exists on the Viewer's Sequence/Clip
        a KeyError is raised.

        Args:
            tag: a Tag object or the name of the desired tag.
        """
        ...
    def goToTrackItemEnd(self, trackItem):
        """
        alias of _goToTrackItemEnd
        Move playhead to end of the trackItem.

        Args:
            trackItem: sequence's track item.
        """
        ...
    def goToTrackItemMiddle(self, trackItem):
        """
        alias of _goToTrackItemMiddle
        Move playhead to middle of the trackItem.

        Args:
            trackItem: sequence's track item.
        """
        ...
    def goToTrackItemStart(self, trackItem):
        """
        alias of _goToTrackItemStart
        Move playhead to start of the trackItem.

        Args:
            trackItem: sequence's track item.
        """
        ...
    def image(self) -> PySide.QtGui.QImage:
        """

        Returns:
            the contents of the viewer as an image, including all overlays. Can only be called from the user interface thread.
        """
        ...
    def isCachingPaused(self) -> bool:
        """
        get whether caching is paused.
        """
        ...
    def layoutMode(self) -> Viewer.LayoutMode:
        """

        Returns:
            the layout mode the viewer is currently in.
        """
        ...
    def overlaysShown(self) -> bool:
        """
        get whether overlays are shown in the viewer.
        """
        ...
    def pauseCaching(self):
        """
        pause caching on the viewer.
        """
        ...
    def play(self):
        """
        starts playback in the viewer in the forward direction. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def playBackwards(self):
        """
        starts playback in the viewer in the backwards direction. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def playForwards(self):
        """
        starts playback in the viewer in the forward direction. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def player(self, index) -> Player:
        """

        Args:
            index: integer index of the player to retrieve

        Returns:
            the player object attached to this viewer, based on the input index.
        """
        ...
    def resumeCaching(self):
        """
        resume caching on the viewer.
        """
        ...
    def setCompareMode(self, mode):
        """
        changes the compare mode for the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.

        Args:
            compareMode: a Viewer.CompareMode value
        """
        ...
    def setDisplayTimecode(self, displayTimecode) -> None:
        """
        Sets the viewer to display Timecode if 'displayTimecode' is True, or Timeline Frame otherwise
        """
        ...
    def setFrameIncrement(self, frames):
        """
        changes the frame increment for the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.

        Args:
            frames: the number of frames to skip or nudge
        """
        ...
    def setLayoutMode(self, mode):
        """
        changes the layout mode for the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.

        Args:
            layoutMode: a Viewer.LayoutMode value indicating what layout to set the viewer to
        """
        ...
    def setOverlaysShown(self, show):
        """
        set whether overlays are shown in the viewer.

        Args:
            show: bool
        """
        ...
    def setTime(self, time):
        """
        seeks the play head of the viewer to the time parameter. Works the same as scrubbing the timeline in the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.

        Args:
            time: frame to set the play head to
        """
        ...
    def setView(self, name, viewIndex):
        """
        If name matches an existing view then the Viewers's active view for viewIndex is set to the view given by name.

        Args:
            name: typing.Text
            viewIndex: optional; integer (for example in stereo a viewIndex of 0 corresponds to the primary view and 1 to the secondary view)
        """
        ...
    def stop(self):
        """
        stops playback in the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def time(self):
        """

        Returns:
            the current frame of the viewer.
        """
        ...
    def toggleFullScreen(self):
        """
        toggles full screen mode for the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def toggleFullScreen1_1(self):
        """
        toggles 1:1 full screen mode for the viewer. Can only be called from the user interface thread. Use hiero.core.executeInMainThread if you need to call it from a non-ui thread.
        """
        ...
    def view(self, viewIndex):
        """
        Returns the name of the active view for viewIndex.

        Args:
            viewIndex: optional; integer (for example in stereo a viewIndex of 0 corresponds to the primary view and 1 to the secondary view)
        """
        ...
    def window(self):
        """
        Return the viewer window
        """
        ...
    def wipeTool(self) -> ViewerWipeTool:
        """
        return the split wipe tool for this viewer.
        """
        ...
    ...

class ViewerWipeTool(Shiboken.Object):
    """
    Object for manipulating the viewer wipe tool in Hiero.
    """

    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def isActive(self, index) -> bool:
        """

        Args:
            index: integer index of the player to retrieve

        Returns:
            True if the tool is active.
        """
        ...
    def setActive(self, active) -> None:
        """
        Make the tool active or inactive.

        Args:
            active: the active state
        """
        ...
    ...

class WindowManager(Shiboken.Object):
    """
    Global object to handle window management in Hiero. Use hiero.ui.windowManager() to get the single instance of this object to use.
    """

    WindowMenuSection: ...
    """
    """

    kApplicationSection: ...
    """
    """

    kDocumentSection: ...
    """
    """

    kNumGroups: ...
    """
    """

    kQAToolsSection: ...
    """
    """
    def __copy__(self, *args, **kwargs):
        """ """
        ...
    def addWindow(self, window, section, shortcut):
        """
        adds a window to the window manager and insert a menu item for it into the Window menu. This will also make the window dockable with Hiero's other windows.

        Args:
            window: QWidget object for the window
            section: section (either an int, or a WindowManager.WindowMenuSection) to insert the menu item into
            shortcut: shortcut to apply to the menu item. See the documentation on QKeySequence for more info
        """
        ...
    def popupWindow(self, window):
        """
        Opens the window in a floating dock panel.

        Args:
            window: QWidget object for the window
        """
        ...
    def showWindow(self, window):
        """
        Opens the window in its layout position or if as a floating dock panel

        Args:
            window: QWidget object for the window
        """
        ...
    def windows(self):
        """
        Returns a list with the available widgets in WindowManager

        Returns:
            list of the available widgets in WindowManager
        """
        ...
    ...

def InvalidOutputResolutionMessage(message):
    """ """
    ...

def _addMenuActionR(path, action, menu, before=None):
    """
    # Menus
    """
    ...

def _areNonDaemonThreadsStillRunning():
    """ """
    ...

def _checkForStillRunningThreads(event):
    """ """
    ...

def _findMenuActionR(name, menu):
    """ """
    ...

def _isWaitForRunningThreads():
    """
    # Override the threading exit handler
    """
    ...

def activeSequence() -> typing.Optional[hiero.core.Sequence]:
    """
    gets the currently active sequence.

    Returns:
        a hiero.core.Sequence of the last activated hiero.ui.TimelineEditor, hiero.ui.SpreadsheetView object or hiero.ui.Viewer object
    """
    ...

def activeView() -> typing.Union[TimelineEditor, SpreadsheetView, Viewer, BinView]:
    """
    gets the currently active view object.

    Returns:
        depending on the active view, a hiero.ui.TimelineEditor, a hiero.ui.SpreadsheetView object, a hiero.ui.Viewer object or a hiero.ui.BinView object
    """
    ...

def addMenuAction(path, action, before=None):
    """
    Add a QAction to the main menubar. The 'path' parameter specifies the menu to which to add the action as a '/'-separated string.
    The path may contain either internal action names or display names. e.g. 'View/Transform', or (better) 'foundry.menu.view/foundry.view.transform'."
    The optional 'before' parameter specifies the name of an item the action should be inserted before. If this is not specified, the action is appended to the menu.
    """
    ...

def browseForApplication(*args, **kwargs) -> typing.Text:
    """
    hiero.ui.browseForApplication (message, initialPath, parentWidget) -> brings up the file browser to allow the user to select an application. Allows the user to select an executable file on Windows and Linux, and to select an application bundle (\\*.app) directory on OSX.

    Args:
        message: prompt to display to the user in the file browser
        initialPath: initial path to set the file browser to. Can be a zero length string
        parentWidget: QWidget to set as the parent of the file browser. Can be None.
    """
    ...

def createMenuAction(name, method, icon=None):
    """
    Creates a menu action (QAction) for use in context menus or Main menubar.
    The 'name' parameter specifies the title of the action.

    Args:
        name: name - the title of the menu action
        method: method - the Python method which this action triggers
        icon: icon (optional) - provides an icon for the action. This can be an absolute path ('/var/tmp/myIcon.png'), or relative path ('icons:myIcon.png')
    """
    ...

def currentContextMenuView():
    """

    Returns:
        the current view for the context menu. Only valid during a kShowContextMenu event callback.
        hiero.ui.Viewer, hiero.ui.TimelineEditor, hiero.ui.BinView, depending on which window had the context menu created for it
    """
    ...

def currentViewer() -> Viewer:
    """

    Returns:
        the current viewer window.
    """
    ...

def currentWorkspace():
    """
    Returns the name of the current Workspace.

    Returns:
        name of current Workspace as a string
    """
    ...

def findMenuAction(name):
    """
    Find a QAction in the main menubar. The 'name' parameter specifies the name of the action.
    The name may be either an internal action name or a display name. e.g. 'Cut', or (better) 'foundry.application.cut'."
    """
    ...

def findRegisteredAction(name):
    """
    Find the action with the given name.

    Returns:
        a QAction, or None if not found.
    """
    ...

def findRegisteredActions(pattern):
    """
    Find the action that starts with the given pattern.

    Returns:
        a QAction list or None on an error.
    """
    ...

def flushAllViewersCache():
    """
    flush the cache of all viewers and pause caching
    """
    ...

def getFlipbook(*args, **kwargs):
    """ """
    ...

def getProjectRootInteractive(project):
    """
    Try to get a valid root path from the project.  If the existing projectRoot()
    is not set or doesn't exist, the user will be prompted to select one.  If no path
    is selected, returns None.
    """
    ...

def getTimelineEditor(sequence: hiero.core.Sequence) -> typing.Optional[TimelineEditor]:
    """
    Find the TimelineEditor for the given Sequence.

    Returns:
        a hiero.ui.TimelineEditor, or None if no appropriate TimelineEditor is found.
    """
    ...

def insertMenuAction(action, menu, before=None, after=None):
    """
    Insert a QAction into the given QMenu. If strings 'before' or 'after' are specified, the action is inserted before or after the action with that name.
    If no such action is found or 'before/after' are not given, the action is appended to the menu.
    """
    ...

def isInAnyProject(*args, **kwargs):
    """ """
    ...

def isInAnyTimeline(*args, **kwargs):
    """ """
    ...

def mainWindow() -> QtWidgets.QMainWindow:
    """
    used to get Hiero's main window object.
    """
    ...

def menuBar() -> QtWidgets.QMenuBar:
    """
    used to get Hiero's global menu bar.
    """
    ...

def openFileBrowser(
    caption="",
    mode=1,
    pattern="",
    initialPath="",
    forSave=False,
    canChooseMultiple=False,
    sequencesEnabled=False,
    mayNotExist=False,
    showAllFileTypes=False,
    confirmOverwrite=True,
    requiredExtension="",
):
    """
    string list.
    Displays a modal foundry file browser dialog.

    Args:
        caption: Optional. Message to display in the dialog.
        mode: Optional. Selection mode (1=Files Only, 2=Directories Only, 3=Files and Directories)
        pattern: Optional. File filter pattern.
        initialPath: Optional. The selected path on dialog creation.
        forSave: Optional. Configure dialog for saving a file.
        multipleSelection: Optional. Allow selection of multiple files.
        sequencesEnabled: Optional. Configure file browser for showing sequences.
        mayNotExist: Optional. Allow return of paths that don't exist e.g. for saving.
        showAllFileTypes: Optional. Show all files regardless of the filter.
        confirmOverwrite: Optional. If file exists will ask user to confirm overwrite. If canceled the file will not be in the returned list of paths.
        requiredExtension: Optional. Enforce a certain file extension.

    Returns:
        The selected files as a list of strings
    """
    ...

def openInNewViewer(binItem) -> Viewer:
    """
    Opens a BinItem's activeItem (Clip/Sequence) in a new Viewer.

    Args:
        binItem: hiero.core.BinItem to be opened in a new Viewer
    """
    ...

def openInOSShell(*args, **kwargs):
    """ """
    ...

def openInSpreadsheet(sequence) -> SpreadsheetView:
    """
    Opens a Sequence in a Spreadsheet.

    Args:
        sequence: hiero.core.Sequence to be opened in Spreadsheet
    """
    ...

def openInTimeline(arg1: hiero.core.BinItem) -> typing.Tuple[TimelineEditor, ...]:
    """
    Opens a BinItem's activeItem (Clip/Sequence) in a Timeline View.

    Overloads:
        hiero.ui.openInTimeline( [hiero.core.BinItem] ) -> Opens a list of BinItems' activeItems (Clips/Sequences) in a Timeline View.
    """
    ...

def openInViewer(binItem) -> Viewer:
    """
    Opens a BinItem's activeItem (Clip/Sequence) in the Viewer.

    Args:
        binItem: hiero.core.BinItem to be opened in the current Viewer
    """
    ...

def registerAction(action: QtWidgets.QAction) -> None:
    """
    Register an action.
    """
    ...

def registerBinViewCustomMimeDataType(customMimeType):
    """
    registers a custom mime type so that Hiero passes on drag and drop events through the event system. For an example of how to use this method, see the bin_drop.py example.
    """
    ...

def registerPanel(id, command):
    """ """
    ...

def registeredActions() -> typing.Tuple[QtWidgets.QAction, ...]:
    """
    Returns a list of all registered actions.

    Returns:
        a tuple of QActions
    """
    ...

def resetCurrentWorkspace() -> None:
    """
    Resets the current Workspace to its default state.
    """
    ...

def restorePanel(id):
    """ """
    ...

def saveWorkspace(name) -> None:
    """
    Save the current Workspace with name.
    Example: hiero.ui.saveWorkspace('NewWorkspaceName')
    """
    ...

def sendToViewerA(binItem):
    """
    Sends a BinItem's activeItem (Clip/Sequence) to the Viewer A.

    Args:
        binItem: hiero.core.BinItem to be opened in the current Viewer's A Buffer
    """
    ...

def sendToViewerB(binItem):
    """
    Sends a BinItem's activeItem (Clip/Sequence) to the Viewer B.

    Args:
        binItem: hiero.core.BinItem to be opened in the current Viewer's B buffer
    """
    ...

def setWorkspace(name) -> None:
    """
    Sets the Workspace with name, as per the name in the Workspace menu.
    Example: hiero.ui.setWorkspace('Reviewing')
    """
    ...

def trackNameValidator():
    """ """
    ...

def unregisterBinViewCustomMimeDataType(customMimeType):
    """
    unregisters a custom mime type that was previously registered using hiero.ui.registerBinViewCustomMimeDataType().
    """
    ...

def unregisterPanel(id, command):
    """ """
    ...

def updateViewer(*args, **kwargs):
    """ """
    ...

def windowManager() -> WindowManager:
    """

    Returns:
        the single WindowManager object.
    """
    ...

__all__: ...
"""
['ApplicationSettings', 'BinView', 'BuildExternalMediaTrack'...
"""

_panels: dict
"""
{}
"""

taskUIRegistry: ...
"""
<hiero.ui.FnExportUIRegistry.TaskUIRegistry object>
"""

viewer_guides: ...
"""
[<hiero.ui.guides.SimpleGuide object>, <hiero.ui.guide...
"""

viewer_masks: ...
"""
[<hiero.ui.guides.MaskGuide object>, <hiero.ui.guides.M...
"""
