Exemple #1
0
    def setupUi(self, Item):
        Item.setObjectName("Item")
        Item.resize(329, 65)
        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Minimum)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(Item.sizePolicy().hasHeightForWidth())
        Item.setSizePolicy(sizePolicy)
        Item.setMinimumSize(QtCore.QSize(0, 65))
        self.verticalLayout = QtGui.QVBoxLayout(Item)
        self.verticalLayout.setSpacing(2)
        self.verticalLayout.setContentsMargins(2, 2, 2, 2)
        self.verticalLayout.setObjectName("verticalLayout")
        self.background = ClickBubblingGroupBox(Item)
        self.background.setTitle("")
        self.background.setObjectName("background")
        self.horizontalLayout = QtGui.QHBoxLayout(self.background)
        self.horizontalLayout.setSpacing(8)
        self.horizontalLayout.setContentsMargins(10, 2, 2, 2)
        self.horizontalLayout.setObjectName("horizontalLayout")
        self.light = QtGui.QLabel(self.background)
        self.light.setText("")
        self.light.setPixmap(QtGui.QPixmap(":/res/empty_bullet.png"))
        self.light.setObjectName("light")
        self.horizontalLayout.addWidget(self.light)
        self.thumbnail = ThumbnailLabel(self.background)
        self.thumbnail.setMinimumSize(QtCore.QSize(60, 40))
        self.thumbnail.setMaximumSize(QtCore.QSize(60, 40))
        self.thumbnail.setText("")
        self.thumbnail.setPixmap(QtGui.QPixmap(":/res/no_thumb.png"))
        self.thumbnail.setScaledContents(False)
        self.thumbnail.setAlignment(QtCore.Qt.AlignCenter)
        self.thumbnail.setObjectName("thumbnail")
        self.horizontalLayout.addWidget(self.thumbnail)
        self.details = QtGui.QLabel(self.background)
        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(self.details.sizePolicy().hasHeightForWidth())
        self.details.setSizePolicy(sizePolicy)
        self.details.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
        self.details.setWordWrap(True)
        self.details.setObjectName("details")
        self.horizontalLayout.addWidget(self.details)
        self.verticalLayout.addWidget(self.background)

        self.retranslateUi(Item)
        QtCore.QMetaObject.connectSlotsByName(Item)
Exemple #2
0
    def __init__(self, parent=None):
        QtGui.QMainWindow.__init__(self, parent)

        if sys.platform == "darwin":
            self.setAttribute(QtCore.Qt.WA_MacNoShadow)

        self.filter = self.ApplicationEventFilter(self)
        QtGui.QApplication.instance().installEventFilter(self.filter)

        self.setWindowFlags(self.windowFlags() | QtCore.Qt.FramelessWindowHint)

        self.__state = None  # pinned or windowed
        self.__anchor_side = None  # which side the anchor is currently pinned on
        self.__content_layout = None  # layout whose margin will be set to contain the anchor
        self.__mouse_down_pos = None  # track position when dragging
        self.__mouse_down_global = None  # track global position when dragging

        # setup the anchor
        self.__bottom_anchor = QtGui.QPixmap(":/tk-desktop/anchor_arrow.png")
        self.__top_anchor = self.__bottom_anchor.transformed(
            QtGui.QTransform(1, 0, 0, -1, 0, 0))
        self.__right_anchor = self.__bottom_anchor.transformed(
            QtGui.QTransform(0, 1, 1, 0, 0, 0))
        self.__left_anchor = self.__bottom_anchor.transformed(
            QtGui.QTransform(0, 1, -1, 0, 0, 0))

        # radius for rounded corners
        self.__corner_radius = 4

        # widgets that will trigger the drag to move behavior
        self.__drag_widgets = []

        # create the system tray icon
        self.systray = ShotgunSystemTrayIcon(self)
        self.systray.show()

        # hook up handler for when the systray is clicked
        self.systray.clicked.connect(self.systray_clicked)
