def __init__(self, parent=None):
        super(NoSceneVersionWidget, self).__init__(parent)
        self.setMinimumWidth(700)

        css_loading = """
        background:#222; border-radius: 4px;
        padding:10px; border: 0px;
        """

        css_image = """
        background: url(':ftrack/image/integration/no-asset') no-repeat center center;
        """
        main_layout = QtGui.QHBoxLayout(self)

        frame = QtGui.QFrame(self)
        frame.setMaximumSize(QtCore.QSize(350, 400))
        frame.setStyleSheet(css_loading)
        frame.setFrameShape(QtGui.QFrame.StyledPanel)
        frame.setFrameShadow(QtGui.QFrame.Raised)
        frame_layout = QtGui.QVBoxLayout(frame)

        movie_screen = QtGui.QFrame(frame)
        movie_screen.setMinimumSize(QtCore.QSize(300, 300))
        movie_screen.setStyleSheet(css_image)

        warning = QtGui.QLabel(frame)
        warning.setText("No scene asset found for the selected task")
        warning.setWordWrap(True)
        warning.setAlignment(QtCore.Qt.AlignCenter)

        frame_layout.addWidget(movie_screen)
        frame_layout.addWidget(warning)

        main_layout.addWidget(frame)
Beispiel #2
0
    def __init__(self, parent=None):
        super(SnapshotsWidget).__init__(parent=parent)

        self._view_size = QtCore.QSize(600, 400)
        self._widget_size = QtCore.QSize(self._view_size.width() + 4,
                                         self._view_size.height())

        self.setupUI()

        self._source = self._viewer_btn
        self.initiate_snapshots()
Beispiel #3
0
    def sizeHint(self, option, index):
        is_btn = index.data(QtCore.Qt.UserRole)

        if is_btn:
            height = self._padding_item["top"] + self._padding_item["bottom"]
            height += self._space_before_btn + self._fm_desc.height()
            return QtCore.QSize(self._width, height)

        # Otherwise we draw the asset
        version_nb = index.data(TreeItem.version_nb_role)
        comment = index.data(TreeItem.comment_role)
        available = index.data(TreeItem.is_available_role)

        padding_left = option.rect.left(
        ) + self._padding_item["left"] + self._padding_content["left"]
        padding_left += self._type_indicator_width
        if self._show_thumbnail:
            thumnbail_size = self._thumnbail_size
            if not self._is_top_asset_version(index):
                thumnbail_size = self._thumnbail_child_size

            padding_left += thumnbail_size.width() + 10

        base_height = self._padding_item["top"] + self._padding_content["top"]
        height = base_height + (self._fm_desc.height() * 2)
        height += (self._inter_text * 3)
        if not available:
            height += self._fm_desc.height() + self._inter_text

        if comment != None:
            r_comment, r_comment_text = self._bounding_boxes(
                comment, self._width, padding_left, 0)
            height += r_comment.height()

        else:
            height += self._fm_desc.height()

        if self._is_top_asset_version(index):
            height += self._fm_name.height() + self._inter_text

        if self._need_button(index, version_nb):
            height += self._space_before_btn + self._fm_desc.height()

        if self._show_thumbnail:
            if height < base_height + thumnbail_size.height():
                height = base_height + thumnbail_size.height()

        height += self._padding_content["bottom"] + \
            self._padding_item["bottom"]

        return QtCore.QSize(self._width, height)
