Ejemplo n.º 1
0
    def __init__(self, parent=None):
        super(StoreXml, self).__init__(parent)
        # load the ui

        #import __main__
        #self.parentWindow = __main__.__dict__["blurDeformWindow"]
        #blurdev.gui.loadUi( __file__, self )

        QtCompat.loadUi(getUiFile(__file__), self)
        self.parentWindow = parent
        #------------------------

        self.parentWindow.saveXmlWin = self

        self.setWindowFlags(QtCore.Qt.Tool | QtCore.Qt.WindowStaysOnTopHint)
        self.setWindowTitle("Store xml file")
        self.uiAllFramesTW.setSelectionMode(
            QtWidgets.QAbstractItemView.ExtendedSelection)
        self.uiAllFramesTW.setAlternatingRowColors(True)

        self.uiDoStoreBTN.clicked.connect(self.buttonAction)

        self.uiXmlStoreFile = filepickerwidget.FilePickerWidget(self)
        self.botLay.insertWidget(0, self.uiXmlStoreFile)
        self.uiXmlStoreFile.filenameChanged.connect(self.fileIsPicked)
Ejemplo n.º 2
0
    def __init__(self, *args, **kwds):
        super(Launcher, self).__init__(*args, **kwds)

        DIR,file_name = os.path.split(__file__)
        base_name,_ = os.path.splitext(file_name)
        ui_path = os.path.join(DIR,"%s.ui" % base_name)
        QtCompat.loadUi(ui_path,self)

        # NOTE 隐藏 Error_Label
        self.Error_Label.hide()
        
        # NOTE 设置图标
        style = QtWidgets.QApplication.style()
        icon = style.standardIcon(QtWidgets.QStyle.SP_FileDialogContentsView)
        pixmap = icon.pixmap(32,32)
        # pixmap = style.standardPixmap(QtWidgets.QStyle.SP_FileDialogContentsView)
        bitmap = pixmap.createMaskFromColor(QtGui.QColor(50, 50, 50))
        pixmap.setMask(bitmap)
        self.Label.setPixmap(pixmap)
        

        # TODO 设置状态标签

        self.setWindowFlags(QtCore.Qt.Popup|QtCore.Qt.FramelessWindowHint)
        self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
        # self.setFlags(QtCore.Qt.WA_TranslucentBackground)
        
        self.LineEdit.returnPressed.connect(self.accept)
        
        self.show()
Ejemplo n.º 3
0
	def __init__(self, system):
		super(SystemSettingsWidget, self).__init__()
		uiPath = os.path.join(os.path.dirname(__file__), "ui", "systemSettingsWidget.ui")
		QtCompat.loadUi(uiPath, self)

		self._system = None
		self._connectionWidgets = {}
		self._settingsWidgets = {}
		self._settingsWidget = None

		self.uiPreScriptWDG = ScriptWidget("pre")
		self.uiScriptsTAB.layout().addWidget(self.uiPreScriptWDG)
		self.uiPostScriptWDG = ScriptWidget("post")
		self.uiScriptsTAB.layout().addWidget(self.uiPostScriptWDG)

		if system:
			self.setSystem(system)

		# Connect Signals
		self.uiTypeCBOX.currentIndexChanged.connect(self.swap)
		self.uiVersionCBOX.currentIndexChanged.connect(self.swap)
		self.uiLocationCBOX.currentIndexChanged.connect(self.rename)
		self.uiNameLINE.editingFinished.connect(self.rename)
		self.uiAddConnectionBTN.clicked.connect(self.addConnection)
		self.uiConnectionPortCBOX.currentIndexChanged.connect(self.loadConnectionTypes)

		self.uiPreScriptWDG.updated.connect(self.scriptUpdated)
		self.uiPostScriptWDG.updated.connect(self.scriptUpdated)