def show_dialog(app):
    """
    Show the main loader dialog

    :param app:    The parent App
    """
    # defer imports so that the app works gracefully in batch modes
    from .dialog import AppDialog

    # Create and display the splash screen
    splash_pix = QtGui.QPixmap(":/res/splash.png")
    splash = QtGui.QSplashScreen(splash_pix, QtCore.Qt.WindowStaysOnTopHint)
    splash.setMask(splash_pix.mask())
    splash.show()
    QtCore.QCoreApplication.processEvents()

    # create the action manager for the Loader UI:
    from .loader_action_manager import LoaderActionManager

    action_manager = LoaderActionManager()

    # start ui
    ui_title = app.get_setting("title_name")
    w = app.engine.show_dialog(ui_title, app, AppDialog, action_manager)

    # Keep pointer to dialog so as to be able to hide/show it in actions
    engine_name = app.engine.instance_name

    # attach splash screen to the main window to help GC
    w.__splash_screen = splash

    # hide splash screen after loader UI show
    splash.finish(w.window())

    # pop up help screen
    if w.is_first_launch():
        # wait a bit before show window
        QtCore.QTimer.singleShot(1400, w.show_help_popup)
Exemple #4
0
    def __init__(self, display_widget, parent=None):
        """
        Initialize the widget.

        :param display_widget: The ``DISPLAY`` widget instance
        :type display_widget: :class:`~PySide.QtGui.QWidget`
        :param parent: The parent widget or ``None``
        :type parent: :class:`~PySide.QtGui.QWidget`
        """

        super(ShotgunFieldNotEditable, self).__init__(parent)

        self._display_widget = display_widget

        # this is the "no edit" label that will show on hover
        self._no_edit_lbl = QtGui.QLabel(self)
        self._no_edit_lbl.setPixmap(
            QtGui.QPixmap(":/qtwidgets-shotgun-fields/not_editable.png")
        )
        self._no_edit_lbl.setFixedSize(QtCore.QSize(16, 16))
        self._no_edit_lbl.hide()

        spacer = QtGui.QWidget()
        spacer.setFixedHeight(self._no_edit_lbl.height())
        spacer.setFixedWidth(4)

        layout = QtGui.QHBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(0)
        layout.addWidget(display_widget)
        layout.addWidget(spacer)
        layout.addWidget(self._no_edit_lbl)
        layout.addStretch(10)

        self.installEventFilter(self)

        # forward the display widget's value changed signal
        self._display_widget.value_changed.connect(self.value_changed.emit)
    def populateUI(self, widget, exportTemplate):

        # prior to 10.5v1, this method created the layout. in 10.5v1 and later,
        # the widget already has a layout
        if self.app.get_nuke_version_tuple() >= (10, 5, 1):
            layout = widget.layout()
        else:
            # create a layout with custom top and bottom widgets
            layout = QtGui.QVBoxLayout(widget)
            layout.setContentsMargins(0, 0, 0, 0)
            layout.setSpacing(9)

        top = QtGui.QWidget()

        top_layout = QtGui.QVBoxLayout()
        top_layout.setContentsMargins(9, 0, 9, 0)
        create_version_checkbox = QtGui.QCheckBox("Create SG Version", widget)
        create_version_checkbox.setToolTip(
            "Create a Version in SG for this transcode.\n\n"
            "If the output format is not a quicktime, then\n"
            "a quicktime will be created.  The quicktime will\n"
            "be uploaded to SG as Screening Room media."
        )

        create_version_checkbox.setCheckState(QtCore.Qt.Checked)
        if not self._preset._properties.get("create_version", True):
            create_version_checkbox.setCheckState(QtCore.Qt.Unchecked)
        create_version_checkbox.stateChanged.connect(self.create_version_changed)
        top_layout.addWidget(create_version_checkbox)

        top.setLayout(top_layout)

        middle = QtGui.QWidget()

        # prior to 10.5v1, the layout was set in the base class. in 10.5v1, the
        # base class expects the widget to already have a layout.
        if self.app.get_nuke_version_tuple() >= (10, 5, 1):
            middle.setLayout(QtGui.QVBoxLayout())

        # populate the middle with the standard layout
        FnTranscodeExporterUI.TranscodeExporterUI.populateUI(
            self, middle, exportTemplate
        )

        layout.addWidget(top)
        layout.addWidget(middle)

        # Handle any custom widget work the user did via the custom_export_ui
        # hook.
        custom_widget = self._get_custom_widget(
            parent=widget,
            create_method="create_transcode_exporter_widget",
            get_method="get_transcode_exporter_ui_properties",
            set_method="set_transcode_exporter_ui_properties",
        )

        if custom_widget is not None:
            layout.addWidget(custom_widget)