Beispiel #4
0
    def activate_button(self, button, icon_name=None, bool_value=False, hover_emphasize=False):
        if bool_value:
            if icon_name != None:
                btn_css = "background: url(%s) rgba(230,120,120,150); " % self._icones[
                    icon_name]
            else:
                btn_css = "background: rgba(230,120,120,150); "
            btn_css += "border-radius: 5px; border: none;"
            global_css = "QToolButton{%s}" % (btn_css)
            button.setStyleSheet(global_css)

        else:
            if hover_emphasize:
                hover_background = "rgba(230,120,120,150)"
            else:
                hover_background = "rgba(255,255,255,80)"
            if icon_name != None:
                btn_css = "background: url(%s) rgba(255,255,255,50); " % self._icones[
                    icon_name]
                btn_css += "border-radius: 5px; border: none;"
                btn_hover_css = "background: url(%s) %s;" % (
                    self._icones[icon_name], hover_background)
            else:
                btn_css = "background: rgba(255,255,255,50); "
                btn_css += "border-radius: 5px; border: none;"
                btn_hover_css = "background: %s;" % hover_background
            global_css = "QToolButton{%s} QToolButton:hover{%s}" % (
                btn_css, btn_hover_css)
            button.setStyleSheet(global_css)

        button.setIconSize(QtCore.QSize(18, 18))
    def __init__(self, parent=None, image=None):
        super(ThumbnailWidget, self).__init__(parent)
        css_thumbnail = """
        background: #000; border-radius: 2px;
        border: 1px solid #AAA;
        """
        self.size = QtCore.QSize(354, 236)
        self.setMinimumSize(self.size)
        self.setMaximumSize(self.size)

        self.setStyleSheet(css_thumbnail)
        self.setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignTop)
        self.update_image(image)
Beispiel #6
0
    def _activate_color_button(self, color, bool_value):
        colors_button = dict(white=self._color_white,
                             black=self._color_black,
                             red=self._color_red,
                             green=self._color_green,
                             blue=self._color_blue,
                             yellow=self._color_yellow)

        btn_css = "background: %s; " % color
        if bool_value:
            btn_css += "border-radius: 5px; border: 3px solid rgb(200,200,200);"
            global_css = "QToolButton{%s}" % (btn_css)
            colors_button[color].setStyleSheet(global_css)
        else:
            btn_css += "border-radius: 5px; border: 3px solid rgb(100,100,100);"
            global_css = "QToolButton{%s}" % (btn_css)
            colors_button[color].setStyleSheet(global_css)
        colors_button[color].setIconSize(QtCore.QSize(18, 18))
    def _build(self):
        '''Build and layout widget.'''
        layout = QtWidgets.QHBoxLayout()
        self.setLayout(layout)

        icon = QtWidgets.QPixmap(':icon-ftrack-box')
        smallIcon = icon.scaled(QtCore.QSize(24,
                                             24), QtCore.Qt.KeepAspectRatio,
                                QtCore.Qt.SmoothTransformation)

        iconLabel = QtWidgets.QLabel()
        iconLabel.setPixmap(smallIcon)
        layout.addWidget(iconLabel)

        self._label = QtWidgets.QLabel(self._noSelectionMessage)
        self._label.setEnabled(False)
        layout.addWidget(self._label)

        layout.addStretch()

        self._browseButton = QtWidgets.QPushButton('Browse...')
        layout.addWidget(self._browseButton)
Beispiel #8
0
 def sizeHint(self):
   return QtCore.QSize(400, 450)
Beispiel #9
0
 def sizeHint(self, option, index):
     tree_widget = self.parent()
     font = self._font_has_children
     font.setPixelSize(tree_widget.font_size)
     fm = QtGui.QFontMetrics(font)
     return QtCore.QSize(200, fm.height() + 5)
 def sizeHint(self):
     return QtCore.QSize(850, 650)
 def sizeHint(self):
     return QtCore.QSize(600, 400)
Beispiel #12
0
 def sizeHint(self):
   return QtCore.QSize(800, 550)