Ejemplo n.º 4
0
    def __init__(self):
        super(Dialog, self).__init__()
        QtCompat.loadUi(os.path.join(__file__, '../downloader.ui'), self)
        self.file_sets = {}
        self._files = RemoteFiles()
        self.is_downloading = False

        # Recover from config.
        self.dir = CONFIG['OUTPUT_DIR']

        # Setup radio buttons.
        self.radioButtonSubmit.toggled.connect(
            lambda status: self.on_radio_toggled(SUBMIT_FILE, status))
        select = cgtwq.DesktopClient().selection()
        pipeline = select.module.database.pipeline.filter(
            cgtwq.Filter('entity', select['pipeline'][0]))[0]
        for filebox in (
                select.module.database.filebox.list_by_pipeline(pipeline)):
            button = QRadioButton(filebox.title)
            button.setObjectName(filebox.title)
            button.toggled.connect(lambda status, target=filebox: self.
                                   on_radio_toggled(target, status))
            self.groupBox.layout().addWidget(button)

        # Connect signals.
        self.toolButton.clicked.connect(self.ask_dir)
        self.lineEditDir.editingFinished.connect(self.autoset)
        self.checkBoxSkipSame.toggled.connect(self.update_filelist)

        self.update_filelist()
Ejemplo n.º 5
0
 def __init__(self):
     
     super(MyWindow, self).__init__()
     QtCompat.loadUi(ui_path, self)
     self.open_button.clicked.connect(self.open)
     self.export_button.clicked.connect(self.export)
     self.import_button.clicked.connect(self.importation)
Ejemplo n.º 6
0
    def __init__(self, parent=None):
        super(ArgileAddPose, self).__init__(parent)
        # load the ui

        QtCompat.loadUi(getUiFile(__file__), self)
        self.parentWindow = parent

        self.parentWindow.addPoseWin = self

        self.uiTransformLE.setText("N/A")
        self.uiPoseNameLE.setText("newPose")

        self.uiAddPoseBTN.clicked.connect(self.addNewPose)
        self.uiPickTransformBTN.clicked.connect(self.getSelectedTransform)

        self.uiLocalDeformationRB.toggled.connect(
            self.uiTransformLE.setEnabled)
        self.uiLocalDeformationRB.toggled.connect(
            self.uiPickTransformBTN.setEnabled)
        self.uiLocalDeformationRB.toggled.connect(
            self.uiUseTransformLBL.setEnabled)
        self.uiTangentDeformationRB.toggled.connect(
            self.uiWarningLabel.setVisible)

        self.uiWarningLabel.setVisible(False)
        self.uiWarningExistPoseNameLabel.hide()

        self.setWindowFlags(QtCore.Qt.Tool | QtCore.Qt.WindowStaysOnTopHint)
        self.setWindowTitle("Add New Pose")
Ejemplo n.º 7
0
    def __init__(self, guide):
        super(GuideVisibilityWidget, self).__init__()
        uiPath = os.path.join(os.path.dirname(__file__), "ui",
                              "guideVisibilityWidget.ui")
        QtCompat.loadUi(uiPath, self)

        self._visButtons = []
        self.setGuide(guide)
Ejemplo n.º 8
0
 def __init__(self, config=None, parent=None):
     self.config = config or dict()
     super(DialogWithDir, self).__init__(parent)
     QtCompat.loadUi(unicode(Path(__file__, self.uifile)), self)
     self._setup_icons()
     self._load_edits_state()
     self._setup_edits()
     self.dir_edit.textChanged.connect(self._validate_dir)
Ejemplo n.º 9
0
def test_load_ui_baseinstance():
    """Tests to see if the baseinstance loading loads widgets on properly"""
    import sys
    from Qt import QtWidgets, QtCompat
    app = QtWidgets.QApplication(sys.argv)
    win = QtWidgets.QWidget()
    QtCompat.loadUi(self.ui_qwidget, win)
    assert hasattr(win, 'lineEdit'), "loadUi could not load instance to win"
    app.exit()