Exemple #6
0
def create_round_thumbnail(image):
    """
    Create a 200 px wide circle thumbnail

    :param image: QImage representing a thumbnail
    :returns: Round QPixmap
    """
    CANVAS_SIZE = 200

    # get the 512 base image
    base_image = QtGui.QPixmap(CANVAS_SIZE, CANVAS_SIZE)
    base_image.fill(QtCore.Qt.transparent)

    # now attempt to load the image
    # pixmap will be a null pixmap if load fails
    thumb = QtGui.QPixmap.fromImage(image)

    if not thumb.isNull():

        # scale it down to fit inside a frame of maximum 512x512
        thumb_scaled = thumb.scaled(
            CANVAS_SIZE,
            CANVAS_SIZE,
            QtCore.Qt.KeepAspectRatioByExpanding,
            QtCore.Qt.SmoothTransformation,
        )

        # now composite the thumbnail on top of the base image
        # bottom align it to make it look nice
        thumb_img = thumb_scaled.toImage()
        brush = QtGui.QBrush(thumb_img)
        painter = QtGui.QPainter(base_image)
        painter.setRenderHint(QtGui.QPainter.Antialiasing)
        painter.setBrush(brush)
        painter.drawEllipse(0, 0, CANVAS_SIZE, CANVAS_SIZE)
        painter.end()

    return base_image
Exemple #7
0
def __create_tank_disabled_menu(details):
    """
    Creates a std "disabled" shotgun menu
    """
    from sgtk.platform.qt import QtGui
    if Configuration.get("KATANA_UI_MODE"):
        sg_menu = MenuGenerator.get_or_create_root_menu("Shotgun")
        if sg_menu is not None:
            sg_menu.clear()
            cmd = lambda d=details: __show_tank_disabled_message(d)
            action = QtGui.QAction("Toolkit is disabled", sg_menu, triggered=cmd)
            sg_menu.addAction(action)
    else:
        print("The Shotgun Pipeline Toolkit is disabled: %s" % details)
Exemple #8
0
    def open_attachments(self):
        """
        Sets the attachments editor into its "open mode" which will
        allow the user to attach files to the note.
        """
        self.ui.attachment_list_tree.clear()

        for file_path in self._attachments:
            self.ui.attachment_list_tree.addTopLevelItem(
                QtGui.QTreeWidgetItem([file_path]))

        self.ui.stacked_widget.setCurrentIndex(self._ATTACHMENTS_WIDGET_INDEX)
        self._adjust_ui()
        self._add_attachments()
    def show_success(self):
        """
        Shows standard "publish completed successfully!" prompt
        """
        self.ui.icon.setPixmap(
            QtGui.QPixmap(":/tk_multi_publish2/publish_complete.png")
        )
        self.ui.label.setText("Publish\nComplete")
        self.ui.info.setText("For more details, <b><u>click here</u></b>.")

        self.ui.publish_again.setText("To publish again, <b><u>click here</u></b>.")
        self.ui.publish_again.show()

        self.show()
    def _clear_model(self, add_loading_item=True):
        """
        Clears the current data in the model.
        
        :param add_loading_item: if true, a "loading please wait" item will
                                 be added.
        """
        # clear model
        self._model.clear()

        if add_loading_item:
            item = QtGui.QStandardItem("Loading data...")
            item.setData(self.MODE_LOADING, self.MODE_ROLE)
            self._model.appendRow(item)
Exemple #11
0
 def _populate_default_thumbnail(self, item):
     """
     Called whenever an item needs to get a default thumbnail attached to a node.
     When thumbnails are loaded, this will be called first, when an object is
     either created from scratch or when it has been loaded from a cache, then later
     on a call to _populate_thumbnail will follow where the subclassing implementation
     can populate the real image.
     """
     # set up publishes with a "thumbnail loading" icon
     item.setData(self._loading_icon,
                  SgPublishHistoryModel.PUBLISH_THUMB_ROLE)
     thumb = utils.create_overlayed_user_publish_thumbnail(
         item.data(SgPublishHistoryModel.PUBLISH_THUMB_ROLE), None)
     item.setIcon(QtGui.QIcon(thumb))
Exemple #12
0
 def __init__(self, parent, bg_task_manager):
     """
     Constructor
     """
     # folder icon
     self._loading_icon = QtGui.QPixmap(":/res/loading_100x100.png")
     app = sgtk.platform.current_bundle()
     ShotgunModel.__init__(
         self,
         parent,
         download_thumbs=app.get_setting("download_thumbnails"),
         schema_generation=2,
         bg_load_thumbs=True,
         bg_task_manager=bg_task_manager)
    def _clear_model(self, add_loading_item=True):
        """
        Clears the current data in the model.

        :param add_loading_item: if true, a "loading please wait" item will
                                 be added.
        """
        # clear model
        self._model.clear()

        if add_loading_item:
            item = QtGui.QStandardItem("Hold on, loading...")
            item.setData(None, self._SG_DATA_ROLE)
            self._model.appendRow(item)