Beispiel #13
0
    def __init__(self, parent, minimum_width=200, show_thumbnail=True):
        super(TreeDelegateStyle, self).__init__(parent)

        self._view = parent
        self._minimum_width = minimum_width
        self._show_thumbnail = show_thumbnail

        self._thumnbail_default = QtGui.QImage()
        default_thumb = os.environ["FTRACK_SERVER"] + "/img/thumbnail2.png"
        self._thumnbail_default.loadFromData(
            urllib.urlopen(default_thumb).read())

        # Fonts...
        self._font_name = QtGui.QFont()
        self._font_name.setPixelSize(12)
        self._font_name.setWeight(QtGui.QFont.Bold)
        self._fm_name = QtGui.QFontMetrics(self._font_name)

        self._font_desc = QtGui.QFont()
        self._font_desc.setPixelSize(11)
        self._font_desc.setWeight(QtGui.QFont.Normal)
        self._fm_desc = QtGui.QFontMetrics(self._font_desc)

        # Sizes...
        self._thumnbail_size = QtCore.QSize(150, 100)
        self._thumnbail_child_size = QtCore.QSize(96, 64)

        self._type_indicator_width = 12

        # Colors...
        self._background = QtGui.QColor(68, 68, 68)
        self._background_regenerated = QtGui.QColor(20, 20, 20)

        self._background_comment = QtGui.QColor(58, 58, 58)

        self._name_color = QtGui.QColor(195, 207, 164)
        self._desc_color = QtGui.QColor(240, 240, 240)
        self._owner_color = QtGui.QColor(200, 200, 200)
        self._comment_color = QtGui.QColor(240, 240, 240)

        self._btn_color = QtGui.QColor(255, 255, 255, 80)
        self._btn_color_hover = QtGui.QColor(255, 255, 255, 200)
        self._btn_color_pressed = QtGui.QColor(255, 255, 255, 255)

        # Flags...
        self._comment_flags = QtCore.Qt.TextWordWrap | QtCore.Qt.AlignLeft | QtCore.Qt.AlignTop

        # Paddings...
        self._padding_item = dict(left=3, top=3, right=3, bottom=0)
        self._padding_content = dict(left=5, top=5, right=5, bottom=10)
        self._padding_comment = 5
        self._inter_text = 5
        self._inter_item = 3
        self._space_before_btn = 8

        # method...
        self._width = self._minimum_width

        # Keep the QRect of the "show previous versions" button if necessary
        self._button_rect = None

        # Keep the QRect of the "date" to show the real date in hover mode
        self._date_rect = None

        # Hover state
        self._hover_state = dict(no_hover=0,
                                 btn_hover=1,
                                 btn_pressed=2,
                                 date_hover=3)

        # Keep in memory the index under the mouse
        self._current_index = None