Ejemplo n.º 10
0
def test_load_ui_baseinstance():
    """Tests to see if the baseinstance loading loads widgets on properly"""
    import sys
    from Qt import QtWidgets, QtCompat
    app = QtWidgets.QApplication(sys.argv)
    win = QtWidgets.QWidget()
    QtCompat.loadUi(self.ui_qwidget, win)
    assert hasattr(win, 'lineEdit'), "loadUi could not load instance to win"
    app.exit()
Ejemplo n.º 11
0
    def __init__(self):
        super(MyWindow, self).__init__()
        #self.engine = MayaEngine()
        path = ""

        # setup ui
        QtCompat.loadUi(ui_path, self)  # replace self.setupUi(Self)
        self.open_button.clicked.connect(self.open)
        self.select_button.clicked.connect(self.browse)
Ejemplo n.º 12
0
	def __init__(self, layer):
		super(LayerSettingsWidget, self).__init__()
		uiPath = os.path.join(os.path.dirname(__file__), "ui", "layerSettingsWidget.ui")
		QtCompat.loadUi(uiPath, self)

		self._layer = None

		self.connectWidgets()

		self.setLayer(layer)
Ejemplo n.º 13
0
    def __init__(self):
        super(MyWindow, self).__init__()
        self.engine = get_current()        

        
        # setup ui
        QtCompat.loadUi(ui_path, self)

        self.Open_Button.clicked.connect(self.select)
        self.exportABC.clicked.connect(self.export)
Ejemplo n.º 14
0
 def __init__(self):
     super(ToRef, self).__init__()
     QtCompat.loadUi(Tools.get_ui_path(), self)
     self.file = None
     self.iter = None
     self.namespaces = None
     self.thread = MyThread()
     self.thread.signal.connect(self.update_process)
     self.toolButton.clicked.connect(self.get_file)
     self.refButton.clicked.connect(self.check_params)
Ejemplo n.º 15
0
 def LoadUI(self, obj):
     path = inspect.getsourcefile(obj.__class__).replace('\\','/')
     relpath = path.split(self['CoreDirectory'],1)[-1].rsplit('.',1)[0]+'.ui'
     uipath = self.GetOverriddenPath(relpath)
     print('path', path)
     print('self[CoreDirectory]', self['CoreDirectory'])
     print('relpath', relpath)
     print('uipath', uipath)
     
     if os.path.exists(uipath):
         QtCompat.loadUi(uipath, baseinstance=obj)
Ejemplo n.º 16
0
    def __init__(self):
        super(OpenWindow, self).__init__()
        QtCompat.loadUi(ui_path, self)

        # Assign the buttons to functions
        self.exportButton.clicked.connect(self.exportAbc)
        self.importButton.clicked.connect(self.importAbc)
        self.searchOpenFileButton.clicked.connect(self.searchOpenFile)
        self.searchExportFolderButton.clicked.connect(self.searchExportFolder)
        self.searchExportFileButton.clicked.connect(self.searchExportFile)
        self.searchOpenFolderButton.clicked.connect(self.searchOpenFolder)
Ejemplo n.º 17
0
def test_load_ui_signals():
    """Tests to see if the baseinstance loading loads widgets on properly"""
    import sys
    from Qt import QtWidgets, QtCompat
    app = QtWidgets.QApplication(sys.argv)
    win = QtWidgets.QWidget()
    QtCompat.loadUi(self.ui_qwidget, win)

    win.lineEdit.setText('Hello')
    assert str(win.label.text()) == 'Hello', "lineEdit signal did not fire"

    app.exit()
Ejemplo n.º 18
0
def test_load_ui_signals():
    """Tests to see if the baseinstance loading loads widgets on properly"""
    import sys
    from Qt import QtWidgets, QtCompat
    app = QtWidgets.QApplication(sys.argv)
    win = QtWidgets.QWidget()
    QtCompat.loadUi(self.ui_qwidget, win)

    win.lineEdit.setText('Hello')
    assert str(win.label.text()) == 'Hello', "lineEdit signal did not fire"

    app.exit()
