def __init__(self, parent=None):
     super(XCollapsibleLoggerWidget, self).__init__(parent)
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._collapsed = False
     self._animated = True
     self._expandedHeight = 250
     
     # animation properties
     self._startHeight = 0
     self._targetHeight = 0
     self._targetPercent = 0
     
     self.uiFeedbackLBL.setFont(self.uiLoggerWGT.font())
     
     # set default properties
     self.setCollapsed(True)
     
     # create connections
     self.uiShowBTN.clicked.connect(self.expand)
     self.uiHideBTN.clicked.connect(self.collapse)
     self.uiLoggerWGT.messageLogged.connect(self.updateFeedback)
Пример #2
0
    def __init__(self, parent=None):
        super(XQueryBuilderWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        self.setMinimumWidth(470)

        # define custom properties
        self._rules = {}
        self._defaultQuery = []
        self._completionTerms = []
        self._minimumCount = 1

        # set default properties
        self._container = QWidget(self)
        layout = QVBoxLayout()
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(2)
        layout.addStretch(1)
        self._container.setLayout(layout)
        self.uiQueryAREA.setWidget(self._container)

        # create connections
        self.uiResetBTN.clicked.connect(self.emitResetRequested)
        self.uiSaveBTN.clicked.connect(self.emitSaveRequested)
        self.uiCancelBTN.clicked.connect(self.emitCancelRequested)

        self.resetRequested.connect(self.reset)
    def __init__(self, parent, tableType):
        super(XOrbQueryEntryWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._queryWidget = parent.queryWidget()
        self._containerWidget = parent
        self._tableType = tableType
        self._query = None
        self._first = False
        self._last = False
        self._checked = False

        self.uiEditorAREA.setAutoFillBackground(False)
        self.setAttribute(Qt.WA_DeleteOnClose)

        # set default properties
        self.uiColumnDDL.setTableType(tableType)

        # create connections (use old-style syntax or PySide errors out)
        self.connect(self.uiSelectBTN, SIGNAL('clicked()'), self.toggleChecked)
        self.connect(self.uiJoinSBTN, SIGNAL('clicked()'), self.addEntry)
        self.connect(self.uiRemoveBTN, SIGNAL('clicked()'), self.removeEntry)
        self.connect(self.uiEnterBTN, SIGNAL('clicked()'), self.enterCompound)
        self.connect(self.uiOperatorDDL, SIGNAL('currentIndexChanged(int)'),
                     self.assignEditor)

        self.uiColumnDDL.schemaColumnChanged.connect(self.assignPlugin)
 def __init__( self, parent = None ):
     super(XQueryBuilderWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     self.setMinimumWidth(470)
     
     # define custom properties
     self._rules           = {}
     self._defaultQuery    = []
     self._completionTerms = []
     self._minimumCount    = 1
     
     # set default properties
     self._container = QWidget(self)
     layout = QVBoxLayout()
     layout.setContentsMargins(0, 0, 0, 0)
     layout.setSpacing(2)
     layout.addStretch(1)
     self._container.setLayout(layout)
     self.uiQueryAREA.setWidget(self._container)
     
     # create connections
     self.uiResetBTN.clicked.connect(  self.emitResetRequested )
     self.uiSaveBTN.clicked.connect(   self.emitSaveRequested )
     self.uiCancelBTN.clicked.connect( self.emitCancelRequested )
     
     self.resetRequested.connect(      self.reset )
Пример #5
0
 def __init__(self, loggerWidget):
     super(XLoggerControls, self).__init__(loggerWidget)
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     self._url = 'https://docs.python.org/2/library/logging.html#logrecord-attributes'
     self._loggerWidget = loggerWidget
     self.uiLoggerTREE.setLoggerWidget(loggerWidget)
     self.uiFormatTXT.setText(loggerWidget.formatText())
     
     # load the levels
     if 'designer' not in sys.executable:
         tree = self.uiLevelTREE
         from projexui.widgets.xloggerwidget import XLoggerWidget
         items = sorted(XLoggerWidget.LoggingMap.items())
         for i, (level, data) in enumerate(items):
             item = XTreeWidgetItem(tree, [projex.text.pretty(data[0])])
             item.setFixedHeight(22)
             item.setData(0, QtCore.Qt.UserRole, wrapVariant(level))
             item.setCheckState(0, QtCore.Qt.Unchecked)
     
     # create connections
     self.uiFormatTXT.textChanged.connect(loggerWidget.setFormatText)
     self.uiLevelTREE.itemChanged.connect(self.updateLevels)
     self.uiHelpBTN.clicked.connect(self.showHelp)
Пример #6
0
    def __init__(self,
                 parent=None,
                 _sequence='',
                 _sequenceTreeItem='',
                 _project=''):

        super(SeqDescription, self).__init__(parent)

        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
            projexui.loadUi(sys._MEIPASS,
                            self,
                            uifile=(sys._MEIPASS + "/ui/seqDescription.ui"))
        else:
            projexui.loadUi(__file__, self)

        self._sequence = _sequence
        self._sequenceTreeItem = _sequenceTreeItem
        self._project = _project

        self.sequenceDescription = textEditAutosave.TextEditAutoSave(
            source=self._sequence, sourceAttr="_description")
        self.seqDescriptionLayout.addWidget(self.sequenceDescription)
        self.sequenceDescription.save.connect(self.SaveSequenceDescription)

        self.setDescription()

        self.descriptionBox.setTitle("Sequence " +
                                     str(self._sequence._number) +
                                     " Description")

        self.addShot.clicked.connect(self.AddShot)
        self._sequence.sequenceChanged.connect(self.setDescription)
Пример #7
0
 def __init__( self, parent = None ):
     super(XOrbRecordSetEdit, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._table    = None
     
     # setup delegates
     self.uiQueryTREE.setItemDelegateForColumn(1, ColumnDelegate(self))
     self.uiQueryTREE.setItemDelegateForColumn(2, OperatorDelegate(self))
     
     # set default properties
     palette = self.palette()
     palette.setColor(palette.Base, palette.color(palette.AlternateBase))
     self.uiQueryTREE.setPalette(palette)
     self.uiQueryTREE.setGridPen(palette.color(palette.AlternateBase))
     self.uiQueryTREE.setArrowStyle(True)
     self.uiQueryTXT.setHint('enter quick query...')
     self.uiQueryBTN.setChecked(False)
     self.setTable(None)
     
     # create connections
     self.uiQueryTXT.returnPressed.connect(self.applyQuery)
     self.uiQueryTREE.itemExpanded.connect(self.updateQueryItem)
     self.uiQueryTREE.itemCollapsed.connect(self.updateQueryItem)
Пример #8
0
    def __init__(self, parent=None):
        super(XOrbGridEdit, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._queryWidget = XOrbQueryWidget(self)

        self.uiSearchTXT.setIconSize(QSize(28, 28))
        self.uiSearchTXT.addButton(self.uiQueryBTN)

        self.uiQueryBTN.setCentralWidget(self._queryWidget)
        self.uiQueryBTN.setDefaultAnchor(XPopupWidget.Anchor.TopRight)
        popup = self.uiQueryBTN.popupWidget()
        popup.setShowTitleBar(False)

        # set default properties
        self.uiRecordTREE.setGroupingEnabled(False)
        self.uiRecordTREE.setEditable(True)
        self.uiRecordTREE.setPageSize(50)
        self.uiRecordTREE.setTabKeyNavigation(True)

        # create connections
        self.uiRefreshBTN.clicked.connect(self.refresh)
        self.uiSaveBTN.clicked.connect(self.commit)
        self.uiQueryBTN.popupAboutToShow.connect(self.loadQuery)
        self.uiQueryBTN.popupAccepted.connect(self.assignQuery)
        self.uiRecordTREE.headerMenuAboutToShow.connect(self.updateMenu)

        popup.resetRequested.connect(self._queryWidget.reset)
Пример #9
0
    def __init__(self, parent=None):
        super(XdkWindow, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._currentContentsIndex = -1
        self._worker = XdkWorker()
        self._workerThread = QThread()
        self._worker.moveToThread(self._workerThread)
        self._workerThread.start()

        # set default properties
        self.setAcceptDrops(True)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self.uiFindNextBTN.setDefaultAction(self.uiFindNextACT)
        self.uiFindPrevBTN.setDefaultAction(self.uiFindPrevACT)
        self.uiFindWIDGET.setVisible(False)
        self.uiSearchWEB.page().setLinkDelegationPolicy(
            QWebPage.DelegateAllLinks)

        self.refreshUi()

        # connect widgets
        self.uiContentsTAB.currentChanged.connect(self.refreshUi)
        self.uiContentsTAB.tabCloseRequested.connect(self.closeContentsWidget)
        self.uiContentsTREE.itemExpanded.connect(self.loadItem)
        self.uiContentsTREE.itemSelectionChanged.connect(self.refreshContents)
        self.uiSearchTXT.returnPressed.connect(self.search)
        self.uiSearchWEB.linkClicked.connect(self.gotoUrl)
        self.uiIndexTREE.itemSelectionChanged.connect(self.refreshFromIndex)

        # connect find actions
        self.uiBackACT.triggered.connect(self.goBack)
        self.uiForwardACT.triggered.connect(self.goForward)
        self.uiHomeACT.triggered.connect(self.goHome)
        self.uiFindTXT.textChanged.connect(self.findNext)
        self.uiFindTXT.returnPressed.connect(self.findNext)
        self.uiFindNextACT.triggered.connect(self.findNext)
        self.uiFindPrevACT.triggered.connect(self.findPrev)
        self.uiFindACT.triggered.connect(self.showFind)
        self.uiFindCloseBTN.clicked.connect(self.uiFindWIDGET.hide)
        self.uiCopyTextACT.triggered.connect(self.copyText)

        # connect zoom actions
        self.uiZoomResetACT.triggered.connect(self.zoomReset)
        self.uiZoomInACT.triggered.connect(self.zoomIn)
        self.uiZoomOutACT.triggered.connect(self.zoomOut)

        # connect file actions
        self.uiLoadACT.triggered.connect(self.loadFilename)
        self.uiNewTabACT.triggered.connect(self.addContentsWidget)
        self.uiCloseTabACT.triggered.connect(self.closeContentsWidget)
        self.uiQuitACT.triggered.connect(self.close)

        # connect the signals
        self.loadFileRequested.connect(self._worker.loadFile)
        self._worker.loadingFinished.connect(self._addXdkItem)
        QApplication.instance().aboutToQuit.connect(self._cleanupWorker)
Пример #10
0
 def __init__( self, parent = None ):
     super(XdkWindow, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._currentContentsIndex = -1
     self._worker = XdkWorker()
     self._workerThread = QThread()
     self._worker.moveToThread(self._workerThread)
     self._workerThread.start()
     
     # set default properties
     self.setAcceptDrops(True)
     self.setAttribute( Qt.WA_DeleteOnClose )
     self.uiFindNextBTN.setDefaultAction(self.uiFindNextACT)
     self.uiFindPrevBTN.setDefaultAction(self.uiFindPrevACT)
     self.uiFindWIDGET.setVisible(False)
     self.uiSearchWEB.page().setLinkDelegationPolicy(
                                         QWebPage.DelegateAllLinks)
     
     self.refreshUi()
     
     # connect widgets
     self.uiContentsTAB.currentChanged.connect(self.refreshUi)
     self.uiContentsTAB.tabCloseRequested.connect(self.closeContentsWidget)
     self.uiContentsTREE.itemExpanded.connect(self.loadItem)
     self.uiContentsTREE.itemSelectionChanged.connect(self.refreshContents)
     self.uiSearchTXT.returnPressed.connect(self.search)
     self.uiSearchWEB.linkClicked.connect(self.gotoUrl)
     self.uiIndexTREE.itemSelectionChanged.connect(self.refreshFromIndex)
     
     # connect find actions
     self.uiBackACT.triggered.connect(self.goBack)
     self.uiForwardACT.triggered.connect(self.goForward)
     self.uiHomeACT.triggered.connect(self.goHome )
     self.uiFindTXT.textChanged.connect( self.findNext )
     self.uiFindTXT.returnPressed.connect( self.findNext )
     self.uiFindNextACT.triggered.connect( self.findNext )
     self.uiFindPrevACT.triggered.connect( self.findPrev )
     self.uiFindACT.triggered.connect(self.showFind)
     self.uiFindCloseBTN.clicked.connect(self.uiFindWIDGET.hide)
     self.uiCopyTextACT.triggered.connect( self.copyText )
     
     # connect zoom actions
     self.uiZoomResetACT.triggered.connect( self.zoomReset )
     self.uiZoomInACT.triggered.connect( self.zoomIn )
     self.uiZoomOutACT.triggered.connect( self.zoomOut )
     
     # connect file actions
     self.uiLoadACT.triggered.connect( self.loadFilename )
     self.uiNewTabACT.triggered.connect( self.addContentsWidget )
     self.uiCloseTabACT.triggered.connect( self.closeContentsWidget )
     self.uiQuitACT.triggered.connect( self.close )
     
     # connect the signals
     self.loadFileRequested.connect(self._worker.loadFile)
     self._worker.loadingFinished.connect(self.__addXdkItem)
     QApplication.instance().aboutToQuit.connect(self.__cleanupWorker)
Пример #11
0
    def __init__( self, parent = None ):
        
        super(CreateProjectWidget, self).__init__( parent )
        
        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
	    #print (sys._MEIPASS+"/ui/createprojectwidget.ui");
	    projexui.loadUi(sys._MEIPASS, self, uifile = (sys._MEIPASS+"/ui/createprojectwidget.ui"))
	    
	else:
	    projexui.loadUi(__file__, self)
        #projexui.loadUi(__file__, self)
        
        # define custom properties
	
	self.dockWidget = QDockWidget()
        parent.addDockWidget(QtCore.Qt.LeftDockWidgetArea,self.dockWidget)
        self.dockWidget.setFloating(1)
        self.dockWidget.setWindowTitle("Create Project")
        self.dockWidget.setWidget(self)
	
	#self.setWindowFlags(QtCore.Qt.Tool)
        
        self._backend               = None
        
	#self.myClientNameLineEdit = clientIPLineEdit.ClientIPLineEdit(self)
	#self.clientIPBoxLayout.addWidget(self.myClientNameLineEdit)
	
        #connects buttons
        self.createButton.clicked.connect(self.CreateProject)
        self.cancelButton.clicked.connect(self.cancel)
        self.UpdateClientList()
	self.clientComboBox.currentIndexChanged.connect(self.UpdateIPList)
	
	self.UpdateIPList(self.clientComboBox.currentIndex())        
    def __init__(self, parent=None):
        super(XCollapsibleLoggerWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._collapsed = False
        self._animated = True
        self._expandedHeight = 250

        # animation properties
        self._startHeight = 0
        self._targetHeight = 0
        self._targetPercent = 0

        self.uiFeedbackLBL.setFont(self.uiLoggerWGT.font())

        # set default properties
        self.setCollapsed(True)

        # create connections
        self.uiShowBTN.clicked.connect(self.expand)
        self.uiHideBTN.clicked.connect(self.collapse)
        self.uiLoggerWGT.messageLogged.connect(self.updateFeedback)
Пример #13
0
    def __init__( self, parent = None ):
        super(XOrbGridEdit, self).__init__( parent )
        
        # load the user interface
        projexui.loadUi(__file__, self)
        
        # define custom properties
        self._queryWidget = XOrbQueryWidget(self)
        
        self.uiSearchTXT.setIconSize(QSize(28, 28))
        self.uiSearchTXT.addButton(self.uiQueryBTN)
        
        self.uiQueryBTN.setCentralWidget(self._queryWidget)
        self.uiQueryBTN.setDefaultAnchor(XPopupWidget.Anchor.TopRight)
        popup = self.uiQueryBTN.popupWidget()
        popup.setShowTitleBar(False)

        # set default properties
        self.uiRecordTREE.setGroupingEnabled(False)
        self.uiRecordTREE.setEditable(True)
        self.uiRecordTREE.setPageSize(50)
        self.uiRecordTREE.setTabKeyNavigation(True)
        
        # create connections
        self.uiRefreshBTN.clicked.connect(self.refresh)
        self.uiSaveBTN.clicked.connect(self.commit)
        self.uiQueryBTN.popupAboutToShow.connect(self.loadQuery)
        self.uiQueryBTN.popupAccepted.connect(self.assignQuery)
        self.uiRecordTREE.headerMenuAboutToShow.connect(self.updateMenu)
        
        popup.resetRequested.connect(self._queryWidget.reset)
Пример #14
0
    def __init__( self, parent = None, _project = None, _userassignment = None, _phaseassignment = None, _rowItem = None ):
    
	super(MyTasksWidgetItem, self).__init__( parent )
	
	# load the user interface# load the user interface
	if getattr(sys, 'frozen', None):
	   projexui.loadUi(sys._MEIPASS, self, uifile = (sys._MEIPASS+"/ui/mytaskswidgetitem.ui"))    
	else:
	    projexui.loadUi(__file__, self)
	    
	self._project = _project
	self._userassignment = _userassignment
	if _userassignment is not None:
	    if str(_userassignment.idUsers()) in sharedDB.myUsers:
		self.user = sharedDB.myUsers[str(_userassignment.idUsers())]
	    self._userassignment.userAssignmentChanged.connect(self.UpdateValues)
	else:
	    self.user = None
	self._phaseassignment = _phaseassignment	
	self.mytaskwidget = parent
	self._rowItem = _rowItem
	
	#connect update values
	self._project.projectChanged.connect(self.UpdateValues)
	
	self._phaseassignment.phaseAssignmentChanged.connect(self.UpdateValues)
	self._phaseassignment.phaseAssignmentChanged.connect(self.SetVisibility)
	self._phaseassignment.userAssigned.connect(self.deleteThisRow)
	
	sharedDB.mySQLConnection.dateChanged.connect(self.UpdateValues)
	
	self.UpdateValues()
Пример #15
0
    def __init__(self, parent=None):
        super(XOrbRecordSetEdit, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._table = None

        # setup delegates
        self.uiQueryTREE.setItemDelegateForColumn(1, ColumnDelegate(self))
        self.uiQueryTREE.setItemDelegateForColumn(2, OperatorDelegate(self))

        # set default properties
        palette = self.palette()
        palette.setColor(palette.Base, palette.color(palette.AlternateBase))
        self.uiQueryTREE.setPalette(palette)
        self.uiQueryTREE.setGridPen(palette.color(palette.AlternateBase))
        self.uiQueryTREE.setArrowStyle(True)
        self.uiQueryTXT.setHint('enter quick query...')
        self.uiQueryBTN.setChecked(False)
        self.setTable(None)

        # create connections
        self.uiQueryTXT.returnPressed.connect(self.applyQuery)
        self.uiQueryTREE.itemExpanded.connect(self.updateQueryItem)
        self.uiQueryTREE.itemCollapsed.connect(self.updateQueryItem)
 def __init__(self, parent, tableType):
     super(XOrbQueryEntryWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._queryWidget       = parent.queryWidget()
     self._containerWidget   = parent
     self._tableType         = tableType
     self._query             = None
     self._first             = False
     self._last              = False
     self._checked           = False
     
     self.uiEditorAREA.setAutoFillBackground(False)
     self.setAttribute(Qt.WA_DeleteOnClose)
     
     # set default properties
     self.uiColumnDDL.setTableType(tableType)
     
     # create connections (use old-style syntax or PySide errors out)
     self.connect(self.uiSelectBTN, SIGNAL('clicked()'), self.toggleChecked)
     self.connect(self.uiJoinSBTN, SIGNAL('clicked()'), self.addEntry)
     self.connect(self.uiRemoveBTN, SIGNAL('clicked()'), self.removeEntry)
     self.connect(self.uiEnterBTN, SIGNAL('clicked()'), self.enterCompound)
     self.connect(self.uiOperatorDDL,
                  SIGNAL('currentIndexChanged(int)'),
                  self.assignEditor)
     
     self.uiColumnDDL.schemaColumnChanged.connect(self.assignPlugin)
Пример #17
0
    def __init__( self, parent = None ):
        
        super(LoginWidget, self).__init__( parent )
	
        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
	    projexui.loadUi(sys._MEIPASS, self, uifile = (sys._MEIPASS+"/ui/loginwidget.ui"))	    
	else:
	    projexui.loadUi(__file__, self)
        
        # define custom properties
       
	sharedDB.loginWidget = self
        
        self._backend               = None
	self.setWindowFlags(QtCore.Qt.Tool)
	
	
        #connects buttons
        self.loginButton.clicked.connect(self.Login)
	self.user.returnPressed.connect(self.Login)
	self.password.returnPressed.connect(self.Login)
	
	if (sharedDB.autologin):
	    self.user.setText("dkonieczka")
	    self.password.setText("doodle")
	    self.Login()
	    self.close()
Пример #18
0
    def __init__(self, parent=None):

        super(ProjectViewWidget, self).__init__(parent)

        self._currentProject = None

        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
            projexui.loadUi(sys._MEIPASS,
                            self,
                            uifile=(sys._MEIPASS + "/ui/projectviewwidget.ui"))

        else:
            projexui.loadUi(__file__, self)

        self.projectDescription = textEditAutosave.TextEditAutoSave()
        self.projDescrLayout.addWidget(self.projectDescription)
        self.projectDescription.save.connect(self.SaveProjectDescription)

        self.myProjectNameLineEdit = projectNameLineEdit.ProjectNameLineEdit(
            self)
        self.projectNameLayout.addWidget(self.myProjectNameLineEdit)

        self._backend = None
        self._blockUpdates = 0

        sharedDB.myProjectViewWidget = self

        self.projectValueGrp.setEnabled(0)
        self.progressListGrpInner.setEnabled(0)
        self.AddImageBox.setHidden(1)

        self.stillImagesCheckbox.stateChanged.connect(self.ToggleStillImages)

        sharedDB.mySQLConnection.firstLoadComplete.connect(self.propogateUI)
        sharedDB.mySQLConnection.firstLoadComplete.connect(
            self.myProjectNameLineEdit.firstLoadComplete)

        self._shotTreeWidget = None
        #self.progressListLayout.addWidget(self._shotTreeWidget)
        #self.setProgressListVisibility()

        self.rigList.setColumnHidden(0, True)

        self.renderIconSize = QtGui.QSlider(QtCore.Qt.Horizontal)
        self.renderIconSize.setMaximum(2000)
        self.renderIconSize.setMinimum(20)
        self.renderIconSize.setValue(200)
        self.rendersTabLayout.addWidget(self.renderIconSize)

        self.renderTimeline = rendertimelinewidget.RenderTimelineWidget(
            self, sizeSlider=self.renderIconSize)
        self.rendersTabLayout.addWidget(self.renderTimeline)
        self.projectPartWidget.currentChanged.connect(
            self.projectPartTabChanged)

        self.projectPath.setContextMenuPolicy(Qt.CustomContextMenu)
        self.projectPath.customContextMenuRequested.connect(
            self.ProjectPathMenu)
Пример #19
0
 def __init__( self, parent = None ):
     super(XViewProfileDialog, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._profile = None
Пример #20
0
    def __init__(self, parent=None):
        super(XViewProfileDialog, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._profile = None
Пример #21
0
 def __init__( self, parent = None ):
     super(XOrbGroupingWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._tableType = None
Пример #22
0
    def __init__(self, parent=None):
        super(XOrbBrowserWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._hint = ''
        self._query = Q()
        self._advancedGrouping = []
        self._records = RecordSet()
        self._groupBy = XOrbBrowserWidget.GroupByAdvancedKey
        self._factory = XOrbBrowserFactory()
        self._queryWidget = XOrbQueryWidget(self, self._factory)
        self._thumbnailSize = QSize(128, 128)

        # set default properties
        self.uiSearchTXT.addButton(self.uiQueryBTN)
        self.uiQueryBTN.setCentralWidget(self._queryWidget)
        self.uiThumbLIST.installEventFilter(self)

        self.uiQueryACT.setShortcutContext(Qt.WidgetWithChildrenShortcut)
        self.uiQueryBTN.setDefaultAction(self.uiQueryACT)

        self.uiViewModeWGT.addAction(self.uiDetailsACT)
        self.uiViewModeWGT.addAction(self.uiCardACT)
        self.uiViewModeWGT.addAction(self.uiThumbnailACT)

        # create connections
        self.uiGroupOptionsBTN.clicked.connect(self.showGroupMenu)
        self.uiSearchTXT.returnPressed.connect(self.refresh)
        self.queryChanged.connect(self.refresh)
        self.uiGroupBTN.toggled.connect(self.refreshResults)

        self.uiDetailsACT.triggered.connect(self.setDetailMode)
        self.uiCardACT.triggered.connect(self.setCardMode)
        self.uiThumbnailACT.triggered.connect(self.setThumbnailMode)

        self.uiQueryBTN.popupAboutToShow.connect(self.prepareQuery)
        self.uiQueryBTN.popupAccepted.connect(self.acceptQuery)
        self.uiQueryBTN.popupReset.connect(self.resetQuery)

        self.uiRefreshBTN.clicked.connect(self.refresh)

        self.uiRecordsTREE.itemDoubleClicked.connect(self.handleDetailDblClick)
        self.uiRecordsTREE.currentItemChanged.connect(
            self.emitCurrentRecordChanged)

        self.uiThumbLIST.itemDoubleClicked.connect(self.handleThumbDblClick)
        self.uiThumbLIST.currentItemChanged.connect(
            self.emitCurrentRecordChanged)

        self.uiCardTREE.itemDoubleClicked.connect(self.handleCardDblClick)
        self.uiCardTREE.currentItemChanged.connect(
            self.emitCurrentRecordChanged)
Пример #23
0
 def __init__( self, parent = None ):
     super(XOrbBrowserWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._hint              = ''
     self._query             = Q()
     self._advancedGrouping  = []
     self._records           = RecordSet()
     self._groupBy           = XOrbBrowserWidget.GroupByAdvancedKey
     self._factory           = XOrbBrowserFactory()
     self._queryWidget       = XOrbQueryWidget(self, self._factory)
     self._thumbnailSize     = QSize(128, 128)
     
     # set default properties
     self.uiSearchTXT.addButton(self.uiQueryBTN)
     self.uiQueryBTN.setCentralWidget(self._queryWidget)
     self.uiThumbLIST.installEventFilter(self)
     
     self.uiQueryACT.setShortcutContext(Qt.WidgetWithChildrenShortcut)
     self.uiQueryBTN.setDefaultAction(self.uiQueryACT)
     
     self.uiViewModeWGT.addAction(self.uiDetailsACT)
     self.uiViewModeWGT.addAction(self.uiCardACT)
     self.uiViewModeWGT.addAction(self.uiThumbnailACT)
     
     # create connections
     self.uiGroupOptionsBTN.clicked.connect(self.showGroupMenu)
     self.uiSearchTXT.returnPressed.connect(self.refresh)
     self.queryChanged.connect(self.refresh)
     self.uiGroupBTN.toggled.connect(self.refreshResults)
     
     self.uiDetailsACT.triggered.connect(self.setDetailMode)
     self.uiCardACT.triggered.connect(self.setCardMode)
     self.uiThumbnailACT.triggered.connect(self.setThumbnailMode)
     
     self.uiQueryBTN.popupAboutToShow.connect(self.prepareQuery)
     self.uiQueryBTN.popupAccepted.connect(self.acceptQuery)
     self.uiQueryBTN.popupReset.connect(self.resetQuery)
     
     self.uiRefreshBTN.clicked.connect(self.refresh)
     
     self.uiRecordsTREE.itemDoubleClicked.connect(self.handleDetailDblClick)
     self.uiRecordsTREE.currentItemChanged.connect(
                                              self.emitCurrentRecordChanged)
     
     self.uiThumbLIST.itemDoubleClicked.connect(self.handleThumbDblClick)
     self.uiThumbLIST.currentItemChanged.connect(
                                             self.emitCurrentRecordChanged)
     
     self.uiCardTREE.itemDoubleClicked.connect(self.handleCardDblClick)
     self.uiCardTREE.currentItemChanged.connect(
                                             self.emitCurrentRecordChanged)
Пример #24
0
    def __init__( self, parent = None ):
    
	super(HoursWidget, self).__init__( parent )
	
	self._currentProject = None
	
	# load the user interface# load the user interface
	if getattr(sys, 'frozen', None):
	    projexui.loadUi(sys._MEIPASS, self, uifile = (sys._MEIPASS+"/ui/hourswidget.ui"))
	    
	else:
	    projexui.loadUi(__file__, self)
Пример #25
0
    def __init__(self, parent=None):
        super(XProgressFeedbackWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # update the ui
        self._showSecondary = False

        self.uiLoggerEDIT.hide()
        self.setProgress(0)
        self.setSecondaryProgress(0)
        self.setShowSecondaryProgress(False)
 def __init__( self, parent = None ):
     super(XProgressFeedbackWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # update the ui
     self._showSecondary = False
     
     self.uiLoggerEDIT.hide()
     self.setProgress(0)
     self.setSecondaryProgress(0)
     self.setShowSecondaryProgress(False)
Пример #27
0
    def __init__(self, parent=None):
        super(XLogRecordWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._handler = XLogRecordHandler(self)
        self._destroyed = False
        self._loggers = set()
        self._activeLevels = []
        self._queue = []
        self._timer = QtCore.QTimer()
        self._timer.setInterval(500)  # only load records every 500 msecs

        # update the feedback
        id = threading.currentThread().ident
        self.uiFeedbackLBL.setText('Main thread: {0}'.format(id))

        # update the interface
        font = QtGui.QFont('Courier New')
        font.setPointSize(9)
        self.uiRecordTREE.setFont(font)
        self.uiRecordTREE.setVisibleColumns(['Level', 'Name', 'Message'])
        self.uiRecordTREE.setFilteredColumns(
            list(range(self.uiRecordTREE.columnCount())))
        self.updateUi()

        # setup the configurations
        popup = self.uiSettingsBTN.popupWidget()
        popup.setShowTitleBar(False)
        popup.setResizable(False)

        bbox = popup.buttonBox()
        bbox.clear()
        bbox.addButton(QtGui.QDialogButtonBox.Ok)

        # create the logger tree widget
        controls = XLogRecordControls(self)
        self.uiSettingsBTN.setCentralWidget(controls)
        self.uiSettingsBTN.setDefaultAnchor(popup.Anchor.TopRight)

        self._timer.start()

        # create connections
        self._timer.timeout.connect(self.loadQueue)
        self._handler.dispatch().recordLogged.connect(self.addRecord)

        self.uiRecordBTN.toggled.connect(self.updateUi)
        self.uiRecordTREE.customContextMenuRequested.connect(self.showMenu)
        self.destroyed.connect(self.markDestroyed)
Пример #28
0
 def __init__( self, parent = None ):
     super(XLogRecordWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._handler = XLogRecordHandler(self)
     self._destroyed = False
     self._loggers = set()
     self._activeLevels = []
     self._queue = []
     self._timer = QtCore.QTimer()
     self._timer.setInterval(500)  # only load records every 500 msecs
     
     # update the feedback
     id = threading.currentThread().ident
     self.uiFeedbackLBL.setText('Main thread: {0}'.format(id))
     
     # update the interface
     font = QtGui.QFont('Courier New')
     font.setPointSize(9)
     self.uiRecordTREE.setFont(font)
     self.uiRecordTREE.setVisibleColumns(['Level', 'Name', 'Message'])
     self.uiRecordTREE.setFilteredColumns(list(range(self.uiRecordTREE.columnCount())))
     self.updateUi()
     
     # setup the configurations
     popup = self.uiSettingsBTN.popupWidget()
     popup.setShowTitleBar(False)
     popup.setResizable(False)
     
     bbox = popup.buttonBox()
     bbox.clear()
     bbox.addButton(QtGui.QDialogButtonBox.Ok)
     
     # create the logger tree widget
     controls = XLogRecordControls(self)
     self.uiSettingsBTN.setCentralWidget(controls)
     self.uiSettingsBTN.setDefaultAnchor(popup.Anchor.TopRight)
     
     self._timer.start()
     
     # create connections
     self._timer.timeout.connect(self.loadQueue)
     self._handler.dispatch().recordLogged.connect(self.addRecord)
     
     self.uiRecordBTN.toggled.connect(self.updateUi)
     self.uiRecordTREE.customContextMenuRequested.connect(self.showMenu)
     self.destroyed.connect(self.markDestroyed)
Пример #29
0
 def __init__( self, parent = None ):
     super(XWizardBrowserDialog,self).__init__(parent)
     
     # load the ui
     projexui.loadUi(__file__, self)
     
     self._plugins = []
     
     self.showWizards()
     
     # create connections
     self.uiPluginTREE.itemSelectionChanged.connect( self.showWizards )
     self.uiWizardTABLE.itemSelectionChanged.connect( self.showDescription )
     self.uiWizardTABLE.itemDoubleClicked.connect( self.runWizard )
Пример #30
0
    def __init__(self, parent=None):
        super(XQueryLineWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._currentRule = None

        # create connections
        self.uiTermDDL.currentIndexChanged.connect(self.applyRule)
        self.uiOperatorDDL.currentIndexChanged.connect(self.updateEditor)

        self.uiAddBTN.clicked.connect(self.emitAddRequested)
        self.uiRemoveBTN.clicked.connect(self.emitRemoveRequested)
Пример #31
0
 def __init__( self, parent = None ):
     super(XQueryLineWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._currentRule = None
     
     # create connections
     self.uiTermDDL.currentIndexChanged.connect( self.applyRule )
     self.uiOperatorDDL.currentIndexChanged.connect( self.updateEditor )
     
     self.uiAddBTN.clicked.connect(      self.emitAddRequested )
     self.uiRemoveBTN.clicked.connect(   self.emitRemoveRequested )
Пример #32
0
 def __init__(self, scaffold, parent=None):
     super(XScaffoldStructurePage, self).__init__(parent)
     
     # setup the scaffolding options
     self._scaffold = scaffold
     self._structure = None
     
     projexui.loadUi(__file__, self)
     
     path = QtGui.QApplication.clipboard().text()
     if not os.path.isdir(path):
         path = QtCore.QDir.currentPath()
     
     self.uiOutputPATH.setFilepath(path)
     self.uiStructureTREE.itemChanged.connect(self.updateItems)
Пример #33
0
    def __init__(self, scaffold, parent=None):
        super(XScaffoldStructurePage, self).__init__(parent)

        # setup the scaffolding options
        self._scaffold = scaffold
        self._structure = None

        projexui.loadUi(__file__, self)

        path = QtGui.QApplication.clipboard().text()
        if not os.path.isdir(path):
            path = QtCore.QDir.currentPath()

        self.uiOutputPATH.setFilepath(path)
        self.uiStructureTREE.itemChanged.connect(self.updateItems)
Пример #34
0
    def __init__(self, parent=None):
        super(XConsoleView, self).__init__(parent, autoKillThreads=False)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._locked = False
        self._lastDetails = True
        self._lastHeight = None

        # set default properties
        self.uiConsoleEDIT.setLogger(logging.root)
        self.uiLoggerDDL.addItem(ROOT_LOGGER_TEXT)
        self.uiLoggerDDL.addItem('-----------')
        self.lockHeight()

        self.uiFindWIDGET.hide()

        all_loggers = logging.root.manager.loggerDict.keys()
        self.uiLoggerDDL.addItems(sorted(all_loggers))
        self.adjustLoggerIcons()

        # load level drop down list
        order = []
        size = QSize(120, 20)
        for i, item in enumerate(sorted(XLoggerWidget.LoggingMap.items())):
            level, data = item
            self.uiLevelDDL.addItem(projex.text.pretty(data[0]))
            self.uiLevelDDL.setItemIcon(i, QIcon(data[1]))
            self.uiLevelDDL.setItemData(i, wrapVariant(level))
            self.uiLevelDDL.setItemData(i, wrapVariant(size), Qt.SizeHintRole)

            if (logging.root.getEffectiveLevel() == level):
                self.uiLevelDDL.setCurrentIndex(i)

        # link the find widget with the text edit
        self.uiFindWIDGET.setTextEdit(self.uiConsoleEDIT)

        # create connections
        self.uiLevelDDL.currentIndexChanged.connect(self.adjustLevel)
        self.uiShowLevelCHK.toggled.connect(self.uiConsoleEDIT.setShowLevel)
        self.uiShowDetailsCHK.toggled.connect(
            self.uiConsoleEDIT.setShowDetails)
        self.uiShowDetailsCHK.clicked.connect(self.setLastDetails)
        self.uiLoggerDDL.currentIndexChanged.connect(self.updateLogger)
        self.uiMoreBTN.clicked.connect(self.unlockHeight)
        self.uiLessBTN.clicked.connect(self.lockHeight)
Пример #35
0
 def __init__(self, parent=None):
     super(XConsoleView, self).__init__(parent, autoKillThreads=False)
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._locked        = False
     self._lastDetails   = True
     self._lastHeight    = None
     
     # set default properties
     self.uiConsoleEDIT.setLogger(logging.root)
     self.uiLoggerDDL.addItem(ROOT_LOGGER_TEXT)
     self.uiLoggerDDL.addItem('-----------')
     self.lockHeight()
     
     self.uiFindWIDGET.hide()
     
     all_loggers = logging.root.manager.loggerDict.keys()
     self.uiLoggerDDL.addItems(sorted(all_loggers))
     self.adjustLoggerIcons()
     
     # load level drop down list
     order = []
     size = QSize(120, 20)
     for i, item in enumerate(sorted(XLoggerWidget.LoggingMap.items())):
         level, data = item
         self.uiLevelDDL.addItem(projex.text.pretty(data[0]))
         self.uiLevelDDL.setItemIcon(i, QIcon(data[1]))
         self.uiLevelDDL.setItemData(i, wrapVariant(level))
         self.uiLevelDDL.setItemData(i, wrapVariant(size), Qt.SizeHintRole)
         
         if ( logging.root.getEffectiveLevel() == level ):
             self.uiLevelDDL.setCurrentIndex(i)
     
     # link the find widget with the text edit
     self.uiFindWIDGET.setTextEdit(self.uiConsoleEDIT)
     
     # create connections
     self.uiLevelDDL.currentIndexChanged.connect( self.adjustLevel )
     self.uiShowLevelCHK.toggled.connect( self.uiConsoleEDIT.setShowLevel )
     self.uiShowDetailsCHK.toggled.connect(self.uiConsoleEDIT.setShowDetails)
     self.uiShowDetailsCHK.clicked.connect(self.setLastDetails)
     self.uiLoggerDDL.currentIndexChanged.connect( self.updateLogger )
     self.uiMoreBTN.clicked.connect( self.unlockHeight )
     self.uiLessBTN.clicked.connect( self.lockHeight )
Пример #36
0
    def __init__(self, parent=None):
        super(XFontPickerWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        database = QFontDatabase()
        for family in sorted(database.families()):
            item = QTreeWidgetItem(self.uiFontTREE, [family])
            item.setFont(0, QFont(family))

        # set default properties

        # create connections
        self.uiSizeSPN.valueChanged.connect(self.setPointSize)
        self.uiFontTREE.itemDoubleClicked.connect(self.accepted)
Пример #37
0
    def __init__(self, parent=None):

        super(AEShot, self).__init__(parent)

        self._noImage = projexui.resources.find('img/DP/noImage.png')

        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
            projexui.loadUi(sys._MEIPASS,
                            self,
                            uifile=(sys._MEIPASS + "/ui/AEshot.ui"))
        else:
            projexui.loadUi(__file__, self)

        self.setHidden(1)

        self.shotImage = clickableImageQLabel.ClickableImageQLabel(self)
        self.shotImageLayout.addWidget(self.shotImage)

        self.shotDescription = textEditAutosave.TextEditAutoSave()
        self.shotDescriptionLayout.addWidget(self.shotDescription)
        self.shotDescription.save.connect(self.SaveShotDescription)

        self.shotNotes = textEditAutosave.TextEditAutoSave()
        self.shotNotesLayout.addWidget(self.shotNotes)
        self.shotNotes.save.connect(self.SaveShotNotes)

        self.cfip = CheckForImagePath()
        self.cfip.AEShot = self
        self.shotImageFound.connect(self.shotImage.assignImage)
        #self.shotImageDir = ''

        self.cfpb = CheckForPlayblastPath()
        self.shotPlayblastPath = None
        self.shotPlayblastDir = ''
        self.shotImage.clicked.connect(self.checkForPlayblast)

        self.startFrame.valueChanged.connect(self.SetShotValues)
        self.endFrame.valueChanged.connect(self.SetShotValues)

        self.project = None

        self._backend = None
        self._blockUpdates = 0

        self.setEnabled(0)
Пример #38
0
 def __init__( self, parent = None ):
     super(XFontPickerWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     database = QFontDatabase()
     for family in sorted(database.families()):
         item = QTreeWidgetItem(self.uiFontTREE, [family])
         item.setFont(0, QFont(family))
     
     # set default properties
     
     # create connections
     self.uiSizeSPN.valueChanged.connect(self.setPointSize)
     self.uiFontTREE.itemDoubleClicked.connect(self.accepted)
Пример #39
0
 def __init__( self, parent = None, factory = None ):
     super(XOrbQueryWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     if ( not factory ):
         factory = XOrbBrowserFactory()
     
     # define custom properties
     self._tableType = None
     self._factory = factory
     
     # setup delegates
     delegates = [self.uiQueryTREE.itemDelegate()]
     
     # create the column delegate
     column_delegate   = ColumnDelegate(self.uiQueryTREE)
     operator_delegate = OperatorDelegate(self.uiQueryTREE)
     value_delegate    = ValueDelegate(self.uiQueryTREE)
     
     delegates.append(column_delegate)
     delegates.append(operator_delegate)
     delegates.append(value_delegate)
     
     self.uiQueryTREE.setItemDelegateForColumn(0, column_delegate)
     self.uiQueryTREE.setItemDelegateForColumn(1, operator_delegate)
     self.uiQueryTREE.setItemDelegateForColumn(2, value_delegate)
     
     # set the resize mode
     header = self.uiQueryTREE.header()
     header.setResizeMode(0, header.ResizeToContents)
     header.setResizeMode(1, header.ResizeToContents)
     
     # create event filter information
     self.uiQueryTXT.installEventFilter(self)
     
     # create connections
     self.uiQueryTREE.itemExpanded.connect(self.updateQueryItem)
     self.uiQueryTREE.itemCollapsed.connect(self.updateQueryItem)
     self.uiAddBTN.clicked.connect(self.addQuery)
     self.uiGroupBTN.clicked.connect(self.groupQuery)
     self.uiRemoveBTN.clicked.connect(self.removeQuery)
Пример #40
0
    def __init__(self, parent=None, factory=None):
        super(XOrbQueryWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        if (not factory):
            factory = XOrbBrowserFactory()

        # define custom properties
        self._tableType = None
        self._factory = factory

        # setup delegates
        delegates = [self.uiQueryTREE.itemDelegate()]

        # create the column delegate
        column_delegate = ColumnDelegate(self.uiQueryTREE)
        operator_delegate = OperatorDelegate(self.uiQueryTREE)
        value_delegate = ValueDelegate(self.uiQueryTREE)

        delegates.append(column_delegate)
        delegates.append(operator_delegate)
        delegates.append(value_delegate)

        self.uiQueryTREE.setItemDelegateForColumn(0, column_delegate)
        self.uiQueryTREE.setItemDelegateForColumn(1, operator_delegate)
        self.uiQueryTREE.setItemDelegateForColumn(2, value_delegate)

        # set the resize mode
        header = self.uiQueryTREE.header()
        header.setResizeMode(0, header.ResizeToContents)
        header.setResizeMode(1, header.ResizeToContents)

        # create event filter information
        self.uiQueryTXT.installEventFilter(self)

        # create connections
        self.uiQueryTREE.itemExpanded.connect(self.updateQueryItem)
        self.uiQueryTREE.itemCollapsed.connect(self.updateQueryItem)
        self.uiAddBTN.clicked.connect(self.addQuery)
        self.uiGroupBTN.clicked.connect(self.groupQuery)
        self.uiRemoveBTN.clicked.connect(self.removeQuery)
Пример #41
0
    def __init__( self, parent = None ):
    
	super(AEShot, self).__init__( parent )
	
	self._noImage = projexui.resources.find('img/DP/noImage.png')
	
	# load the user interface# load the user interface
	if getattr(sys, 'frozen', None):
	    projexui.loadUi(sys._MEIPASS, self, uifile = (sys._MEIPASS+"/ui/AEshot.ui"))	    
	else:
	    projexui.loadUi(__file__, self)
	
	self.setHidden(1)
	
	self.shotImage = clickableImageQLabel.ClickableImageQLabel(self)
	self.shotImageLayout.addWidget(self.shotImage)
	
	self.shotDescription = textEditAutosave.TextEditAutoSave()
	self.shotDescriptionLayout.addWidget(self.shotDescription)
	self.shotDescription.save.connect(self.SaveShotDescription)
	
	self.shotNotes = textEditAutosave.TextEditAutoSave()
	self.shotNotesLayout.addWidget(self.shotNotes)
	self.shotNotes.save.connect(self.SaveShotNotes)
	
	self.cfip = CheckForImagePath()
	self.shotImageFound.connect(self.shotImage.assignImage)
	self.shotImageDir = ''	
	
	self.cfpb = CheckForPlayblastPath()
	self.shotPlayblastPath = None
	self.shotPlayblastDir = ''
	self.shotImage.clicked.connect(self.checkForPlayblast)
	
	self.startFrame.valueChanged.connect(self.SetShotValues)
	self.endFrame.valueChanged.connect(self.SetShotValues)
	
	self.project = None	
	
	self._backend               = None
	self._blockUpdates = 0

	self.setEnabled(0)
Пример #42
0
    def __init__(self,
                 parent=None,
                 _project=None,
                 _userassignment=None,
                 _phaseassignment=None,
                 _rowItem=None):

        super(MyTasksWidgetItem, self).__init__(parent)

        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
            projexui.loadUi(sys._MEIPASS,
                            self,
                            uifile=(sys._MEIPASS + "/ui/mytaskswidgetitem.ui"))
        else:
            projexui.loadUi(__file__, self)

        self._project = _project
        self._userassignment = _userassignment
        if _userassignment is not None:
            if str(_userassignment.idUsers()) in sharedDB.myUsers:
                self.user = sharedDB.myUsers[str(_userassignment.idUsers())]
            self._userassignment.userAssignmentChanged.connect(
                self.UpdateValues)
        else:
            self.user = None
        self._phaseassignment = _phaseassignment
        self.mytaskwidget = parent
        self._rowItem = _rowItem

        #connect update values
        self._project.projectChanged.connect(self.UpdateValues)

        self._phaseassignment.phaseAssignmentChanged.connect(self.UpdateValues)
        self._phaseassignment.phaseAssignmentChanged.connect(
            self.SetVisibility)
        self._phaseassignment.userAssigned.connect(self.deleteThisRow)

        sharedDB.mySQLConnection.dateChanged.connect(self.UpdateValues)
        self.tasklist = []

        self.UpdateValues()
Пример #43
0
    def __init__(self, parent=None):
        super(XMenuTemplateWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._actions = {}

        # set default properties
        self.uiActionTREE.setDataCollector(XMenuTemplateWidget.dataCollector)
        self.uiMenuTREE.installEventFilter(self)

        palette = self.uiMenuTREE.palette()
        palette.setColor(palette.Base, palette.color(palette.Window))
        palette.setColor(palette.Text, palette.color(palette.WindowText))
        self.uiMenuTREE.setPalette(palette)

        # create connections
        self.uiMenuTREE.customContextMenuRequested.connect(self.showMenu)
Пример #44
0
 def __init__( self, parent = None ):
     super(XMenuTemplateWidget, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._actions = {}
     
     # set default properties
     self.uiActionTREE.setDataCollector( XMenuTemplateWidget.dataCollector )
     self.uiMenuTREE.installEventFilter(self)
     
     palette = self.uiMenuTREE.palette()
     palette.setColor(palette.Base, palette.color(palette.Window))
     palette.setColor(palette.Text, palette.color(palette.WindowText))
     self.uiMenuTREE.setPalette(palette)
     
     # create connections
     self.uiMenuTREE.customContextMenuRequested.connect( self.showMenu )
Пример #45
0
    def __init__( self, parent = None ):
    
	super(ProjectViewWidget, self).__init__( parent )
	
	self._currentProject = None
	
	# load the user interface# load the user interface
	if getattr(sys, 'frozen', None):
	    projexui.loadUi(sys._MEIPASS, self, uifile = (sys._MEIPASS+"/ui/projectviewwidget.ui"))
	    
	else:
	    projexui.loadUi(__file__, self)
	
	self.projectDescription = textEditAutosave.TextEditAutoSave()
	self.projDescrLayout.addWidget(self.projectDescription)
	self.projectDescription.save.connect(self.SaveProjectDescription)
	
	self.myProjectNameLineEdit = projectNameLineEdit.ProjectNameLineEdit(self)
	self.projectNameLayout.addWidget(self.myProjectNameLineEdit)
	
	self._backend               = None
	self._blockUpdates = 0
	
	sharedDB.myProjectViewWidget = self

	self.projectValueGrp.setEnabled(0)
	self.progressListGrpInner.setEnabled(0)
	self.AddImageBox.setHidden(1)
	
	
	self.stillImagesCheckbox.stateChanged.connect(self.ToggleStillImages)
	
	sharedDB.mySQLConnection.firstLoadComplete.connect(self.propogateUI)
	sharedDB.mySQLConnection.firstLoadComplete.connect(self.myProjectNameLineEdit.firstLoadComplete)
	
	self._shotTreeWidget = None
	#self.progressListLayout.addWidget(self._shotTreeWidget)
	#self.setProgressListVisibility()
	
	self.rigList.setColumnHidden(0,True)
Пример #46
0
    def __init__(self, parent=None, uifile=''):
        super(XShortcutWidget, self).__init__(parent, uifile)

        # load the user interface
        projexui.loadUi(__file__, self)

        # update the tree view
        header = self.uiActionTREE.header()
        header.setStretchLastSection(False)
        header.setResizeMode(0, header.Stretch)
        header.setResizeMode(1, header.ResizeToContents)

        window = projexui.topWindow()
        self.setActions(window.actions())

        # intercept key press events for the shortcut widget
        self.uiShortcutTXT.installEventFilter(self)

        # create connections
        self.uiActionTREE.itemSelectionChanged.connect(self.updateAction)
        self.uiClearBTN.clicked.connect(self.clear)
        self.uiSaveBTN.clicked.connect(self.updateShortcut)
Пример #47
0
 def __init__( self, parent = None, uifile = '' ):
     super(XShortcutWidget, self).__init__( parent, uifile )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # update the tree view
     header = self.uiActionTREE.header()
     header.setStretchLastSection(False)
     header.setResizeMode(0, header.Stretch)
     header.setResizeMode(1, header.ResizeToContents)
     
     window = projexui.topWindow()
     self.setActions(window.actions())
     
     # intercept key press events for the shortcut widget
     self.uiShortcutTXT.installEventFilter(self)
     
     # create connections
     self.uiActionTREE.itemSelectionChanged.connect( self.updateAction )
     self.uiClearBTN.clicked.connect( self.clear )
     self.uiSaveBTN.clicked.connect( self.updateShortcut )
Пример #48
0
 def __init__(self, loggerWidget):
     super(XLogRecordControls, self).__init__(loggerWidget)
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     self._loggerWidget = loggerWidget
     self.uiLoggerTREE.setLoggerWidget(loggerWidget)
     
     # load the levels
     if 'designer' not in sys.executable:
         tree = self.uiLevelTREE
         from projexui.widgets.xloggerwidget import XLoggerWidget
         items = sorted(XLoggerWidget.LoggingMap.items())
         for i, (level, data) in enumerate(items):
             item = XTreeWidgetItem(tree, [projex.text.pretty(data[0])])
             item.setFixedHeight(22)
             item.setData(0, QtCore.Qt.UserRole, wrapVariant(level))
             item.setCheckState(0, QtCore.Qt.Unchecked)
     
     # create connections
     self.uiLevelTREE.itemChanged.connect(self.updateLevels)
Пример #49
0
    def __init__( self, parent = None ):
        
        super(CreateProjectWidget, self).__init__( parent )
        
        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
	    #print (sys._MEIPASS+"/ui/createprojectwidget.ui");
	    projexui.loadUi(sys._MEIPASS, self, uifile = (sys._MEIPASS+"/ui/userwidget.ui"))
	    
	else:
	    projexui.loadUi(__file__, self)
        #projexui.loadUi(__file__, self)
        
        # define custom properties
        
        self._backend               = None
        
        #connects buttons
        self.createButton.clicked.connect(self.CreateProject)
        self.cancelButton.clicked.connect(self.cancel)
        self.setDefaults()
	self.open()
Пример #50
0
    def __init__(self, parent=None):

        super(CreateProjectWidget, self).__init__(parent)

        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
            #print (sys._MEIPASS+"/ui/createprojectwidget.ui");
            projexui.loadUi(sys._MEIPASS,
                            self,
                            uifile=(sys._MEIPASS +
                                    "/ui/createprojectwidget.ui"))

        else:
            projexui.loadUi(__file__, self)
        #projexui.loadUi(__file__, self)

        # define custom properties

        self.dockWidget = QDockWidget()
        parent.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dockWidget)
        self.dockWidget.setFloating(1)
        self.dockWidget.setWindowTitle("Create Project")
        self.dockWidget.setWidget(self)

        #self.setWindowFlags(QtCore.Qt.Tool)

        self._backend = None

        #self.myClientNameLineEdit = clientIPLineEdit.ClientIPLineEdit(self)
        #self.clientIPBoxLayout.addWidget(self.myClientNameLineEdit)

        #connects buttons
        self.createButton.clicked.connect(self.CreateProject)
        self.cancelButton.clicked.connect(self.cancel)
        self.UpdateClientList()
        self.clientComboBox.currentIndexChanged.connect(self.UpdateIPList)

        self.UpdateIPList(self.clientComboBox.currentIndex())
Пример #51
0
 def __init__( self, parent = None ):
     super(XOrbQueryContainer, self).__init__( parent )
     
     # load the user interface
     projexui.loadUi(__file__, self)
     
     # define custom properties
     self._queryWidget   = parent
     self._entryWidget   = QWidget(self)
     self._currentJoiner = QueryCompound.Op.And
     
     layout = QVBoxLayout()
     layout.addStretch(1)
     layout.setSpacing(3)
     self._entryWidget.setLayout(layout)
     self.uiQueryAREA.setWidget(self._entryWidget)
     
     # set default properties
     self.setContextMenuPolicy(Qt.CustomContextMenu)
     
     # create connections (use old-style syntax or PySide errors)
     self.connect(self.uiBackBTN, SIGNAL('clicked()'), self.exitCompound)
     self.entriesUpdated.connect(self.refreshEntries)
Пример #52
0
    def __init__(self, parent=None):
        super(XOrbQueryContainer, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._queryWidget = parent
        self._entryWidget = QWidget(self)
        self._currentJoiner = QueryCompound.Op.And

        layout = QVBoxLayout()
        layout.addStretch(1)
        layout.setSpacing(3)
        self._entryWidget.setLayout(layout)
        self.uiQueryAREA.setWidget(self._entryWidget)

        # set default properties
        self.setContextMenuPolicy(Qt.CustomContextMenu)

        # create connections (use old-style syntax or PySide errors)
        self.connect(self.uiBackBTN, SIGNAL('clicked()'), self.exitCompound)
        self.entriesUpdated.connect(self.refreshEntries)
Пример #53
0
    def __init__(self, parent=None):

        super(CreateProjectWidget, self).__init__(parent)

        # load the user interface# load the user interface
        if getattr(sys, 'frozen', None):
            #print (sys._MEIPASS+"/ui/createprojectwidget.ui");
            projexui.loadUi(sys._MEIPASS,
                            self,
                            uifile=(sys._MEIPASS + "/ui/userwidget.ui"))

        else:
            projexui.loadUi(__file__, self)
        #projexui.loadUi(__file__, self)

        # define custom properties

        self._backend = None

        #connects buttons
        self.createButton.clicked.connect(self.CreateProject)
        self.cancelButton.clicked.connect(self.cancel)
        self.setDefaults()
        self.open()
Пример #54
0
    def __init__( self, parent = None, _sequence = '',_sequenceTreeItem = '', _project = '' ):
    
	super(SeqDescription, self).__init__( parent )
	
	# load the user interface# load the user interface
	if getattr(sys, 'frozen', None):
	    projexui.loadUi(sys._MEIPASS, self, uifile = (sys._MEIPASS+"/ui/seqDescription.ui")) 
	else:
	    projexui.loadUi(__file__, self)

	self._sequence = _sequence
	self._sequenceTreeItem = _sequenceTreeItem
	self._project = _project
	
	self.sequenceDescription = textEditAutosave.TextEditAutoSave(source = self._sequence, sourceAttr = "_description")
	self.seqDescriptionLayout.addWidget(self.sequenceDescription)
	self.sequenceDescription.save.connect(self.SaveSequenceDescription)
	
	self.setDescription()
	
	self.descriptionBox.setTitle("Sequence "+str(self._sequence._number)+" Description")
	
	self.addShot.clicked.connect(self.AddShot)
	self._sequence.sequenceChanged.connect(self.setDescription)
Пример #55
0
    def __init__(self, parent=None):
        super(XGanttWidget, self).__init__(parent)

        # load the user interface
        projexui.loadUi(__file__, self)

        # define custom properties
        self._backend = None
        self._dateStart = QDate.currentDate().addMonths(-2)
        self._dateEnd = QDate.currentDate().addMonths(2)
        self._timeStart = QTime(0, 0, 0)
        self._timeEnd = QTime(23, 59, 59)
        self._alternatingRowColors = False
        self._cellWidth = 20
        self._cellHeight = 20
        self._first = True
        self._dateFormat = 'M/d/yy'
        self._timescale = XGanttWidget.Timescale.Month
        self._scrolling = False
        self._dirty = False

        # setup the palette colors
        palette = self.palette()
        color = palette.color(palette.Base)

        self._gridPen = QPen(color.darker(115))
        self._brush = QBrush(color)
        self._alternateBrush = QBrush(color.darker(105))

        weekendColor = color.darker(108)
        self._weekendBrush = QBrush(weekendColor)

        # setup the columns for the tree
        self.setColumns(['Name', 'Start', 'End', 'Calendar Days', 'Work Days'])

        header = self.uiGanttTREE.header()
        header.setFixedHeight(self._cellHeight * 2)
        headerItem = self.uiGanttTREE.headerItem()
        headerItem.setSizeHint(0, QSize(80, header.height()))

        # initialize the tree widget
        self.uiGanttTREE.setShowGrid(False)
        self.uiGanttTREE.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        self.uiGanttTREE.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.uiGanttTREE.setVerticalScrollMode(self.uiGanttTREE.ScrollPerPixel)
        self.uiGanttTREE.setResizeToContentsInteractive(True)
        self.uiGanttTREE.setEditable(True)
        self.uiGanttTREE.resize(500, 20)
        self.uiGanttTREE.setContextMenuPolicy(Qt.CustomContextMenu)

        # initialize the view widget
        self.uiGanttVIEW.setDragMode(self.uiGanttVIEW.RubberBandDrag)
        self.uiGanttVIEW.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        self.uiGanttVIEW.setAlignment(Qt.AlignTop | Qt.AlignLeft)
        self.uiGanttVIEW.setScene(XGanttScene(self))
        self.uiGanttVIEW.installEventFilter(self)
        self.uiGanttVIEW.horizontalScrollBar().setValue(50)
        self.uiGanttVIEW.setContextMenuPolicy(Qt.CustomContextMenu)

        # create connections
        self.uiGanttTREE.itemExpanded.connect(self.syncView)
        self.uiGanttTREE.itemCollapsed.connect(self.syncView)

        # connect scrollbars
        tree_bar = self.uiGanttTREE.verticalScrollBar()
        view_bar = self.uiGanttVIEW.verticalScrollBar()

        tree_bar.rangeChanged.connect(self._updateViewRect)
        tree_bar.valueChanged.connect(self._scrollView)
        view_bar.valueChanged.connect(self._scrollTree)

        # connect selection
        self.uiGanttTREE.itemSelectionChanged.connect(self._selectView)
        self.uiGanttVIEW.scene().selectionChanged.connect(self._selectTree)
        self.uiGanttTREE.itemChanged.connect(self.updateItemData)
        self.uiGanttTREE.customContextMenuRequested.connect(
            self.requestTreeMenu)
        self.uiGanttVIEW.customContextMenuRequested.connect(
            self.requestViewMenu)
Пример #56
0
 def rebuild( self ):
     """
     Rebuilds the interface for this widget based on the current model.
     """
     self.setUpdatesEnabled(False)
     self.blockSignals(True)
     
     # clear out all the subwidgets for this widget
     for child in self.findChildren(QObject):
         child.setParent(None)
         child.deleteLater()
     
     # load up all the interface for this widget
     schema = self.schema()
     if ( schema ):
         self.setEnabled(True)
         
         uifile = self.uiFile()
         
         # load a user defined file
         if ( uifile ):
             projexui.loadUi('', self, uifile)
             
             for widget in self.findChildren(XOrbColumnEdit):
                 columnName = widget.columnName()
                 column     = schema.column(columnName)
                 
                 if ( column ):
                     widget.setColumn(column)
                 else:
                     logger.debug('%s is not a valid column of %s' % \
                                  (columnName, schema.name()))
         
         # dynamically load files
         else:
             layout = QFormLayout()
             layout.setContentsMargins(0, 0, 0, 0)
             columns = schema.columns()
             columns.sort(key = lambda x: x.displayName())
             
             record = self.record()
             
             for column in columns:
                 # ignore protected columns
                 if ( column.name().startswith('_') ):
                     continue
                 
                 label   = column.displayName()
                 coltype = column.columnType()
                 name    = column.name()
                 
                 # create the column edit widget
                 widget  = XOrbColumnEdit(self)
                 widget.setObjectName('ui_' + name)
                 widget.setColumnName(name)
                 widget.setColumnType(coltype)
                 widget.setColumn(column)
                 
                 layout.addRow(QLabel(label, self), widget)
             
             self.setLayout(layout)
             self.adjustSize()
             
             self.setWindowTitle('Edit %s' % schema.name())
     else:
         self.setEnabled(False)
     
     self.setUpdatesEnabled(True)
     self.blockSignals(False)