Beispiel #14
0
    def setupUI(self, parent):
        self._refresh = QtWidgets.QToolButton(parent)
        self._refresh.setMaximumSize(QtCore.QSize(45, 15))
        button_css_refresh = """
          QToolButton{background:transparent; border:none; color: rgba(255,255,255,80);}
          QToolButton:hover{color: rgba(255,255,255,200);}
          QToolButton:pressed{color: rgba(255,255,255,255);}
        """
        self._refresh.setStyleSheet(button_css_refresh)
        self._refresh.move(parent.width() - self._refresh.width() - 10, 5)
        self._refresh.setText("refresh")
        self._refresh.clicked.connect(self.refresh)

        button_css = """
          QToolButton{ background:rgba(255,255,255,50); border:none;
                       color: rgba(255,255,255,80); border-radius: 5px; }
          QToolButton:hover{ background:rgba(255,255,255,120);
                             color: rgba(255,255,255,200); }
          QToolButton:pressed{ background:rgba(255,255,255,80);
                               color: rgba(255,255,255,255); }
        """

        # Colors buttons

        left_gap = 10
        top_padding = 80
        self._color_white = QtWidgets.QToolButton(parent)
        self._color_white.setMaximumSize(QtCore.QSize(20, 20))
        self._color_white.move(left_gap, parent.height() - top_padding)
        self._color_white.clicked.connect(self._toggle_color)
        left_gap += self._color_white.width() + 10

        self._color_black = QtWidgets.QToolButton(parent)
        self._color_black.setMaximumSize(QtCore.QSize(20, 20))
        self._color_black.move(left_gap, parent.height() - top_padding)
        self._color_black.clicked.connect(self._toggle_color)
        left_gap += self._color_black.width() + 10

        self._color_red = QtWidgets.QToolButton(parent)
        self._color_red.setMaximumSize(QtCore.QSize(20, 20))
        self._color_red.move(left_gap, parent.height() - top_padding)
        self._color_red.clicked.connect(self._toggle_color)
        left_gap += self._color_red.width() + 10

        self._color_green = QtWidgets.QToolButton(parent)
        self._color_green.setMaximumSize(QtCore.QSize(20, 20))
        self._color_green.move(left_gap, parent.height() - top_padding)
        self._color_green.clicked.connect(self._toggle_color)
        left_gap += self._color_green.width() + 10

        self._color_blue = QtWidgets.QToolButton(parent)
        self._color_blue.setMaximumSize(QtCore.QSize(20, 20))
        self._color_blue.move(left_gap, parent.height() - top_padding)
        self._color_blue.clicked.connect(self._toggle_color)
        left_gap += self._color_blue.width() + 10

        self._color_yellow = QtWidgets.QToolButton(parent)
        self._color_yellow.setMaximumSize(QtCore.QSize(20, 20))
        self._color_yellow.move(left_gap, parent.height() - top_padding)
        self._color_yellow.clicked.connect(self._toggle_color)

        self._activate_color_button("white", False)
        self._activate_color_button("black", False)
        self._activate_color_button("red", True)  # default
        self._activate_color_button("green", False)
        self._activate_color_button("blue", False)
        self._activate_color_button("yellow", False)

        # Edit buttons

        left_gap = 10
        self._fit_screen = QtWidgets.QToolButton(parent)
        self._fit_screen.setMaximumSize(QtCore.QSize(20, 20))
        self._fit_screen.setStyleSheet(button_css)
        self._fit_screen.move(left_gap, 5)
        self._fit_screen.setToolButtonStyle(QtCore.Qt.ToolButtonIconOnly)
        self._fit_screen.clicked.connect(self.fit_screen)
        self.activate_button(self._fit_screen, "fitscreen")
        left_gap += self._fit_screen.width() + 10

        self._zoom_out = QtWidgets.QToolButton(parent)
        self._zoom_out.setMaximumSize(QtCore.QSize(20, 20))
        self._zoom_out.setStyleSheet(button_css)
        self._zoom_out.move(left_gap, 5)
        self._zoom_out.setText("-")
        self._zoom_out.clicked.connect(self.zoom_out)
        left_gap += self._zoom_out.width() + 10

        self._zoom_in = QtWidgets.QToolButton(parent)
        self._zoom_in.setMaximumSize(QtCore.QSize(20, 20))
        self._zoom_in.setStyleSheet(button_css)
        self._zoom_in.move(left_gap, 5)
        self._zoom_in.setText("+")
        self._zoom_in.clicked.connect(self.zoom_in)
        left_gap += self._zoom_in.width() + 10

        self._drag = QtWidgets.QToolButton(parent)
        self._drag.setMaximumSize(QtCore.QSize(20, 20))
        self._drag.move(left_gap, 5)
        self._drag.setToolButtonStyle(QtCore.Qt.ToolButtonIconOnly)
        self._drag.clicked.connect(self._toggle_handscroll_mode)
        self.set_handscroll_mode(self._handscroll_mode)
        left_gap += self._drag.width() + 10

        self._pencil = QtWidgets.QToolButton(parent)
        self._pencil.setMaximumSize(QtCore.QSize(20, 20))
        self._pencil.move(left_gap, 5)
        self._pencil.setToolButtonStyle(QtCore.Qt.ToolButtonIconOnly)
        self._pencil.clicked.connect(self._toggle_drawing_mode)
        self.set_drawing_mode(self._drawing_mode)
        left_gap += self._pencil.width() + 10

        self._eraser = QtWidgets.QToolButton(parent)
        self._eraser.setMaximumSize(QtCore.QSize(20, 20))
        self._eraser.move(left_gap, 5)
        self._eraser.setToolButtonStyle(QtCore.Qt.ToolButtonIconOnly)
        self._eraser.clicked.connect(self._toggle_eraser)
        self.activate_button(self._eraser, "eraser", hover_emphasize=True)