Ejemplo n.º 19
0
	def __init__(self, parent, guide):
		super(PickSlotDialog, self).__init__(parent)
		uiPath = os.path.join(os.path.dirname(__file__), "ui", "pickSlotDialog.ui")
		QtCompat.loadUi(uiPath, self)

		self._system = None
		self._slots = None

		self.uiGuideTREE = GuideTreeWidget(guide)
		self.uiGuideTREE.setSelectionMode(self.uiGuideTREE.SingleSelection)
		self.uiGuideTREE.itemSelectionChanged.connect(self.loadSlots)

		self.uiTreeWDG.layout().addWidget(self.uiGuideTREE)
Ejemplo n.º 20
0
    def __init__(self, connection, system):
        super(SystemConnectionWidget, self).__init__()

        # Load UI File
        module = __import__(self.__module__, globals(), locals(), ["*"], -1)
        uiPath = os.path.join(os.path.dirname(module.__file__), "widget.ui")
        QtCompat.loadUi(uiPath, self)

        self._connection = connection
        self._system = system
        self._widgets = self.getSettingWidgets()

        self.loadSettings()
Ejemplo n.º 21
0
    def __init__(self, *args, **kwargs):
        super(LauncherBase, self).__init__(*args, **kwargs)

        DIR, file_name = os.path.split(__file__)
        base_name, _ = os.path.splitext(file_name)
        ui_path = os.path.join(DIR, "%s.ui" % base_name)
        QtCompat.loadUi(ui_path, self)

        self.offset = QtCore.QPoint()

        self.Search_List.hide()
        self.Search_Combo.hide()
        self.Search_Label.hide()
        self.Loading_Container.setVisible(lambda: self.state.loading_vis * 1)

        # NOTE 设置图标
        style = QtWidgets.QApplication.style()
        icon = style.standardIcon(QtWidgets.QStyle.SP_FileDialogContentsView)
        self.Settings_BTN.setIcon(icon)
        icon = style.standardIcon(QtWidgets.QStyle.SP_BrowserReload)
        self.loading_pixmap = icon.pixmap(20, 20)
        self.Loading_Icon.setPixmap(self.loading_pixmap)
        self.Loading_Icon.setFixedSize(25, 25)

        self.Settings_BTN.setMenu(self.Settings_Menu)
        self.Settings_BTN.clicked.connect(self.Settings_BTN.showMenu)

        # NOTE loading 按钮旋转动画
        self.loading_animation = QtCore.QVariantAnimation(
            self,
            startValue=0.0,
            endValue=360.0,
            duration=1000,
        )
        self.loading_animation.valueChanged.connect(
            lambda value: self.Loading_Icon.setPixmap(
                self.loading_pixmap.transformed(QtGui.QTransform().rotate(value))
            )
        )
        self.loading_animation.finished.connect(self.loading_animation.start)
        self.loading_animation.start()

        # TODO 设置状态标签

        self.setWindowFlags(QtCore.Qt.Popup | QtCore.Qt.FramelessWindowHint)
        self.setAttribute(QtCore.Qt.WA_TranslucentBackground)

        self.Search_LE.search()
        self.Search_LE.setPlaceholderText("")
        self.Search_LE.returnPressed.connect(self.accept)
        self.adjustSize()
Ejemplo n.º 22
0
def test_load_ui_dockwidget():
    """Tests to see if the baseinstance loading loads a QDockWidget properly"""
    import sys
    from Qt import QtWidgets, QtCompat

    app = QtWidgets.QApplication(sys.argv)
    win = QtWidgets.QDockWidget()

    QtCompat.loadUi(self.ui_qdockwidget, win)

    assert hasattr(win, 'lineEdit'), \
        "loadUi could not load instance to main window"

    app.exit()
Ejemplo n.º 23
0
    def __init__(self, guide):
        super(SystemWidget, self).__init__()

        self._guide = None
        self._widgets = None
        self._builder = None

        # Load UI File
        module = __import__(self.__module__, globals(), locals(), ["*"], -1)
        uiPath = os.path.join(os.path.dirname(module.__file__), "widget.ui")
        QtCompat.loadUi(uiPath, self)

        if guide:
            self.setSystem(guide)