Exemple #14
0
    def __init__(self, parent, settings):
        """
        :param parent: Parent widget.
        :param settings: Settings object to persist and restore state.
        """
        super(CommandPanel, self).__init__(parent)
        # The app style sheet styles this widget so give it the proper name.
        self.setObjectName("command_panel")
        self._layout = QtGui.QVBoxLayout(self)
        self._layout.setContentsMargins(0, 10, 0, 0)
        self._layout.addStretch(1)
        self.setLayout(self._layout)

        # We want the background color to apply to the entire surface of the widget
        # in PySide instead of just under its children
        self.setAttribute(QtCore.Qt.WA_StyledBackground, True)
        self.setMouseTracking(True)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.setSizePolicy(QtGui.QSizePolicy.Maximum, QtGui.QSizePolicy.Preferred)

        filter = ResizeEventFilter(parent)
        filter.resized.connect(self._on_parent_resized)
        parent.installEventFilter(filter)

        self.command_triggered.connect(self._update_recents_list)

        # Settings object allowing to read and write settings.
        self._settings = settings
        # The widget for the recently launched command. Will be None if
        # the recent list is disabled or if there are no recent commands.
        self._recents_widget = None
        # Dictionary of the commands that were executed recently.
        # Follows this structure:
        # self._recents = {
        #     'launch_nuke': {
        #         'timestamp': datetime.datetime(2016, 5, 20, 21, 48, 17, 495234),
        #         'added': False},
        #     ...
        # }
        self._recents = {}
        # Keeps track of all the command information so we can easily build the recent
        # command list.
        self._command_info = {}
        # List of section names that the widget knows about. The sections
        # will be displayed in that order.
        self._section_names = []
        # If True, the recent list will be displayed.
        self._show_recents = False
        # Keeps a reference to scroll view that owns this widget.
        self._scroll_view_owner = parent
Exemple #15
0
    def __init__(self, view):
        self.tray_view = view
        shotgun_view.WidgetDelegate.__init__(self, view)
        self.__selection_model = view.selectionModel()

        self._pen = QtGui.QPen(QtCore.Qt.white, 1, QtCore.Qt.SolidLine)

        self._ORIGINAL_THUMBNAIL = QtCore.Qt.UserRole + 1702
        self._FILTER_THUMBNAIL = QtCore.Qt.UserRole + 1703
        self._PINNED_THUMBNAIL = QtCore.Qt.UserRole + 1704

        # pinned icon
        try:
            f = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                             "review_app_pinned.png")
            self.pin_pixmap = QtGui.QPixmap(f)

            f2 = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                              "ae.jpeg")
            self.missing_pixmap = QtGui.QPixmap(f2)

        except Exception as e:
            print "ERROR: cant load pin %r" % e
    def setup_ui(self, page_id):
        BasePage.setup_ui(self, page_id)

        # Setup buttongroup by hand since in PySide it breaks the ui compilation
        wiz = self.wizard()
        self._config_button_group = QtGui.QButtonGroup(self)
        self._config_button_group.addButton(wiz.ui.select_default_config,
                                            self.DEFAULT_ID)
        self._config_button_group.addButton(wiz.ui.select_multiroot_config,
                                            self.MULTIROOT_ID)
        self._config_button_group.addButton(wiz.ui.select_games_config,
                                            self.GAMES_ID)
        self._config_button_group.addButton(wiz.ui.select_flame_config,
                                            self.FLAME_ID)
Exemple #17
0
 def show_no_items_error(self):
     """
     Shows a special message when there is no items collected under an alternate
     UI operation determined by the 'enable_manual_load' application option.
     """
     self.ui.icon.setPixmap(
         QtGui.QPixmap(":/tk_multi_publish2/publish_failed.png"))
     # Hardcoding line break so the message displays on 2 lines.
     # Usage of label's own word wrap displays the message below on 3 lines.
     # NOTE: Can't manually break line when using <p></p>
     self.ui.label.setText("Could not find any\nitems to publish.")
     self.ui.info.setText("For more details, <b><u>click here</u></b>.")
     self.ui.publish_again.hide()
     self.show()
    def _upload_image(self):
        """
        Display a file browser and process the selected file path.
        """

        file_path = QtGui.QFileDialog.getOpenFileName(
            self,
            caption="Replace Image",
            options=QtGui.QFileDialog.DontResolveSymlinks)[0]
        if file_path:
            self.setPixmap(QtGui.QPixmap(file_path))
            self._image_path = file_path
            self._value = file_path
            self.value_changed.emit()