Ejemplo n.º 24
0
def test_load_ui_dockwidget():
    """Tests to see if the baseinstance loading loads a QDockWidget properly"""
    import sys
    from Qt import QtWidgets, QtCompat

    app = QtWidgets.QApplication(sys.argv)
    win = QtWidgets.QDockWidget()

    QtCompat.loadUi(self.ui_qdockwidget, win)

    assert hasattr(win, 'lineEdit'), \
        "loadUi could not load instance to main window"

    app.exit()
Ejemplo n.º 25
0
def test_load_ui_existingLayoutOnWidget():
    """Tests to see if loading a ui onto a layout in a Widget works"""
    import sys
    from Qt import QtWidgets, QtCompat

    msgs = 'QLayout: Attempting to add QLayout "" to QWidget ' \
        '"Form", which already has a layout'

    with ignoreQtMessageHandler([msgs]):
        app = QtWidgets.QApplication(sys.argv)
        win = QtWidgets.QWidget()
        QtWidgets.QComboBox(win)
        QtWidgets.QHBoxLayout(win)
        QtCompat.loadUi(self.ui_qwidget, win)
    app.exit()
Ejemplo n.º 26
0
def test_load_ui_existingLayoutOnWidget():
    """Tests to see if loading a ui onto a layout in a Widget works"""
    import sys
    from Qt import QtWidgets, QtCompat

    msgs = 'QLayout: Attempting to add QLayout "" to QWidget ' \
        '"Form", which already has a layout'

    with ignoreQtMessageHandler([msgs]):
        app = QtWidgets.QApplication(sys.argv)
        win = QtWidgets.QWidget()
        QtWidgets.QComboBox(win)
        QtWidgets.QHBoxLayout(win)
        QtCompat.loadUi(self.ui_qwidget, win)
    app.exit()
Ejemplo n.º 27
0
    def __init__(self, parent, guide, defaultLayer=None):
        super(NewSystemDialog, self).__init__(parent)
        uiPath = os.path.join(os.path.dirname(__file__), "ui",
                              "newSystemDialog.ui")
        QtCompat.loadUi(uiPath, self)

        self._guide = guide
        self._defaultLayer = defaultLayer
        self._layers = []
        self._systemsByCategory = {}
        self.loadLayers()

        self.uiSystemTypeLIST.itemDoubleClicked.connect(self.accept)

        self.uiCategoryCBOX.currentIndexChanged.connect(self.setSystemList)
Ejemplo n.º 28
0
    def add_menu(self):
        path_ui = ("/").join([os.path.dirname(__file__), "ui", TITLE + "_menu.ui"])
        self.wgMenu = QtCompat.loadUi(path_ui)
        self.wgHeader.layMain.addWidget(self.wgMenu, 1, 1)

        menu01_img   = ["btn/btnWrite48", "btn/btnArrowRight48", "btn/btnHoneypot48", "btn/btnLog48", "btn/btnInboxE48", "user/default"]
        menu01_items = [self.wgMenu.btnMenu01_item01, self.wgMenu.btnMenu01_item02, self.wgMenu.btnMenu01_item03,
                        self.wgMenu.btnMenu01_item04, self.wgMenu.btnMenu01_item05, self.wgMenu.btnMenu01_item06]

        self.select_menu = {
            "data"     : self.wgMenu.btnMenu01_item01,
            "path"     : self.wgMenu.btnMenu01_item02,
            "advanced" : self.wgMenu.btnMenu01_item03,
            "log"      : self.wgMenu.btnMenu01_item04,
            "report"   : self.wgMenu.btnMenu01_item05,
            "user"     : self.wgMenu.btnMenu01_item06
        }

        for index, each_item in enumerate(menu01_items):
            each_item.setIcon(QtGui.QPixmap(QtGui.QImage(libData.get_img_path(menu01_img[index]))))
            # each_item.clicked.connect(lambda: self.press_btnMenu("settings"))

        self.wgMenu.btnMenu01_item01.clicked.connect(lambda: self.press_btnMenu("data"))
        self.wgMenu.btnMenu01_item02.clicked.connect(lambda: self.press_btnMenu("path"))
        self.wgMenu.btnMenu01_item03.clicked.connect(lambda: self.press_btnMenu("advanced"))
        self.wgMenu.btnMenu01_item04.clicked.connect(lambda: self.press_btnMenu("log"))
        self.wgMenu.btnMenu01_item05.clicked.connect(lambda: self.press_btnMenu("report"))
        self.wgMenu.btnMenu01_item06.clicked.connect(lambda: self.press_btnMenu("user"))

        menu01_items[0].click()
Ejemplo n.º 29
0
    def __init__(self):
        super().__init__()
        self.workingPath = os.path.dirname(__file__).replace("\\", "/")
        self.ui = QtCompat.loadUi(
            self.workingPath + "/uiFiles/nodeInfoPanel.ui", self)
        self.setWindowTitle("Node Information")

        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
        self.width = 400
        self.height = 600
        self.resize(self.width, self.height)
        self.nodeInfoWidget.setFixedHeight(100)

        self.screenSize = QtWidgets.QDesktopWidget().screenGeometry()
        self.screenWidth = self.screenSize.width()
        self.screenHeight = self.screenSize.height()

        self.attribTextEdits = {
            "vertex": self.ui.vertexAttrText,
            "edge": self.ui.edgeAttrText,
            "face": self.ui.faceAttrText,
            "detail": self.ui.detailAttrText
        }

        self.attribLabels = {
            "vertex": self.ui.label_23,
            "edge": self.ui.label,
            "face": self.ui.label_3,
            "detail": self.ui.label_6
        }

        self.node = None
        self._always_show = False
Ejemplo n.º 30
0
    def add_preview(self, layout):
        path_ui = ("/").join(
            [os.path.dirname(__file__), "ui", TITLE + "_preview.ui"])
        self.wgPreview = QtCompat.loadUi(path_ui)
        layout.addWidget(self.wgPreview, 0, 0)

        self.wgPreview.btnPreviewImg.clicked.connect(self.press_btnPreviewImg)
        self.wgPreview.btnScreenshot.clicked.connect(self.press_btnScreenshot)
        self.wgPreview.btnSnapshotRender.clicked.connect(
            self.press_btnSnapshotRender)
        self.wgPreview.btnSnapshotViewport.clicked.connect(
            self.press_btnSnapshotViewport)

        self.wgPreview.btnPreviewImg.setIcon(
            QtGui.QPixmap(QtGui.QImage(libData.get_img_path("lbl/default"))))
        self.wgPreview.btnScreenshot.setIcon(
            QtGui.QPixmap(QtGui.QImage(
                libData.get_img_path("btn/btnCamera48"))))
        self.wgPreview.btnSnapshotViewport.setIcon(
            QtGui.QPixmap(
                QtGui.QImage(
                    libData.get_img_path(
                        "software/maya/shelf/shelf_renderLow35"))))
        self.wgPreview.btnSnapshotRender.setIcon(
            QtGui.QPixmap(
                QtGui.QImage(
                    libData.get_img_path(
                        "software/maya/shelf/shelf_renderHigh35"))))
Ejemplo n.º 31
0
def loadUiWidget(path, parent=None, source_path=None):
    """ Load a Qt Designer .ui file and return an instance of the user interface
    
    :Parameters:
        path : `str`
            Absolute path to .ui file
        parent : `QtWidgets.QWidget`
            The widget into which UI widgets are loaded
        source_path : `str`
            File loading the UI file, if the UI file is relative and needs to be found in the same directory
    :Returns:
        The widget instance
    :Rtype:
        `QtWidgets.QWidget`
    """
    from Qt import QtCompat

    if not os.path.exists(path) and not os.path.isabs(path):
        # Assume the .ui file lives in this directory.
        if source_path is None:
            path = resource_filename(__name__, path)
        else:
            path = os.path.join(os.path.dirname(os.path.realpath(source_path)),
                                path)
    ui = QtCompat.loadUi(path, parent)
    if parent:
        #ui.setParent(parent)
        for member in dir(ui):
            if not member.startswith(
                    '__') and member is not 'staticMetaObject':
                setattr(parent, member, getattr(ui, member))
    return ui