Exemple #19
0
    def __init__(self):

        # loading a pixmap
        self.loading = create_rectangular_thumbnail(
            QtGui.QPixmap(":/tk_framework_qtwidgets.global_search_widget/loading.png")
        )

        # more typing required
        self.keyboard = create_rectangular_thumbnail(
            QtGui.QPixmap(":/tk_framework_qtwidgets.global_search_widget/keyboard.png")
        )

        # no matches found
        self.no_matches = create_rectangular_thumbnail(
            QtGui.QPixmap(":/tk_framework_qtwidgets.global_search_widget/no_match.png")
        )

        # no thumbnail for the entity
        self.no_thumbnail = create_rectangular_thumbnail(
            QtGui.QPixmap(
                ":/tk_framework_qtwidgets.global_search_widget/no_thumbnail.png"
            )
        )
    def _get_item_thumbnail(item):
        """
        Return the thumbnail data for item.

        :param item: The model item
        :type item: QStandardItem
        """

        thumbnail = item.data(QtCore.Qt.DecorationRole)

        if thumbnail is None:
            thumbnail = QtGui.QPixmap()

        return thumbnail
Exemple #21
0
    def __init__(self, parent=None):
        """
        Initialize the info widget.

        :param parent: The widget's parent.
        """

        super(_PythonInputInfoWidget, self).__init__(parent)

        self._column_lbl = QtGui.QLabel()

        layout = QtGui.QHBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(0)
        layout.addStretch()
        layout.addWidget(self._column_lbl)

        self._text_grey = colorize(
            self.palette().window().color(),
            1,
            self.palette().windowText().color(),
            1,
        ).name()
Exemple #22
0
    def __init__(self, parent=None):
        super(ScribbleArea, self).__init__(parent)

        self.setAttribute(QtCore.Qt.WA_StaticContents)
        self.modified = False
        self.scribbling = False
        self.myPenWidth = 3
        self.myPenColor = QtCore.Qt.red

        imageSize = QtCore.QSize(500, 500)

        self.image = QtGui.QImage(imageSize, QtGui.QImage.Format_RGB32)

        self.lastPoint = QtCore.QPoint()
    def __init__(self, layout, text, editor):
        """
        :param layout: Layout to add the widget into.
        :param text: Text on the left of the editor widget.
        :param editor: Widget used to edit the value.
        """
        super(WidgetHandler, self).__init__(editor)

        self._layout = QtGui.QHBoxLayout()
        self._check_box = QtGui.QCheckBox(text)
        self._label = QtGui.QLabel(text)

        # FIXME: Should take the size of the text + icon as the minimum width.
        self._check_box.setMinimumWidth(50)
        self._label.setMinimumWidth(50)

        self._check_box.stateChanged.connect(self._on_state_changed)

        self._layout.addWidget(self._check_box)
        self._layout.addWidget(self._label)
        self._layout.addWidget(self.editor)

        layout.addRow(self._layout)
    def __init__(self, parent, overlay_widget, publish_type_model):
        """
        Model which represents the latest publishes for an entity
        """
        self._publish_type_model = publish_type_model
        self._no_pubs_found_icon = QtGui.QPixmap(
            ":/res/no_publishes_found.png")
        self._folder_icon = QtGui.QIcon(
            QtGui.QPixmap(":/res/folder_512x400.png"))
        self._loading_icon = QtGui.QIcon(
            QtGui.QPixmap(":/res/loading_512x400.png"))

        self._associated_items = {}

        app = sgtk.platform.current_bundle()

        # init base class
        ShotgunOverlayModel.__init__(
            self,
            parent,
            overlay_widget,
            download_thumbs=app.get_setting("download_thumbnails"),
            schema_generation=5)
    def show_loading(self):
        """
        Shows standard "loading stuff" prompt
        """
        self.ui.icon.setPixmap(
            QtGui.QPixmap(":/tk_multi_publish2/overlay_loading.png")
        )
        self.ui.label.setText("Loading and processing")
        self.ui.info.setText("Hold tight while we analyze your data")

        self.ui.publish_again.hide()
        self.ui.publish_again.setText("")

        self.show()
Exemple #26
0
    def addAction(self, action_definition):
        """
        Adds an action to the context menu.

        Action definitions passed in must take the following form:

            dict(
                callback=callable,
                text=str,
                required_selection="single"
            )

        Where the callback is a callable object that expects to receive
        a list of Version entity dictionaries as returned by the Shotgun
        Python API. The text key contains the string labels of the action
        in the QMenu, and the required_selection is one of "single", "multi",
        or "either". Any action requiring a "single" selection will be enabled
        only if there is a single item selected in the Version list view,
        those requiring "multi" selection require 2 or more selected items,
        and the "either" requirement results in the action being enabled if
        one or more items are selected.

        :param action_definition:   The action defition to add to the menu.
                                    This takes the form of a dictionary of
                                    a structure described in the method docs
                                    above.
        :type action_definition:    dict

        :returns:                   :class:`QtGui.QAction`
        """
        action = QtGui.QAction(action_definition.get("text"), self)
        num_selected = len(self._selected_entities)
        required_selection = action_definition.get("required_selection")

        # Now we can enable or disable the action according to
        # how many items have been reported as being selected.
        if not num_selected:
            action.setEnabled(False)
        elif required_selection == "single":
            action.setEnabled((num_selected == 1))
        elif required_selection == "multi":
            action.setEnabled((num_selected > 1))
        elif required_selection == "either":
            action.setEnabled(True)
        else:
            # This shouldn't ever happen.
            action.setEnabled(False)

        self._actions[action] = action_definition
        return super(SelectionContextMenu, self).addAction(action)
    def show_fail(self):
        """
        Shows standard "publish failed!" prompt
        """
        self.ui.icon.setPixmap(
            QtGui.QPixmap(":/tk_multi_publish2/publish_failed.png")
        )
        self.ui.label.setText("Publish\nFailed!")
        self.ui.info.setText("For more details, <b><u>click here</u></b>.")

        self.ui.publish_again.hide()
        self.ui.publish_again.setText("")

        self.show()
Exemple #28
0
    def setup_ui(self, page_id):
        BasePage.setup_ui(self, page_id)

        # Setup buttongroup by hand since in PySide it breaks the ui compilation
        wiz = self.wizard()
        self._config_type_button_group = QtGui.QButtonGroup(self)
        self._config_type_button_group.addButton(wiz.ui.select_standard,
                                                 self.STANDARD_ID)
        self._config_type_button_group.addButton(wiz.ui.select_project,
                                                 self.PROJECT_ID)
        self._config_type_button_group.addButton(wiz.ui.select_github,
                                                 self.GITHUB_ID)
        self._config_type_button_group.addButton(wiz.ui.select_disk,
                                                 self.DISK_ID)
    def _get_default_detail_actions(self, sg_data):
        """
        Returns a list of default actions for the detail area
        
        :param sg_data: Shotgun data directory
        """
        refresh = QtGui.QAction("Refresh", None)
        refresh.triggered[()].connect(lambda f=sg_data: self._refresh(f))

        view_in_sg = QtGui.QAction("View in Shotgun", None)
        view_in_sg.triggered[()].connect(lambda f=sg_data: self._show_in_sg(f))

        copy_url = QtGui.QAction("Copy Shotgun url to clipboard", None)
        copy_url.triggered[(
        )].connect(lambda f=sg_data: self._copy_to_clipboard(f))

        show_docs = QtGui.QAction("Documentation", None)
        show_docs.triggered[()].connect(self._show_docs)

        separator = QtGui.QAction(None)
        separator.setSeparator(True)

        return [refresh, view_in_sg, copy_url, show_docs, separator]
    def _clear_model(self, add_loading_item=True, add_more_text_item=False):
        """
        Clears the current data in the model.

        :param add_loading_item: if true, a "loading please wait" item will
            be added.
        :param add_more_text_item: if true, a "type at least 3 characers..."
            item will be added.
        """
        # clear model
        self.model().clear()

        if add_loading_item:
            item = QtGui.QStandardItem("Loading search results...")
            item.setData(self.MODE_LOADING, self.MODE_ROLE)
            self.model().appendRow(item)
            item.setIcon(QtGui.QIcon(self._pixmaps.loading))
        if add_more_text_item:
            item = QtGui.QStandardItem("Type at least %s characters..." %
                                       (self.COMPLETE_MINIMUM_CHARACTERS, ))
            item.setData(self.MODE_NOT_ENOUGH_TEXT, self.MODE_ROLE)
            item.setIcon(QtGui.QIcon(self._pixmaps.keyboard))
            self.model().appendRow(item)