Ejemplo n.º 32
0
    def __init__(self, new_file=True):
        super(ArSaveAs, self).__init__()

        path_ui = ("/").join([os.path.dirname(__file__), "ui", TITLE + ".ui"])
        self.wgSaveAs = QtCompat.loadUi(path_ui)

        self.all_task = '<all tasks>'

        self.new_file = new_file
        self.save_file = ''
        self.save_dir = Tank().data_project['path']
        self.software = Tank().software.software
        self.inputs = [
            self.wgSaveAs.cbxScene, self.wgSaveAs.cbxSet,
            self.wgSaveAs.cbxAsset, self.wgSaveAs.cbxTask
        ]

        self.wgHeader.btnOption.hide()
        self.wgHeader.cbxAdd.hide()
        self.wgHeader.setWindowIcon(
            QtGui.QIcon(Tank().get_img_path("btn/btn_save")))

        btn_title = TITLE if self.new_file else 'Create New Folder'
        self.wgHeader.setWindowTitle(btn_title)
        btn_title = 'Save As' if self.new_file else 'Create'
        self.wgHeader.btnAccept.setText(btn_title)
        self.wgHeader.layMain.addWidget(self.wgSaveAs, 0, 0)
        self.resize_widget(self.wgSaveAs)

        # self.wgSaveAs : always on top
        self.wgSaveAs.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)

        self.setup()
        self.wgSaveAs.show()
        LOG.info('START : arSaveAs')
Ejemplo n.º 33
0
    def __init__(self, parent=None):
        super(ArSave, self).__init__()

        path_ui = ("/").join([os.path.dirname(__file__), "ui", TITLE + ".ui"])
        self.wgSave = QtCompat.loadUi(path_ui)

        self.save_dir = os.getenv('PROJECT_PATH')
        self.save_file = ''
        self.comment = "Comment"
        self.img_path = libSnapshot.default_tmp_path
        self.software = Tank().software.software

        self.wgSave.btnVersionUp.clicked.connect(self.update_version)
        self.wgSave.btnVersionDown.clicked.connect(
            lambda: self.update_version(add=-1))

        # self.wgSave.btnPreviewImg.clicked.connect(self.press_btnPreviewImg)
        self.wgSave.btnScreenshot.clicked.connect(self.press_btnScreenshot)
        self.wgSave.btnSnapshotViewport.clicked.connect(
            self.press_btnSnapshotViewport)
        self.wgSave.btnSnapshotRender.clicked.connect(
            self.press_btnSnapshotRender)

        self.wgSave.btnPreviewImg.setIcon(
            QtGui.QPixmap(QtGui.QImage(libData.get_img_path("lbl/default"))))
        self.wgSave.btnScreenshot.setIcon(
            QtGui.QPixmap(QtGui.QImage(
                libData.get_img_path("btn/btnCamera48"))))
        self.wgSave.btnSnapshotRender.setIcon(
            QtGui.QPixmap(
                QtGui.QImage(
                    libData.get_img_path(
                        "software/maya/shelf/shelf_renderHigh35"))))
        self.wgSave.btnSnapshotViewport.setIcon(
            QtGui.QPixmap(
                QtGui.QImage(
                    libData.get_img_path(
                        "software/maya/shelf/shelf_viewport35"))))

        self.resize_widget(self.wgSave)

        if not self.set_path():
            self.press_btnOption()
            return

        # self.wgSave : always on top
        # self.wgHeader.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)

        self.wgHeader.setWindowTitle(TITLE)
        self.wgHeader.setWindowIcon(
            QtGui.QIcon(libData.get_img_path("btn/btnSave48")))

        self.wgHeader.btnOption.setText('SaveAs')
        self.wgSave.btnSnapshotRender.hide()
        if self.software == 'nuke': self.wgSave.btnSnapshotRender.hide()

        self.wgHeader.layMain.addWidget(self.wgSave, 0, 0)

        self.wgSave.show()
        LOG.info('START : arSave')
Ejemplo n.º 34
0
 def __init__(self, parent=None):
     super(MyWindow, self).__init__(parent, QtCore.Qt.WindowStaysOnTopHint)
     self.mw = QtCompat.loadUi(file_interface)
     self.setCentralWidget(self.mw)
     self.setWindowTitle("Maya2Cloud")
     #Clear Conditions
     self.mw.listWidget.clear()
     self.mw.header_lbl.setPixmap(QPixmap(header))
     self.mw.bttn_link.setText("Link Google Account")
     #Get Init Conditions
     self.Start()
     #Add Items to List.
     self.mw.combo_file.clear()
     self.mw.combo_file.addItem(".mb")
     self.mw.combo_file.addItem(".ma")
     #Button Assignment
     #Link to Google Drive
     self.mw.bttn_link.clicked.connect(self.linkDrive)
     self.mw.bttn_link.setIcon(QIcon(gicon))
     #Get File List from Drive
     self.mw.bttn_getFiles.clicked.connect(self.getFiles)
     self.mw.bttn_getFiles.setIcon(QIcon(gicon))
     #Clear List
     self.mw.bttn_clear.clicked.connect(self.clearList)
     self.mw.bttn_clear.setIcon(QIcon(hicon))
     #Upload Button
     self.mw.bttn_upload.clicked.connect(self.upload)
     self.mw.bttn_upload.setIcon(QIcon(gicon))
Ejemplo n.º 35
0
    def __init__(self, parent=None):
        if parent is None:
            parent = self.default_parent
        self._cancelled = False

        super(QtProgressBar, self).__init__(parent)
        QtCompat.loadUi(module_path('assets', 'progress.ui'), self)
        if parent:
            geo = self.geometry()
            geo.moveCenter(parent.geometry().center())
            self.setGeometry(geo)

        self.setAttribute(Qt.WA_QuitOnClose, True)
        self.setAttribute(Qt.WA_DeleteOnClose, True)
        self.value_changed.connect(self.on_value_changed)
        self.message_changed.connect(self.on_message_changed)
Ejemplo n.º 36
0
def test_load_ui_customwidget():
    """Tests to see if loadUi loads a custom widget properly"""
    import sys
    from Qt import QtWidgets, QtCompat

    app = QtWidgets.QApplication(sys.argv)
    win = QtWidgets.QMainWindow()

    QtCompat.loadUi(self.ui_qcustomwidget, win)

    # Ensure that the derived class was properly created
    # and not the base class (in case of failure)
    custom_class_name = getattr(win, "customwidget", None).__class__.__name__
    excepted_class_name = CustomWidget(win).__class__.__name__
    assert custom_class_name == excepted_class_name, \
        "loadUi could not load custom widget to main window"

    app.exit()
Ejemplo n.º 37
0
def test_load_ui_returntype():
    """load_ui returns an instance of QObject"""

    import sys
    from Qt import QtWidgets, QtCore, QtCompat
    app = QtWidgets.QApplication(sys.argv)
    obj = QtCompat.loadUi(self.ui_qwidget)
    assert isinstance(obj, QtCore.QObject)
    app.exit()
Ejemplo n.º 38
0
def setup_ui(uifile, base_instance=None):
    """Load a Qt Designer .ui file and returns an instance of the user interface

    Args:
        uifile (str): Absolute path to .ui file
        base_instance (QWidget): The widget into which UI widgets are loaded

    Returns:
        QWidget: the base instance

    """
    ui = QtCompat.loadUi(uifile)  # Qt.py mapped function
    if not base_instance:
        return ui
    else:
        for member in dir(ui):
            if not member.startswith('__') and \
               member is not 'staticMetaObject':
                setattr(base_instance, member, getattr(ui, member))
        return ui