class BotTab(TabWidget): key = 'BotTab' def __init__(self, parent=None): super(BotTab, self).__init__(parent) self.parent = parent self.layout = VBoxLayout() self.buildUI() self.setLayout(self.layout) def buildUI(self): self.botTab1 = BotTab1(self.parent) self.botTab2 = BotTab2(self.parent) self.tabs = DAMGLIST(listData=[self.botTab1, self.botTab2]) self.tabNames = DAMGLIST(listData=['General', 'Debug']) for layout in self.tabs: # layout.signals.connect('executing', self.signals.executing) # layout.signals.connect('regisLayout', self.signals.regisLayout) # layout.signals.connect('openBrowser', self.signals.openBrowser) # layout.signals.connect('setSetting', self.signals.setSetting) # layout.signals.connect('showLayout', self.signals.showLayout) # layout.settings._settingEnable = True self.addTab(layout, AppIcon(32, self.tabNames[self.tabs.index(layout)]), self.tabNames[self.tabs.index(layout)]) self.setTabIcon( self.tabs.index(layout), AppIcon(32, self.tabNames[self.tabs.index(layout)]))
def checkSignalRepeat(self, old, data): new = [i for i in data] if self.print_checkRepeat: print(new, old) if len(new) == 0: repeat = False elif len(new) == len(old): repeat = True for i in range(len(new)): if not new[i] == old[i]: repeat = False break else: repeat = False old = DAMGLIST() old.appendList(new) return old, repeat # ------------------------------------------------------------------------------------------------------------- # Created by panda on 25/10/2019 - 6:59 AM # © 2017 - 2018 DAMGteam. All rights reserved
def buildUI(self): self.tab1 = TopTab1.TopTab1(self.buttonManager, self.parent) self.tab2 = TopTab2.TopTab2(self.buttonManager, self.parent) self.tab3 = TopTap3.TopTap3(self.buttonManager, self.parent) self.tabs = DAMGLIST(listData=[self.tab1, self.tab2, self.tab3]) self.tabNames = DAMGLIST(listData=['Common', 'User', 'Cmd']) for tab in self.tabs: # tab.signals.connect('executing', self.signals.executing) # tab.signals.connect('regisLayout', self.signals.regisLayout) # tab.signals.connect('openBrowser', self.signals.openBrowser) # tab.signals.connect('setSetting', self.signals.setSetting) # tab.signals.connect('showLayout', self.signals.showLayout) # tab.settings._settingEnable = True if self.mode == 'Offline': if tab.key == 'TopTab2': pass else: self.addTab(tab, self.tabNames[self.tabs.index(tab)]) self.setTabIcon( self.tabs.index(tab), AppIcon(32, self.tabNames[self.tabs.index(tab)])) else: self.addTab(tab, self.tabNames[self.tabs.index(tab)]) self.setTabIcon( self.tabs.index(tab), AppIcon(32, self.tabNames[self.tabs.index(tab)])) self.signals.updateAvatar.connect(self.tab2.update_avatar)
class InspectLayout(DAMG): key = 'InspectLayout' layoutTypes = DAMGLIST() layoutKeys = DAMGLIST() def __init__(self, parent=None): super(InspectLayout, self).__init__(parent) self.layoutTypes.appendList(layoutTypes) def doInspection(self, layout): self.layoutTypes.append(layout.Type) self.layoutKeys.append(layout.key) return layout def checkType(self, layout): if not self.haveType(layout): try: layout.show() except AttributeError: layoutType = 'Object' else: layoutType = 'UI' layout.__setattr__('Type', layoutType) return self.checkKey(layout) def checkKey(self, layout): if not self.haveKey(layout): key = layout.__class__.__name__ layout.__setattr__('key', key) return layout def haveType(self, layout): try: layout.Type except AttributeError: return False else: return True def haveKey(self, layout): try: layout.key except KeyError: return False else: return True
class ThreadManager(DAMGTHREADPOOL): tasks = DAMGLIST() def __init__(self): super(ThreadManager, self).__init__() self.counter = Counting() def startCounting(self): self.counter.begin() def stopCounting(self): self.counter.finish() def serviceThread(self): thread = BackgroundService() self.threads.append(thread) return thread def setCountLimited(self, val): return self.counter.setCountLimited(val) def setPrintCounter(self, bool): return self.counter.setPrintCounter(bool) def isCounting(self): return self.counter.isCounting # ------------------------------------------------------------------------------------------------------------- # Created by panda on 20/10/2019 - 6:23 PM # © 2017 - 2018 DAMGteam. All rights reserved
def buildUI(self): self.botTab1 = BotTab1(self.parent) self.botTab2 = BotTab2(self.parent) self.tabs = DAMGLIST(listData=[self.botTab1, self.botTab2]) self.tabNames = DAMGLIST(listData=['General', 'Debug']) for layout in self.tabs: # layout.signals.connect('executing', self.signals.executing) # layout.signals.connect('regisLayout', self.signals.regisLayout) # layout.signals.connect('openBrowser', self.signals.openBrowser) # layout.signals.connect('setSetting', self.signals.setSetting) # layout.signals.connect('showLayout', self.signals.showLayout) # layout.settings._settingEnable = True self.addTab(layout, AppIcon(32, self.tabNames[self.tabs.index(layout)]), self.tabNames[self.tabs.index(layout)]) self.setTabIcon( self.tabs.index(layout), AppIcon(32, self.tabNames[self.tabs.index(layout)]))
class TopTab(TabWidget): key = 'TopTab' def __init__(self, buttonManager, parent=None): super(TopTab, self).__init__(parent) self.parent = parent self.layout = VBoxLayout() self.buttonManager = buttonManager self.mode = self.parent.mode self.buildUI() self.setLayout(self.layout) def buildUI(self): self.tab1 = TopTab1.TopTab1(self.buttonManager, self.parent) self.tab2 = TopTab2.TopTab2(self.buttonManager, self.parent) self.tab3 = TopTap3.TopTap3(self.buttonManager, self.parent) self.tabs = DAMGLIST(listData=[self.tab1, self.tab2, self.tab3]) self.tabNames = DAMGLIST(listData=['Common', 'User', 'Cmd']) for tab in self.tabs: # tab.signals.connect('executing', self.signals.executing) # tab.signals.connect('regisLayout', self.signals.regisLayout) # tab.signals.connect('openBrowser', self.signals.openBrowser) # tab.signals.connect('setSetting', self.signals.setSetting) # tab.signals.connect('showLayout', self.signals.showLayout) # tab.settings._settingEnable = True if self.mode == 'Offline': if tab.key == 'TopTab2': pass else: self.addTab(tab, self.tabNames[self.tabs.index(tab)]) self.setTabIcon( self.tabs.index(tab), AppIcon(32, self.tabNames[self.tabs.index(tab)])) else: self.addTab(tab, self.tabNames[self.tabs.index(tab)]) self.setTabIcon( self.tabs.index(tab), AppIcon(32, self.tabNames[self.tabs.index(tab)])) self.signals.updateAvatar.connect(self.tab2.update_avatar) def resizeEvent(self, event): w = self.width() h = self.height() for tab in self.tabs: tab.resize(w - 4, h - 4)
class RegistryLayout(DAMGDICT): awaitingSlots = DAMGLIST() layout_names = DAMGLIST() layout_ids = DAMGLIST() layout_datetimes = DAMGLIST() layout_keys = DAMGLIST() def __init__(self): super(RegistryLayout, self).__init__(self) self.inspect = InspectLayout(self) def regisLayout(self, layout): ui = self.inspect.doInspection(layout) key = ui.key if self.isLayout(ui): if self.isAwaitingSlot(ui): self.awaitingSlots.remove(key) self.doRegister(ui) else: if not self.isRegistered(ui): self.doRegister(ui) else: print("Already registered: {0}".format(key)) return False def isAwaitingSlot(self, layout): key = layout.key if key in self.awaitingSlots: return True else: return False def doRegister(self, layout): key = layout.key self.layout_names.append(layout.name) self.layout_ids.append(id(layout)) self.layout_datetimes.append( str( datetime.datetime.fromtimestamp( time.time()).strftime('%H:%M:%S|%d.%m.%Y'))) self.layout_keys.append(layout.key) # print("Registing layout: {0} : {1}".format(layout.key, layout)) self[key] = layout return True def deRegister(self, layout): key = layout.key index = self.layout_names.index(layout.name) if self.isRegistered(layout): self.awaitingSlots.append(key) try: del self[key] except KeyError: self.pop(key, None) self.layout_names.remove(self.layout_names[index]) self.layout_ids.remove(self.layout_ids[index]) self.layout_datetimes.remove(self.layout_datetimes[index]) return True else: return False def isRegistered(self, layout): key = layout.key if key in self.keys(): return True else: return False def isLayout(self, layout): if layout.Type in self.inspect.layoutTypes: return True else: return False # ------------------------------------------------------------------------------------------------------------- # Created by panda on 8/11/2019 - 4:18 PM # © 2017 - 2018 DAMGteam. All rights reserved
class BodyCheckBoxes(GridLayout): key = 'BodyCheckBoxes' notificationCBs = DAMGLIST() checkboxes = DAMGDICT() def __init__(self, parent=None): super(BodyCheckBoxes, self).__init__(parent) self.parent = parent self.la = 0 self.buildBodyCheckBoxes() cbs = [self.notificationCBs, [self.bodyCB]] for i in range(len(cbs)): if i == 0: prefix = 'Notification' else: prefix = 'Body' for cb in cbs[i]: cb.key = '{0}_{1}_CheckBox_{2}'.format(self.parent.key, prefix, cb.text()) cb._name = '{0} {1} Check Box: {2}'.format(self.parent.key, prefix, cb.text()) cb.settings._settingEnable = True state = cb.getValue('checkState') if state is None: state = True cb.setValue('checkState', state) cb.setChecked(str2bool(state)) self.checkboxes.add(cb.key, cb) def buildBodyCheckBoxes(self): self.buildNotificationCheckBoxes() self.bodyCB = CheckBox('Body') self.bodyCB.stateChanged.connect(self.bodyStateChanged) ntl = self.la bdl = ntl + 1 self.addWidget(Label({'txt': 'Notification'}), ntl, 0, 1, 1) self.addWidget(self.allNotifiCB, ntl, 1, 1, 1) self.addWidget(self.cpuCB, ntl, 2, 1, 1) self.addWidget(self.ramCB, ntl, 3, 1, 1) self.addWidget(self.gpuCB, ntl, 4, 1, 1) self.addWidget(self.diskCB, ntl, 5, 1, 1) self.addWidget(self.timeCB, ntl, 6, 1, 1) self.addWidget(self.dateCB, ntl, 7, 1, 1) self.addWidget(Label({'txt': 'Body'}), bdl, 0, 1, 1) self.addWidget(self.bodyCB, bdl, 1, 1, 1) self.la = bdl + 1 return self.la def buildNotificationCheckBoxes(self): self.cpuCB = CheckBox('cpu') self.ramCB = CheckBox('ram') self.gpuCB = CheckBox('gpu') self.diskCB = CheckBox('disk') self.timeCB = CheckBox('clock') self.dateCB = CheckBox('date') self.allNotifiCB = CheckBox("All: ") self.allNotifiCB.stateChanged.connect(self.allNotifiStateChanged) for cb in [self.cpuCB, self.ramCB, self.gpuCB, self.diskCB, self.timeCB, self.dateCB, self.allNotifiCB]: self.notificationCBs.append(cb) def allNotifiStateChanged(self, bool): for cb in self.notificationCBs: cb.setChecked(bool) def bodyStateChanged(self, bool): self.allNotifiStateChanged(bool)
class LocalDatabase(DAMG): key = 'LocalDatabase' _dbPath = DB_PTH conn = lite.connect(_dbPath) conn.text_factory = str cur = conn.cursor() tableNames = DAMGLIST() tables = DAMGDICT() db_types = DB_ATTRIBUTE_TYPE def __init__(self): super(LocalDatabase, self).__init__(self) self.date = DAMGDATE() self.time = DAMGTIMER() self.update() def update(self): self.tableNames = self.tableList() for table in self.tableNames: columnLst = self.columnList(table) self.tables.add(table, columnLst) self.tables.update() return self.tables def remove_data(self, tableName): self.cur.execute("SELECT * FROM {0}".format(tableName)) self.cur.fetchall() self.cur.execute("DELETE FROM {0}".format(tableName)) self.conn.commit() return def timelog(self, details): self.username, token, cookie, remember = self.query_table("curUser") time = self.time.currentTime() date = self.date.currentDate() self.cur.execute( "INSERT INTO timelog (username, time, date, details) VALUES (?,?,?,?)", (self.username, time, date, details)) self.conn.commit() return def update_table(self, tableName, values): columns = self.columnList(tableName) prefix = "INSERT INTO {0}".format(tableName) midfix = "VALUES" cmd = "" vcmd = "" for i in range(len(columns)): cmd += columns[i] + ", " vcmd += values[i] + ", " command = "{0} ({1}) {2} ({3})".format(prefix, cmd, midfix, vcmd) self.cur.execute("{0}".format(command)) self.conn.commit() return def columnList(self, tableName): result = self.cur.execute( "PRAGMA table_info({0})".format(tableName)).fetchall() columnLst = list(zip(*result))[1] return columnLst def tableList(self): result = self.cur.execute( "SELECT name FROM sqlite_master WHERE type='table';").fetchall() if result == []: table_names = result else: table_names = sorted(list(zip(*result))[0]) return table_names def query_table(self, tableName="curUser"): self.cur.execute("SELECT * FROM {0}".format(tableName)) data = self.cur.fetchall() return list(data[0]) def generate_command(self, tableDetails): columnLst = [c for c in tableDetails.keys()] cmd = "" for i in range(len(columnLst)): column_name = columnLst[i] attribute_key = tableDetails[columnLst[i]] column_attribute = self.db_types[attribute_key] cmd += "{0} {1}".format(column_name, column_attribute) cmd = cmd[:-2] return cmd def create_table(self, tableName, tableDetails): cmd = self.generate_command(tableDetails) self.cur.execute("CREATE TABLE IF NOT EXISTS `{0}` ({1})".format( tableName, cmd)) self.conn.commit() self.update() return def remove_table(self, tableName): self.cur.execute('DROP TABLE {0}'.format(tableName)) self.conn.commit() self.update() return def create_foreign(self, id_name, table_name): value = 'INTERGER, FOREIGN KEY ({0}) REFERENCES {1} ({0}), '.format( id_name, table_name) return value # ------------------------------------------------------------------------------------------------------------- # Created by panda on 3/06/2018 - 3:58 AM # Pipeline manager - DAMGteam
class TopTap3(Widget): key = 'TerminalLayout' _name = 'TerminalLayout' commands = DAMGLIST() shotcuts = DAMGLIST() tracker = 0 _cwd = os.getcwd().replace('\\', '/') _user = getpass.getuser() _host = socket.gethostname() def __init__(self, buttonManager, parent=None): super(TopTap3, self).__init__(parent) self.buttonManager = buttonManager self.parent = parent self.layout = VBoxLayout() self.buildUI() # QApplication.setCursorFlashTime(1000) self.setLayout(self.layout) self.setStyleSheet(mystylesheet(self)) def buildUI(self): self.process = Process(self.dataReady, self.onError, self.onOutput, self.isFinished, self) self.cmdField = PlainTextEdit({ 'lwm': QPlainTextEdit.NoWrap, 'sfh': 25, 'vsbp': SCROLLBAROFF, 'adr': True }) self.textWindow = PlainTextEdit({'rol': True}, self) self.cursor = self.cmdField.textCursor() self.copySelectedTextAction = ShortCut('Copy', 'Copy', 'Shift+Ctrl+c', self.copyText, self) self.cancelAction = ShortCut('Cancel', 'Cancel', 'Ctrl+c', self.killProcess, self) self.pasteTextAction = ShortCut('Paste', 'Paste', 'Shift+Ctrl+v', self.pasteText, self) self.textWindow.addActions( [self.cancelAction, self.copySelectedTextAction]) self.cmdField.addAction(self.pasteTextAction) self.cmdField.installEventFilter(self) self.cursorEnd() sysinfo = QSysInfo() myMachine = "CPU Architecture: {0}***{1}***{2}***{3}".format( sysinfo.currentCpuArchitecture(), sysinfo.prettyProductName(), sysinfo.kernelType(), sysinfo.kernelVersion()) self.statusBar = StatusBar(self) self.statusBar.showMessage(myMachine, 0) self.layout.addWidget(self.textWindow) self.layout.addWidget(self.cmdField) self.layout.addWidget(self.statusBar) def getUsername(self): return "{0}@{1}:{2}$".format(self._user, self._host, self._cwd) def cursorEnd(self): self.cmdField.setPlainText(self.getUsername()) self.cursor.movePosition(11, 0) self.cmdField.setTextCursor(self.cursor) self.cmdField.setFocus() def eventFilter(self, source, event): if source == self.cmdField: if (event.type() == QEvent.DragEnter): event.accept() return True elif (event.type() == QEvent.Drop): # print('Drop') self.setDropEvent(event) return True elif (event.type() == QEvent.KeyPress): cursor = self.cmdField.textCursor() # print('key press:', (event.key(), event.text())) if event.key() == Qt.Key_Backspace: if cursor.positionInBlock() <= len(self.getUsername()): return True else: return False elif event.key() == Qt.Key_Return: self.run() return True elif event.key() == Qt.Key_Left: if cursor.positionInBlock() <= len(self.getUsername()): return True else: return False elif event.key() == Qt.Key_Delete: if cursor.positionInBlock() <= len(self.getUsername()) - 1: return True else: return False elif event.modifiers() == Qt.ControlModifier and event.key( ) == Qt.Key_C: self.killProcess() return True elif event.key() == Qt.Key_Up: try: if self.tracker != 0: cursor.select(QTextCursor.BlockUnderCursor) cursor.removeSelectedText() self.cmdField.appendPlainText(self.getUsername()) self.cmdField.insertPlainText( self.commands[self.tracker]) self.tracker -= 1 except IndexError: self.tracker = 0 return True elif event.key() == Qt.Key_Down: try: if self.tracker != 0: cursor.select(QTextCursor.BlockUnderCursor) cursor.removeSelectedText() self.cmdField.appendPlainText(self.getUsername()) self.cmdField.insertPlainText( self.commands[self.tracker]) self.tracker += 1 except IndexError: self.tracker = 0 return True else: return False else: return False else: return False def copyText(self): self.textWindow.copy() def pasteText(self): self.cmdField.paste() def killProcess(self): # print("cancelled") self.process.kill() self.textWindow.appendPlainText("cancelled") self.cursorEnd() def setDropEvent(self, event): self.cmdField.setFocus() if event.mimeData().hasUrls(): f = str(event.mimeData().urls()[0].toLocalFile()) # print("is file:", f) if " " in f: self.cmdField.insertPlainText("'{}'".format(f)) else: self.cmdField.insertPlainText(f) event.accept() elif event.mimeData().hasText(): ft = event.mimeData().text() # print("is text:", ft) if " " in ft: self.cmdField.insertPlainText("'{}'".format(ft)) else: self.cmdField.insertPlainText(ft) else: event.ignore() def run(self): self.textWindow.setFocus() self.textWindow.appendPlainText(self.cmdField.toPlainText()) cli = shlex.split(self.cmdField.toPlainText().replace( self.getUsername(), '').replace("'", '"'), posix=False) cmd = str(cli[0]) ### is the executable if cmd == "exit": quit() elif 'cd' in cmd: if len(cli) == 1: command_argument = cmd.split('cd')[1] else: command_argument = cli[1] if cmd == 'cd' or cmd == 'cd.': if len(cli) == 1: pass else: if os.path.isdir(command_argument): # print('{0} is dir'.format(command_argument)) check = True for char in command_argument: if not char == '.': check = False break if not check: pth = os.path.join(self._cwd, command_argument) if os.path.exists(pth): self._cwd = pth else: self.command_not_found(cmd) else: # print('{0} is not dir'.format(command_argument)) pass else: if os.path.exists(command_argument): # print('{0} is path'.format(command_argument)) self._cwd = command_argument else: # print('{0} is path but not exists'.format(command_argument)) pth = os.path.join(self._cwd, command_argument) # print(pth, self._cwd) if os.path.exists(pth): self._cwd = pth else: self.command_not_found(cmd) else: if len(command_argument) <= 1: if command_argument == '/' or command_argument == '\\': self._cwd = os.path.splitdrive(self._cwd)[0] + '/' else: self.command_not_found() elif len(command_argument) >= 2: if command_argument[0:2] == '..': check = True for char in command_argument: if not char == '.': check = False if check: for i in range(len(command_argument) - 1): self._cwd = os.path.dirname(self._cwd) else: self.command_not_found(cmd) else: self.command_not_found(cmd) else: self.command_not_found(cmd) self.updateWorkingDirectory(self._cwd) else: if (QStandardPaths.findExecutable(cmd)): self.commands.append(self.cmdField.toPlainText().replace( self.getUsername(), "")) # print("command", cmd, "found") t = " ".join(cli) if self.process.state() != 2: self.process.waitForStarted() self.process.waitForFinished() if "|" in t or ">" in t or "<" in t: # print("special characters") self.process.start('sh -c "' + cmd + ' ' + t + '"') # print("running", ('sh -c "' + cmd + ' ' + t + '"')) else: self.process.start(cmd + " " + t) # print("running", (cmd + " " + t)) else: self.command_not_found(cmd) def command_not_found(self, cmd): self.textWindow.appendPlainText("command not found: {0}".format(cmd)) self.cursorEnd() def dataReady(self): try: out = str(self.process.readAll(), encoding='utf8').rstrip() except TypeError: out = str(self.process.readAll()).rstrip() self.textWindow.moveCursor(self.cursor.Start) ### changed self.textWindow.appendPlainText(out) def onError(self): self.error = self.process.readAllStandardError().data().decode() self.textWindow.appendPlainText(self.error.strip('\n')) self.cursorEnd() def onOutput(self): self.result = self.process.readAllStandardOutput().data().decode() self.textWindow.appendPlainText(self.result.strip('\n')) self.cursorEnd() self.state = self.process.state() # print(self.state) def isFinished(self): # print("finished") self.cmdField.setPlainText(self.getUsername()) self.cursorEnd() def updateWorkingDirectory(self, pth=os.getcwd()): # print('Working Dir: {0}'.format(pth)) fixName = os.path.basename(pth) fixPath = os.path.dirname(pth) self._cwd = os.path.join(fixPath, fixName).replace('\\', '/') self.process.setWorkingDirectory(self._cwd) self.cursorEnd()
class ActionManager(DAMGDICT): key = 'ActionManager' _name = 'ActionManager' appInfo = data_handler(filePath=mainConfig) actionKeys = DAMGLIST() showLayoutKeys = DAMGLIST() showRestoreKeys = DAMGLIST() showMaximizeKeys = DAMGLIST() showMinimizeKeys = DAMGLIST() startFileKeys = DAMGLIST() openBrowserKeys = DAMGLIST() executingKeys = DAMGLIST() orgActions = ['NewOrganisation', 'EditOrganisation'] teamActions = ['NewTeam', 'EditTeam'] prjActions = ['NewProject', 'EditProject'] appActions = ['SettingUI', 'Configuration', 'Preferences', 'Exit'] goActions = ['ConfigFolder', 'IconFolder', 'SettingFolder', 'AppFolder'] officeActions = ['TextEditor', 'NoteReminder'] + CONFIG_OFFICE toolsActions = CONFIG_TOOLS + ['CleanPyc', 'ReConfig', 'Debug'] devActions = CONFIG_DEV libActions = ['Alpha', 'HDRI', 'Texture'] helpActions = [ 'PLM wiki', 'About', 'CodeOfConduct', 'Contributing', 'Credit', 'Reference', 'Version', 'Feedback', 'ContactUs', ] tdActions = CONFIG_TDS artActions = CONFIG_ART texActions = CONFIG_TEX postActions = CONFIG_POST vfxActions = CONFIG_VFX extraActions = CONFIG_EXTRA sysTrayActions = CONFIG_SYSTRAY def __init__(self, parent=None): super(ActionManager, self).__init__(self) self.parent = parent self.showLayoutKeys.appendList(SHOWLAYOUT_KEY) self.startFileKeys.appendList(START_FILE_KEY) self.executingKeys.appendList(EXECUTING_KEY) self.openBrowserKeys.appendList(OPEN_BROWSER_KEY) self.showRestoreKeys.appendList(RESTORE_KEY) self.showMaximizeKeys.appendList(SHOWMAX_KEY) self.showMinimizeKeys.appendList(SHOWMIN_KEY) self.actionKeys = self.showLayoutKeys + self.startFileKeys + self.executingKeys + self.officeActions + \ self.showRestoreKeys + self.showMaximizeKeys + self.showMinimizeKeys def actionConfigError(self, key): return print( 'ActionKeyConfigError: This key is not registered: {0}'.format( key)) def actionRegisterError(self, key): return print( 'ActionRegisterError: This action is already registered: {0}'. format(key)) def extraToolActions(self, parent): return self.createActions(self.extraActions, parent) def tdToolBarActions(self, parent): return self.createActions(self.tdActions, parent) def artToolBarActions(self, parent): return self.createActions(self.artActions, parent) def texToolBarActions(self, parent): return self.createActions(self.texActions, parent) def postToolBarActions(self, parent): return self.createActions(self.postActions, parent) def vfxToolBarActions(self, parent): return self.createActions(self.vfxActions, parent) def sysTrayMenuActions(self, parent): return self.createActions(self.sysTrayActions, parent) def appMenuActions(self, parent): return self.createActions(self.appActions, parent) def orgMenuActions(self, parent): return self.createActions(self.orgActions, parent) def teamMenuActions(self, parent): return self.createActions(self.teamActions, parent) def projectMenuActions(self, parent): return self.createActions(self.prjActions, parent) def goMenuActions(self, parent): return self.createActions(self.goActions, parent) def officeMenuActions(self, parent): return self.createActions(self.officeActions, parent) def toolsMenuActions(self, parent): return self.createActions(self.toolsActions, parent) def devMenuActions(self, parent): return self.createActions(self.devActions, parent) def libMenuActions(self, parent): return self.createActions(self.libActions, parent) def helpMenuActions(self, parent): return self.createActions(self.helpActions, parent) def createActions(self, keys, parent): actions = [] for key in keys: if key in self.appInfo.keys(): if is_string(key): action = self.createAction(key, parent) actions.append(action) elif is_action(key): action = key action.setParent(parent) self.register(action) actions.append(action) else: print( "DATATYPEERROR: Could not add action: {0}".format(key)) return actions def createAction(self, key, parent): if key in self.showLayoutKeys: # print('{0} is set to {1} action'.format(key, 'showlayout')) return self.showLayoutAction(key, parent) elif key in self.startFileKeys: # print('{0} is set to {1} action'.format(key, 'startfile')) return self.startFileAction(key, parent) elif key in self.executingKeys: # print('{0} is set to {1} action'.format(key, 'executing')) return self.executingAction(key, parent) elif key in self.openBrowserKeys: # print('{0} is set to {1} action'.format(key, 'openBrowser')) return self.openBrowserAction(key, parent) elif key in self.showMinimizeKeys: # print('{0} is set to {1} action'.format(key, 'showminimized')) return self.showMinAction(key, parent) elif key in self.showMaximizeKeys: # print('{0} is set to {1} action'.format(key, 'showmaximized')) return self.showMaxAction(key, parent) elif key in self.showRestoreKeys: # print('{0} is set to {1} action'.format(key, 'showrestore')) return self.showRestoreAction(key, parent) else: return self.actionConfigError(key) def showLayoutAction(self, key, parent): if key in self.appInfo.keys(): action = Action( { 'icon': self.appInfo[key][1], 'txt': '&{0}'.format(key), 'stt': self.appInfo[key][0], 'trg': partial(parent.signals.emit, 'showLayout', key, 'show'), }, parent) action.key = '{0}_{1}_Action'.format(parent.key, key) action._name = action.key if action.key in self.actionKeys: return self[action.key] else: action._name = '{0} Action'.format(key) action.Type = 'DAMGShowLayoutAction' self.register(action) return action else: return self.actionConfigError(key) def showRestoreAction(self, key, parent): if key in self.appInfo.keys(): action = Action( { 'icon': self.appInfo[key][1], 'txt': '&{0}'.format(key), 'stt': self.appInfo[key][0], 'trg': partial(parent.signals.emit, 'showLayout', self.appInfo[key][2], 'showRestore'), }, parent) action.key = '{0}_{1}_Action'.format(parent.key, key) action._name = action.key if action.key in self.actionKeys: return self[action.key] else: action._name = '{0} Action'.format(key) action.Type = 'DAMGShowNormalAction' self.register(action) return action else: return self.actionConfigError(key) def showMaxAction(self, key, parent): if key in self.appInfo.keys(): action = Action( { 'icon': self.appInfo[key][1], 'txt': '&{0}'.format(key), 'stt': self.appInfo[key][0], 'trg': partial(parent.signals.emit, 'showLayout', self.appInfo[key][2], 'showMax'), }, parent) action.key = '{0}_{1}_Action'.format(parent.key, key) action._name = action.key if action.key in self.actionKeys: return self[action.key] else: action._name = '{0} Action'.format(key) action.Type = 'DAMGShowMaximizeAction' self.register(action) return action else: return self.actionConfigError(key) def showMinAction(self, key, parent): if key in self.appInfo.keys(): action = Action( { 'icon': self.appInfo[key][1], 'txt': '&{0}'.format(key), 'stt': self.appInfo[key][0], 'trg': partial(parent.signals.emit, 'showLayout', self.appInfo[key][2], 'showMin'), }, parent) action.key = '{0}_{1}_Action'.format(parent.key, key) action._name = action.key if action.key in self.actionKeys: return self[action.key] else: action._name = '{0} Action'.format(key) action.Type = 'DAMGShowMinimizeAction' self.register(action) return action else: return self.actionConfigError(key) def startFileAction(self, key, parent): if key in self.appInfo.keys(): # print('create start file action: {} {}'.format(key, self.appInfo[key][2])) action = Action( { 'icon': self.appInfo[key][1], 'txt': '&{0}'.format(key), 'stt': self.appInfo[key][0], 'trg': partial(os.startfile, self.appInfo[key][2]) }, parent) action.key = '{0}_{1}_Action'.format(parent.key, key) action._name = action.key if action.key in self.actionKeys: return self[action.key] else: action._name = '{0} Action'.format(key) action.Type = 'DAMGStartFileAction' self.register(action) return action else: return self.actionConfigError(key) def executingAction(self, key, parent): if key in self.appInfo.keys(): action = Action( { 'icon': self.appInfo[key][1], 'txt': '&{0}'.format(key), 'stt': self.appInfo[key][0], 'trg': partial(parent.signals.emit, 'executing', self.appInfo[key][2]), }, parent) action.key = '{0}_{1}_Action'.format(parent.key, key) action._name = '{0} Action'.format(key) if action.key in self.actionKeys: return self[action.key] else: action.Type = 'DAMGExecutingAction' self.register(action) return action else: return self.actionConfigError(key) def openBrowserAction(self, key, parent): if key in self.appInfo.keys(): action = Action( { 'icon': self.appInfo[key][1], 'txt': '&{0}'.format(key), 'stt': self.appInfo[key][0], 'trg': partial(parent.signals.emit, 'openBrowser', self.appInfo[key][2]), }, parent) action.key = '{0}_{1}_Action'.format(parent.key, key) action._name = action.key if action.key in self.actionKeys: return self[action.key] else: action._name = '{0} Action'.format(key) action.Type = 'DAMGOpenBrowserAction' self.register(action) return action else: return self.actionConfigError(key) def register(self, action): # print('register action: {}'.format(action)) if not action.key in self.actionKeys: self.actionKeys.append(action.key) self[action.key] = action else: return self.actionRegisterError(action.key) def actions(self): return self.values() # ------------------------------------------------------------------------------------------------------------- # Created by panda on 3/11/2019 - 5:26 PM # © 2017 - 2018 DAMGteam. All rights reserved
class ButtonManager(DAMGDICT): key = 'ButtonManager' _name = 'ButtonManager' mainInfo = data_handler(filePath=mainConfig) buttonKeys = DAMGLIST() showLayoutKeys = DAMGLIST() showRestoreKeys = DAMGLIST() showMaximizeKeys = DAMGLIST() showMinimizeKeys = DAMGLIST() startFileKeys = DAMGLIST() openBrowserKeys = DAMGLIST() executingKeys = DAMGLIST() tagKeys = DAMGLIST() tags = dict( pythonTag="https://docs.anaconda.com/anaconda/reference/release-notes/", licenceTag="https://github.com/vtta2008/damgteam/blob/master/LICENCE", versionTag= "https://github.com/vtta2008/damgteam/blob/master/appData/documentations/version.rst" ) tagButtons = ['pythonTag', 'licenceTag', 'versionTag'] orgButtons = ['NewOrganisation', 'EditOrganisation'] taskButtons = ['NewTask', 'EditTask'] teamButtons = ['NewTeam', 'EditTeam'] prjButtons = ['NewProject', 'EditProject'] userButtons = ['UserSetting', 'SignUp', 'SwitchAccount', 'SignOut'] checkedKeys = teamButtons + prjButtons + userButtons + tagButtons + taskButtons def __init__(self, parent=None): super(ButtonManager, self).__init__(self) self.parent = parent self.showLayoutKeys.appendList(SHOWLAYOUT_KEY) self.startFileKeys.appendList(START_FILE_KEY) self.executingKeys.appendList(EXECUTING_KEY) self.openBrowserKeys.appendList(OPEN_BROWSER_KEY) self.showRestoreKeys.appendList(RESTORE_KEY) self.showMaximizeKeys.appendList(SHOWMAX_KEY) self.showMinimizeKeys.appendList(SHOWMIN_KEY) self.tagKeys.appendList(self.tagButtons) self.buttonKeys = self.showLayoutKeys + self.startFileKeys + self.executingKeys + self.showRestoreKeys + \ self.showMaximizeKeys + self.showMinimizeKeys + self.tagKeys def buttonConfigError(self, key): return print( 'ButtonKeyConfigError: This key is not registered: {0}'.format( key)) def buttonRegisterError(self, key): return print( 'ButtonRegisterError: This action is already registered: {0}'. format(key)) def taskButtonsGroupBox(self, parent): return self.createButtons(self.taskButtons, parent) def projectButtonsGroupBox(self, parent): return self.createButtons(self.prjButtons, parent) def tagButtonsFooterWidget(self, parent): return self.createButtons(self.tagButtons, parent) def teamButtonsGroupBox(self, parent): return self.createButtons(self.teamButtons, parent) def userButtonGroupBox(self, parent): return self.createButtons(self.userButtons, parent) def createButtons(self, keys, parent): buttons = [] for key in keys: if key in self.mainInfo.keys(): if not key in self.checkedKeys: print('key: {0} is in mainInfo: {1}'.format( key, self.mainInfo[key])) if is_string(key): button = self.createButton(key, parent) buttons.append(button) elif is_button(key): button = key button.setParent(parent) self.register(Button) buttons.append(Button) else: print( "DataTypeError: Could not add Button: {0}".format(key)) else: print('key: {0} NOT in mainInfo: {1}'.format( key, self.mainInfo[key])) return buttons def createButton(self, key, parent): if key in self.showLayoutKeys: return self.showLayoutButton(key, parent) elif key in self.startFileKeys: return self.showLayoutButton(key, parent) elif key in self.executingKeys: return self.executingButton(key, parent) elif key in self.openBrowserKeys: return self.openBrowserButton(key, parent) elif key in self.showMinimizeKeys: return self.showMinButton(key, parent) elif key in self.showMaximizeKeys: return self.showMaxButton(key, parent) elif key in self.showRestoreKeys: return self.showRestoreButton(key, parent) elif key in self.tagKeys: return self.tagOpenBrowserButton(key, parent) else: # print('key come here: {}'.format(key)) return self.buttonConfigError(key) def showLayoutButton(self, key, parent): if key in self.mainInfo.keys(): if key in ['SignIn', 'SignOut', 'SignUp', 'SwitchAccount']: show = key else: show = 'show' button = Button({ 'txt': self.mainInfo[key][0], 'stt': self.mainInfo[key][2], 'cl': partial(parent.signals.emit, 'showLayout', key, show), }) button.key = '{0}_{1}_Button'.format(parent.key, key) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button._name = '{0} Button'.format(key) button.Type = 'DAMGShowLayoutButton' self.register(button) return button else: return self.buttonConfigError(key) def showRestoreButton(self, key, parent): if key in self.mainInfo.keys(): button = Button({ 'txt': self.mainInfo[key][0], 'stt': self.mainInfo[key][2], 'cl': partial(parent.signals.emit, 'showLayout', key, 'showRestore'), }) button.key = '{0}_{1}_Button'.format(parent.key, key) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button._name = '{0} Button'.format(key) button.Type = 'DAMGShowNormalButton' self.register(button) return button else: return self.buttonConfigError(key) def showMaxButton(self, key, parent): if key in self.mainInfo.keys(): button = Button({ 'txt': self.mainInfo[key][0], 'stt': self.mainInfo[key][2], 'cl': partial(parent.signals.emit, 'showLayout', key, 'showMaximized'), }) button.key = '{0}_{1}_Button'.format(parent.key, key) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button._name = '{0} Button'.format(key) button.Type = 'DAMGShowMaximizeButton' self.register(button) return button else: return self.buttonConfigError(key) def showMinButton(self, key, parent): if key in self.mainInfo.keys(): button = Button({ 'txt': self.mainInfo[key][0], 'stt': self.mainInfo[key][2], 'cl': partial(parent.signals.emit, 'showLayout', key, 'showMinimized'), }) button.key = '{0}_{1}_Button'.format(parent.key, key) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button._name = '{0} Button'.format(key) button.Type = 'DAMGShowMinimizeButton' self.register(button) return button else: return self.buttonConfigError(key) def startFileButton(self, key, parent): if key in self.mainInfo.keys(): button = Button({ 'txt': self.mainInfo[key][0], 'stt': self.mainInfo[key][2], 'cl': partial(os.startfile, key) }) button.key = '{0}_{1}_Button'.format(parent.key, key) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button._name = '{0} Button'.format(key) button.Type = 'DAMGStartFileButton' self.register(button) return button else: return self.buttonConfigError(key) def executingButton(self, key, parent): if key in self.mainInfo.keys(): button = Button({ 'txt': self.mainInfo[key][0], 'stt': self.mainInfo[key][2], 'cl': partial(parent.signals.emit, 'executing', key), }) button.key = '{0}_{1}_Button'.format(parent.key, key) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button.Type = 'DAMGExecutingButton' self.register(button) return button else: return self.buttonConfigError(key) def openBrowserButton(self, key, parent): if key in self.mainInfo.keys(): button = Button({ 'txt': self.mainInfo[key][0], 'stt': self.mainInfo[key][2], 'cl': partial(parent.signals.emit, 'openBrowser', key), }) button.key = '{0}_{1}_Button'.format(parent.key, key) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button._name = '{0} Button'.format(key) button.Type = 'DAMGOpenBrowserButton' self.register(button) return button else: return self.buttonConfigError(key) def iconShowLayoutButton(self, key, parent): if key in self.mainInfo.keys(): button = Button({ 'icon': key, 'tt': self.mainInfo[key][2], 'fix': BTNICONSIZE, 'ics': ICONBTNSIZE, 'cl': partial(parent.signals.emit, 'showLayout', key, 'show') }) button.key = '{0}_{1}_Button'.format(parent.key, key) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button._name = '{0} Button'.format(key) button.Type = 'DAMGOpenBrowserButton' self.register(button) return button else: return self.buttonConfigError(key) def tagOpenBrowserButton(self, tagName, parent): if tagName in self.tags.keys(): button = Button({ 'tag': tagName, 'fix': BTNTAGSIZE, 'ics': TAGBTNSIZE, 'cl': partial(parent.signals.emit, 'openBrowser', self.tags[tagName]) }) button.key = '{0}_{1}_Button'.format(parent.key, tagName) button._name = button.key if button.key in self.buttonKeys: return self[button.key] else: button._name = '{0} Button'.format(tagName) button.Type = 'DAMGOpenBrowserButton' self.register(button) return button else: return self.buttonConfigError(tagName) def register(self, button): if not button.key in self.buttonKeys: self.buttonKeys.append(button.key) self[button.key] = button else: return self.buttonRegisterError(button.key) def buttons(self): return self.values() # ------------------------------------------------------------------------------------------------------------- # Created by panda on 6/11/2019 - 10:22 AM # © 2017 - 2018 DAMGteam. All rights reserved
class GeneralSetting(GridLayout): key = 'GeneralSetting' statusCBs = DAMGLIST() notificationCBs = DAMGLIST() checkboxes = DAMGDICT() def __init__(self, parent=None): super(GeneralSetting, self).__init__(parent) self.parent = parent self.la = 0 self.buildUI() def buildUI(self): # self.buildHeaderCheckBoxes() self.buildBodyCheckBoxes() self.footerCB = CheckBox('Footer') self.statusBarCB = CheckBox("Status Bar") for cb in [self.statusBarCB, ]: self.statusCBs.append(cb) cbs = [self.toolBarCBs, self.menuCBs, self.connectCBs, self.notificationCBs, self.statusCBs, ] for i in range(len(cbs)): if i == 0: prefix = 'ToolBar' elif i == 1: prefix = 'Menu' elif i == 2: prefix = 'Network' elif i == 3: prefix = 'Notification' elif i == 4: prefix = 'StatusBar' else: prefix = 'NoDefine' for cb in cbs[i]: cb.key = '{0}_{1}_CheckBox_{2}'.format(self.parent.key, prefix, cb.text()) cb._name = '{0} {1} Check Box: {2}'.format(self.parent.key, prefix, cb.text()) cb.settings._settingEnable = True state = cb.getValue('checkState') if state is None: state = True cb.setValue('checkState', state) cb.setChecked(str2bool(state)) self.checkboxes.add(cb.key, cb) def buildBodyCheckBoxes(self): self.buildNotificationCheckBoxes() self.bodyCB = CheckBox('Body') self.bodyCB.stateChanged.connect(self.bodyStateChanged) ntl = self.la bdl = ntl + 1 self.addWidget(Label({'txt': 'Notification'}), ntl, 0, 1, 1) self.addWidget(self.allNotifiCB, ntl, 1, 1, 1) self.addWidget(self.cpuCB, ntl, 2, 1, 1) self.addWidget(self.ramCB, ntl, 3, 1, 1) self.addWidget(self.gpuCB, ntl, 4, 1, 1) self.addWidget(self.prjNameCB, ntl, 5, 1, 1) self.addWidget(self.dueDateCB, ntl, 6, 1, 1) self.addWidget(self.dueTimeCB, ntl, 7, 1, 1) self.addWidget(self.countdownCB, ntl, 8, 1, 1) self.addWidget(self.timeCB, ntl, 9, 1, 1) self.addWidget(self.dateCB, ntl, 10, 1, 1) self.addWidget(self.bodyCB, bdl, 0, 1, 1) self.la = bdl + 1 return self.la def buildNotificationCheckBoxes(self): self.cpuCB = CheckBox('cpu') self.ramCB = CheckBox('ram') self.gpuCB = CheckBox('gpu') self.diskCB = CheckBox('disk') self.prjNameCB = CheckBox('Project Name') self.dueDateCB = CheckBox('Due Date') self.dueTimeCB = CheckBox('Due Time') self.countdownCB = CheckBox('Time Counting') self.timeCB = CheckBox('clock') self.dateCB = CheckBox('date') self.allNotifiCB = CheckBox("All: ") self.allNotifiCB.stateChanged.connect(self.allNotifiStateChanged) for cb in [self.cpuCB, self.ramCB, self.gpuCB, self.diskCB, self.prjNameCB, self.dueDateCB, self.dueTimeCB, self.countdownCB, self.timeCB, self.dateCB, self.allNotifiCB]: self.notificationCBs.append(cb) def allNotifiStateChanged(self, bool): for cb in self.notificationCBs: cb.setChecked(bool) def bodyStateChanged(self, bool): self.allNotifiStateChanged(bool)
class Calculator(Widget): key = 'Calculator' NumDigitButtons = 10 digitButtons = DAMGLIST() def __init__(self, parent=None): super(Calculator, self).__init__(parent) self.setWindowIcon(AppIcon(32, 'Calculator')) self.setWindowTitle(self.key) self.buildUI() def buildUI(self): self.layout = QGridLayout(self) self.pendingAdditiveOperator = '' self.pendingMultiplicativeOperator = '' self.sumInMemory = 0.0 self.sumSoFar = 0.0 self.factorSoFar = 0.0 self.waitingForOperand = True self.display = LineEdit({'txt': '0'}) self.display.setReadOnly(True) self.display.setAlignment(Qt.AlignRight) for i in range(self.NumDigitButtons): self.digitButtons.append(self.createButton(str(i), self.digitClicked)) self.pointButton = self.createButton(".", self.pointClicked) self.changeSignButton = self.createButton(u"\N{PLUS-MINUS SIGN}", self.changeSignClicked) self.backspaceButton = self.createButton("Backspace", self.backspaceClicked) self.clearButton = self.createButton("Clear", self.clear) self.clearAllButton = self.createButton("Clear All", self.clearAll) self.clearMemoryButton = self.createButton("MC", self.clearMemory) self.readMemoryButton = self.createButton("MR", self.readMemory) self.setMemoryButton = self.createButton("MS", self.setMemory) self.addToMemoryButton = self.createButton("M+", self.addToMemory) self.divisionButton = self.createButton(u"\N{DIVISION SIGN}", self.multiplicativeOperatorClicked) self.timesButton = self.createButton(u"\N{MULTIPLICATION SIGN}", self.multiplicativeOperatorClicked) self.minusButton = self.createButton("-", self.additiveOperatorClicked) self.plusButton = self.createButton("+", self.additiveOperatorClicked) self.squareRootButton = self.createButton("Sqrt", self.unaryOperatorClicked) self.powerButton = self.createButton(u"x\N{SUPERSCRIPT TWO}", self.unaryOperatorClicked) self.reciprocalButton = self.createButton("1/x", self.unaryOperatorClicked) self.equalButton = self.createButton("=", self.equalClicked) self.layout.addWidget(self.display, 0,0,1,6) self.layout.addWidget(self.backspaceButton, 1,0,1,2) self.layout.addWidget(self.clearButton, 1,2,1,2) self.layout.addWidget(self.clearAllButton, 1,4,1,2) self.layout.addWidget(self.clearMemoryButton,2,0) self.layout.addWidget(self.readMemoryButton,3,0) self.layout.addWidget(self.setMemoryButton,4,0) self.layout.addWidget(self.addToMemoryButton,5,0) for i in range(1, self.NumDigitButtons): row = ((9 - i) / 3) + 2 column = ((i - 1) % 3) + 1 self.layout.addWidget(self.digitButtons[i], row, column) self.layout.addWidget(self.digitButtons[0],5,1) self.layout.addWidget(self.pointButton,5,2) self.layout.addWidget(self.changeSignButton,5,3) self.layout.addWidget(self.divisionButton,2,4) self.layout.addWidget(self.timesButton,3,4) self.layout.addWidget(self.minusButton,4,4) self.layout.addWidget(self.plusButton,5,4) self.layout.addWidget(self.squareRootButton,2,5) self.layout.addWidget(self.powerButton,3,5) self.layout.addWidget(self.reciprocalButton,4,5) self.layout.addWidget(self.equalButton,5,5) self.display.setMaxLength(15) font = self.display.font() font.setPointSize(font.pointSize() + 8) self.display.setFont(font) self.setLayout(self.layout) def digitClicked(self): clickedButton = self.sender() digitValue = int(clickedButton.text()) if self.display.text() == '0' and digitValue == 0.0: return if self.waitingForOperand: self.display.clear() self.waitingForOperand = False self.display.setText(self.display.text() + str(digitValue)) def unaryOperatorClicked(self): clickedButton = self.sender() clickedOperator = clickedButton.text() operand = float(self.display.text()) if clickedOperator == "Sqrt": if operand < 0.0: self.abortOperation() return result = math.sqrt(operand) elif clickedOperator == u"x\N{SUPERSCRIPT TWO}": result = math.pow(operand, 2.0) elif clickedOperator == "1/x": if operand == 0.0: self.abortOperation() return result = 1.0 / operand self.display.setText(str(result)) self.waitingForOperand = True def additiveOperatorClicked(self): clickedButton = self.sender() clickedOperator = clickedButton.text() operand = float(self.display.text()) if self.pendingMultiplicativeOperator: if not self.calculate(operand, self.pendingMultiplicativeOperator): self.abortOperation() return self.display.setText(str(self.factorSoFar)) operand = self.factorSoFar self.factorSoFar = 0.0 self.pendingMultiplicativeOperator = '' if self.pendingAdditiveOperator: if not self.calculate(operand, self.pendingAdditiveOperator): self.abortOperation() return self.display.setText(str(self.sumSoFar)) else: self.sumSoFar = operand self.pendingAdditiveOperator = clickedOperator self.waitingForOperand = True def multiplicativeOperatorClicked(self): clickedButton = self.sender() clickedOperator = clickedButton.text() operand = float(self.display.text()) if self.pendingMultiplicativeOperator: if not self.calculate(operand, self.pendingMultiplicativeOperator): self.abortOperation() return self.display.setText(str(self.factorSoFar)) else: self.factorSoFar = operand self.pendingMultiplicativeOperator = clickedOperator self.waitingForOperand = True def equalClicked(self): operand = float(self.display.text()) if self.pendingMultiplicativeOperator: if not self.calculate(operand, self.pendingMultiplicativeOperator): self.abortOperation() return operand = self.factorSoFar self.factorSoFar = 0.0 self.pendingMultiplicativeOperator = '' if self.pendingAdditiveOperator: if not self.calculate(operand, self.pendingAdditiveOperator): self.abortOperation() return self.pendingAdditiveOperator = '' else: self.sumSoFar = operand self.display.setText(str(self.sumSoFar)) self.sumSoFar = 0.0 self.waitingForOperand = True def pointClicked(self): if self.waitingForOperand: self.display.setText('0') if "." not in self.display.text(): self.display.setText(self.display.text() + ".") self.waitingForOperand = False def changeSignClicked(self): text = self.display.text() value = float(text) if value > 0.0: text = "-" + text elif value < 0.0: text = text[1:] self.display.setText(text) def backspaceClicked(self): if self.waitingForOperand: return text = self.display.text()[:-1] if not text: text = '0' self.waitingForOperand = True self.display.setText(text) def clear(self): # type: () -> object if self.waitingForOperand: return self.display.setText('0') self.waitingForOperand = True def clearAll(self): self.sumSoFar = 0.0 self.factorSoFar = 0.0 self.pendingAdditiveOperator = '' self.pendingMultiplicativeOperator = '' self.display.setText('0') self.waitingForOperand = True def clearMemory(self): self.sumInMemory = 0.0 def readMemory(self): self.display.setText(str(self.sumInMemory)) self.waitingForOperand = True def setMemory(self): self.equalClicked() self.sumInMemory = float(self.display.text()) def addToMemory(self): self.equalClicked() self.sumInMemory += float(self.display.text()) def createButton(self, text, member): button = ToolButton(text) button.clicked.connect(member) return button def abortOperation(self): self.clearAll() self.display.setText("####") def calculate(self, rightOperand, pendingOperator): if pendingOperator == "+": self.sumSoFar += rightOperand elif pendingOperator == "-": self.sumSoFar -= rightOperand elif pendingOperator == u"\N{MULTIPLICATION SIGN}": self.factorSoFar *= rightOperand elif pendingOperator == u"\N{DIVISION SIGN}": if rightOperand == 0.0: return False self.factorSoFar /= rightOperand return True
class HeaderCheckBoxes(GridLayout): key = 'HeaderCheckBoxes' toolBarCBs = DAMGLIST() menuCBs = DAMGLIST() connectCBs = DAMGLIST() checkboxes = DAMGDICT() def __init__(self, parent=None): super(HeaderCheckBoxes, self).__init__(parent) self.parent = parent self.la = 0 self.buildHeaderCheckBoxes() cbs = [self.toolBarCBs, self.menuCBs, self.connectCBs, [self.headerCB]] for i in range(len(cbs)): if i == 0: prefix = 'ToolBar' elif i == 1: prefix = 'Menu' elif i == 2: prefix = 'Network' else: prefix = 'Header' for cb in cbs[i]: cb.key = '{0}_{1}_CheckBox_{2}'.format(self.parent.key, prefix, cb.text()) cb._name = '{0} {1} Check Box: {2}'.format(self.parent.key, prefix, cb.text()) cb.settings._settingEnable = True state = cb.getValue('checkState') if state is None: state = True cb.setValue('checkState', state) cb.setChecked(str2bool(state)) self.checkboxes.add(cb.key, cb) def buildHeaderCheckBoxes(self): self.buildToolBarCheckBoxes() self.buildMenuCheckBoxes() self.buildServerStatusCheckBoxes() self.headerCB = CheckBox('Header') self.headerCB.stateChanged.connect(self.headerStateChanged) mnl = self.la csl = mnl + 1 tbl = csl + 1 hdl = tbl + 1 self.addWidget(Label({'txt': 'Menus'}), mnl, 0, 1, 1) self.addWidget(self.allMenuCB, mnl, 1, 1, 1) self.addWidget(self.mnAppCB, mnl, 2, 1, 1) self.addWidget(self.mnGoCB, mnl, 3, 1, 1) self.addWidget(self.mnOfficeCB, mnl, 4, 1, 1) self.addWidget(self.mnToolsCB, mnl, 5, 1, 1) self.addWidget(self.mnDevCB, mnl, 6, 1, 1) self.addWidget(self.mnLibCB, mnl, 7, 1, 1) self.addWidget(self.mnHelpCB, mnl, 8, 1, 1) self.addWidget(Label({'txt': 'Tool Bar: '}), tbl, 0, 1, 1) self.addWidget(self.allToolBarCB, tbl, 1, 1, 1) self.addWidget(self.tbTDCB, tbl, 2, 1, 1) self.addWidget(self.tbVfxCB, tbl, 3, 1, 1) self.addWidget(self.tbArtCB, tbl, 4, 1, 1) self.addWidget(self.tbTexCB, tbl, 5, 1, 1) self.addWidget(self.tbPostCB, tbl, 6, 1, 1) self.addWidget(Label({'txt': 'Connect Status'}), csl, 0, 1, 1) self.addWidget(self.allConnectCB, csl, 1, 1, 1) self.addWidget(self.serverCB, csl, 2, 1, 1) self.addWidget(self.onlineCB, csl, 3, 1, 1) self.addWidget(self.modeCB, csl, 4, 1, 1) self.addWidget(Label({'txt': 'Header'}), hdl, 0, 1, 1) self.addWidget(self.headerCB, hdl, 1, 1, 1) def buildServerStatusCheckBoxes(self): self.serverCB = CheckBox('Server') self.onlineCB = CheckBox('Internet') self.modeCB = CheckBox('Mode') self.allConnectCB = CheckBox("All: ") self.allConnectCB.stateChanged.connect(self.allConnectStateChanged) for cb in [self.serverCB, self.onlineCB, self.modeCB, self.allConnectCB]: self.connectCBs.append(cb) def buildMenuCheckBoxes(self): self.mnAppCB = CheckBox('&App') self.mnGoCB = CheckBox('&Go') self.mnOfficeCB = CheckBox('&Office') self.mnToolsCB = CheckBox('&Tools') self.mnDevCB = CheckBox('&Dev') self.mnLibCB = CheckBox('&Lib') self.mnHelpCB = CheckBox('&Help') self.allMenuCB = CheckBox('All: ') self.allMenuCB.stateChanged.connect(self.allMenuStateChanged) for cb in [self.mnAppCB, self.mnGoCB, self.mnOfficeCB, self.mnToolsCB, self.mnDevCB, self.mnLibCB, self.mnHelpCB, self.allMenuCB]: self.menuCBs.append(cb) def buildToolBarCheckBoxes(self): self.tbTDCB = CheckBox("TD") self.tbVfxCB = CheckBox("VFX") self.tbArtCB = CheckBox("Art") self.tbTexCB = CheckBox("Tex") self.tbPostCB = CheckBox('Post') self.allToolBarCB = CheckBox("All: ") self.allToolBarCB.stateChanged.connect(self.allToolBarStateChanged) for cb in [self.tbTDCB, self.tbVfxCB, self.tbArtCB, self.tbTexCB, self.tbPostCB, self.allToolBarCB]: self.toolBarCBs.append(cb) def allToolBarStateChanged(self, bool): for cb in self.toolBarCBs: cb.setChecked(bool) def allMenuStateChanged(self, bool): for cb in self.menuCBs: cb.setChecked(bool) def allConnectStateChanged(self, bool): for cb in self.connectCBs: cb.setChecked(bool) def headerStateChanged(self, bool): self.allToolBarCB.setChecked(bool) self.allMenuCB.setChecked(bool) self.allConnectCB.setChecked(bool)
class ConnectStatus(GridLayout): key = 'ConnectStatus' _allowLocalMode = True _updatting = False _mode = None _server = None labels = DAMGLIST() def __init__(self, parent=None): super(ConnectStatus, self).__init__(parent) self.parent = parent self._server = self.getServer() self.serverStatus = Label({ 'wmax': 20, 'sst': 'Server Connection Status', }) self.internetStatus = Label({ 'wmax': 20, 'sst': 'Internet Connection Status', }) self.modeStatus = Label({ 'txt': self._mode, 'sst': 'Operating Mode Status' }) self.updateTimer = DAMGTIMER() self.updateTimer.setParent(self) self.updateTimer.timeout.connect(self.update_icon) self.server_status() self.internet_status() self.mode_status() self.addWidget(self.serverStatus, 0, 0, 1, 1) self.addWidget(self.internetStatus, 0, 1, 1, 1) self.addWidget(self.modeStatus, 0, 2, 1, 1) self.labels.appendList( [self.serverStatus, self.internetStatus, self.modeStatus]) if not self._updatting: self.updateTimer.stop() else: self.updateTimer.start(1000) def server_status(self): try: r = requests.get(__localServer__) except Exception: if not self._allowLocalMode: MessageBox(None, 'Connection Failed', 'critical', SERVER_CONNECT_FAIL, 'close') sys.exit() else: self.parent.signals.emit('sysNotify', 'Offline', 'Can not connect to Server', 'crit', 500) self.serverIcon = get_app_icon(16, 'Disconnected') else: if r.status_code == 200: self.serverIcon = get_app_icon(16, 'Connected') else: self.serverIcon = get_app_icon(16, 'Disconnected') self.serverStatus.setPixmap(QPixmap(self.serverIcon)) self.serverStatus.update() def internet_status(self): try: r = requests.get(__google__) except requests.ConnectionError: self.parent.signals.emit('sysNotify', 'Offline', 'Can not connect to Internet', 'crit', 500) self.internetIcon = get_app_icon(16, 'Disconnected') self.internetStatus.setToolTip('Disconnected') else: self.parent.signals.emit('sysNotify', 'Online', 'Internet connected', 'info', 500) self.internetIcon = get_app_icon(16, 'Connected') self.internetStatus.setStatusTip('Connected') self.internetStatus.setPixmap(QPixmap(self.internetIcon)) self.internetStatus.update() def mode_status(self): self.getServer() self.modeStatus.setText(self._mode) self.modeStatus.setToolTip(self._mode) self.modeStatus.update() def update_icon(self): # print('update Icon') self.internet_status() self.server_status() self.mode_status() def setMode(self, mode): self._mode = mode def getServer(self): try: r = requests.get(__globalServer__) except Exception: try: r = requests.get(__localServer__) except Exception: if not self._allowLocalMode: MessageBox(None, 'Connection Failed', 'critical', SERVER_CONNECT_FAIL, 'close') sys.exit() else: self.setMode('Offline') else: if r.status_code == 200: self._server = __localServer__ self.setMode('Local') else: self.setMode('Offline') else: if r.status_code == 200: self._server = __globalServer__ self.setMode('GLobal') else: self.setMode('Offline') return self._server @property def updatting(self): return self._updatting @property def allowOfflineMode(self): return self._allowLocalMode @property def mode(self): return self._mode @property def server(self): return self._server @server.setter def server(self, val): self._server = val @mode.setter def mode(self, val): self._mode = val @updatting.setter def updatting(self, val): self._updatting = val @allowOfflineMode.setter def allowOfflineMode(self, val): self._allowLocalMode = val # ------------------------------------------------------------------------------------------------------------- # Created by panda on 25/05/2018
class SignalManager(Signal): key = "SignalManager" showLayoutOld = DAMGLIST() executingOld = DAMGLIST() regisLayoutOld = DAMGLIST() openBrowserOld = DAMGLIST() setSettingOld = DAMGLIST() sysNotifyOld = DAMGLIST() updateAvatarOld = DAMGLIST() loginChangedOld = DAMGLIST() def __init__(self, parent=None): super(SignalManager, self).__init__(parent) self.parent = parent try: self.parent.children() except AttributeError: pass else: self.setParent(self.parent) finally: self.key = '{0}_{1}'.format(self.parent.key, self.key) def emit(self, signal, op1=None, op2=None, op3=None, op4=None): if self._emittable: sig = self.getSignal(signal) self.loadState() if signal == 'showLayout': self.showLayoutOld, repeat = self.checkSignalRepeat( self.showLayoutOld, [op1, op2]) old = self.showLayoutOld if repeat: if self.print_checkState: print(self.key, self.states) if not self.states[op1] == op2: self.states.add(op1, op2) self.updateState() sig.emit(op1, op2) else: if self.print_checkState: print(self.key, self.states) self.states.add(op1, op2) self.updateState() sig.emit(op1, op2) elif signal == 'executing': self.executingOld, repeat = self.checkSignalRepeat( self.executingOld, [op1]) old = self.executingOld if not repeat: sig.emit(op1) elif signal == 'regisLayout': self.regisLayoutOld, repeat = self.checkSignalRepeat( self.regisLayoutOld, [op1]) old = self.regisLayoutOld if not repeat: sig.emit(op1) elif signal == 'openBrowser': self.openBrowserOld, repeat = self.checkSignalRepeat( self.openBrowserOld, [op1]) old = self.openBrowserOld if not repeat: sig.emit(op1) elif signal == 'setSetting': self.setSettingOld, repeat = self.checkSignalRepeat( self.setSettingOld, [op1, op2, op3]) old = self.setSettingOld if not repeat: sig.emit(op1, op2, op3) elif signal == 'sysNotify': self.sysNotifyOld, repeat = self.checkSignalRepeat( self.sysNotifyOld, [op1, op2, op3, op4]) old = self.sysNotifyOld if not repeat: sig.emit(op1, op2, op3, op4) elif signal == 'updateAvatar': self.updateAvatarOld, repeat = self.checkSignalRepeat( self.updateAvatarOld, [op1]) old = self.updateAvatarOld if not repeat: sig.emit(op1) elif signal == 'loginChanged': self.loginChangedOld, repeat = self.checkSignalRepeat( self.loginChangedOld, [op1]) old = self.loginChangedOld if not repeat: sig.emit(op1) else: repeat = False old = [] if repeat: if self.print_block: print('{2}: block signal {0}: {1}'.format( signal, old, self.key)) return else: if self.print_emit: print('{0} signal {1} emmited'.format( self.parent.key, signal)) return else: if self.print_emittable: print('UnEmittableError: {0} is not allowed to emit'.format( self.key)) return def getSignal(self, signal): if self.print_getSignal: print('{0} get signal: {1}'.format(self.parent.key, signal)) return self.signals[signal][0] def connect(self, signal, target): sig = self.getSignal(signal) if self.auto_changeEmmittable: self._emittable = True return sig.connect(target) else: print('EmittableAllowError: Signal is not allowed to emit: {0}'. format(signal)) def checkSignalRepeat(self, old, data): new = [i for i in data] if self.print_checkRepeat: print(new, old) if len(new) == 0: repeat = False elif len(new) == len(old): repeat = True for i in range(len(new)): if not new[i] == old[i]: repeat = False break else: repeat = False old = DAMGLIST() old.appendList(new) return old, repeat # ------------------------------------------------------------------------------------------------------------- # Created by panda on 25/10/2019 - 6:59 AM # © 2017 - 2018 DAMGteam. All rights reserved
class LayoutManager(DAMG): key = 'LayoutManager' _buildAll = False noShowHideAttrs = DAMGLIST() unHidableLayouts = DAMGLIST() unShowableLayouts = DAMGLIST() ignoreIDs = ['MainMenuSection', 'MainMenuBar', 'MainToolBarSection', 'MainToolBar', 'Notification', 'TopTab', 'BotTab', 'Footer', 'TopTab2', 'TopTab1', 'TopTab3', 'MainStatusBar', 'ConnectStatus', 'GridLayout'] def __init__(self, setting, registryLayout, actionManager, buttonManager, eventManager, threadManager, parent=None): super(LayoutManager, self).__init__(parent) self.parent = parent self.settings = setting self.actionManager = actionManager self.buttonManager = buttonManager self._register = registryLayout self.eventManager = eventManager self.threadManager = threadManager self.globalSetting() def layouts(self): return self._register.values() def keys(self): return self._register.keys() def buildLayouts(self): self.mains = self.mainLayouts() self.funcs = self.functionLayouts() self.infos = self.infoLayouts() self.setts = self.settingLayouts() self.tools = self.toolLayouts() self.prjs = self.projectLayouts() tbcbs = self.preferences.headerGrid.toolBarCBs tbs = self.mainUI.mainToolBar.tbs cncbs = self.preferences.headerGrid.connectCBs cns = self.mainUI.connectStatus.labels mncbs = self.preferences.headerGrid.menuCBs mns = self.mainUI.mainMenuBar.mns for i in range(len(tbs)): cb = tbcbs[i] tb = tbs[i] cb.stateChanged.connect(tb.setVisible) tbcbs[-1].stateChanged.connect(self.mainUI.mainToolBarSec.setVisible) for i in range(len(mncbs)): cb = mncbs[i] mn = mns[i] cb.stateChanged.connect(self.mainUI.mainMenuBar.showMenu) mncbs[-1].stateChanged.connect(self.mainUI.mainMenuSec.setVisible) for i in range(len(cns)): cb = cncbs[i] lb = cns[i] cb.stateChanged.connect(lb.setVisible) cncbs[-1].stateChanged.connect(self.mainUI.connectStatusSec.setVisible) ntcbs = self.preferences.bodyGrid.notificationCBs nts = self.mainUI.notification.labels for i in range(len(nts)): cb = ntcbs[i] lb = nts[i] cb.stateChanged.connect(lb.setVisible) ntcbs[-1].stateChanged.connect(self.mainUI.notifiSec.setVisible) for layout in self.layouts(): try: layout.isHidden() except AttributeError: self.noShowHideAttrs.append(layout) layouts = [] for listLayout in [self.mains, self.funcs, self.infos, self.setts, self.tools, self.prjs]: layouts = layouts + list(listLayout) self._buildAll = True return layouts def functionLayouts(self): from ui.subUI.Funcs.SignIn import SignIn from ui.subUI.Funcs.SignUp import SignUp from ui.subUI.Funcs.ForgotPassword import ForgotPassword self.signin = SignIn() self.forgotPW = ForgotPassword() self.signup = SignUp() for layout in [self.signin, self.signup, self.forgotPW]: self.registLayout(layout) return self.signin, self.signup, self.forgotPW def mainLayouts(self): from ui.PipelineManager import PipelineManager from ui.SysTray import SysTray from ui.subUI.ShortcutCommand import ShortcutCommand self.mainUI = PipelineManager(self.actionManager, self.buttonManager, self.threadManager) self.sysTray = SysTray(self.actionManager, self.eventManager) self.shortcutLayout = ShortcutCommand() self.setLayoutUnHidable(self.sysTray) layouts = [self.mainUI, self.sysTray, self.shortcutLayout] for layout in layouts: layout.settings._settingEnable = True self.registLayout(layout) # for layout in self.mainUI.layouts: # self.registLayout(layout) # # for layout in self.mainUI.topTabUI.tabs: # key = layout.key # if not key in self._register.keys(): # self._register[key] = layout return layouts def infoLayouts(self): from ui.subUI.Info.InfoWidget import InfoWidget self.about = InfoWidget(key='About') self.codeConduct = InfoWidget(key='CodeOfConduct') self.contributing = InfoWidget(key='Contributing') self.credit = InfoWidget(key="Credit") self.licence = InfoWidget(key='Licence') self.reference = InfoWidget(key='Reference') self.version = InfoWidget(key='Version') layouts = [self.about, self.codeConduct, self.contributing, self.credit, self.licence, self. reference, self.version] for layout in layouts: layout.settings._settingEnable = True self.registLayout(layout) return layouts def settingLayouts(self): from ui.subUI.Settings.SettingUI import SettingUI from ui.subUI.Settings.UserSetting import UserSetting self.settingUI = SettingUI() self.userSetting = UserSetting() layouts = [self.settingUI, self.userSetting] for layout in layouts: self.registLayout(layout) return layouts def toolLayouts(self): from ui.subUI.Tools import (Screenshot, NoteReminder, ImageViewer, FindFiles, EnglishDictionary, Calendar, Calculator) from ui.subUI.Tools.NodeGraph import NodeGraph from ui.subUI.Tools.TextEditor import TextEditor from ui.Header.Menus.config import Preferences from ui.Header.Menus.config import Configuration from ui.subUI.TaskManager import TaskManager self.calculator = Calculator.Calculator() self.calendar = Calendar.Calendar() self.configuration = Configuration.Configuration() self.engDict = EnglishDictionary.EnglishDictionary() self.findFile = FindFiles.FindFiles() self.imageViewer = ImageViewer.ImageViewer() self.nodeGraph = NodeGraph.NodeGraph() self.noteReminder = NoteReminder.NoteReminder() self.preferences = Preferences.Preferences() self.screenShot = Screenshot.Screenshot() self.textEditor = TextEditor.TextEditor() self.taskManager = TaskManager(self.mainUI) layouts = [self.calculator, self.calendar, self.configuration, self.engDict, self.findFile, self.imageViewer, self.nodeGraph, self.noteReminder, self.preferences, self.screenShot, self.textEditor, self.taskManager] for layout in layouts: layout.settings._settingEnable = True self.registLayout(layout) return layouts def projectLayouts(self): from ui.subUI.Projects.NewProject import NewProject self.newProject = NewProject() for layout in [self.newProject, ]: layout.settings._settingEnable = True self.registLayout(layout) layouts = [self.newProject] return layouts def showOnlyLayout(self, layout): layouts = [l for l in self.layouts() if not l is layout and not l in self.unHidableLayouts] if self.isHidable(layout): self.show(layout) for l in layouts: self.hide(l) def hideOnlyLayout(self, layout): layouts = [l for l in self.layouts() if not l is layout and not l in self.unHidableLayouts] if self.isHidable(layout): self.hide(layout) for l in layouts: self.show(l) def setLayoutUnHidable(self, layout): if not layout in self.unHidableLayouts: layout.show() layout.setVisible(True) return self.unHidableLayouts.append(layout) def setLayoutUnShowable(self, layout): if not layout in self.unShowableLayouts: self.hide(layout) return self.unShowableLayouts.append(layout) def setLayoutHidable(self, layout): if layout in self.unHidableLayouts: self.show(layout) return self.unHidableLayouts.remove(layout) def isHidable(self, layout): if not layout in self.noShowHideAttrs: if not layout in self.unHidableLayouts: try: layout.isHidden() except AttributeError: return False else: return True elif layout in self.unShowableLayouts: return False else: return False else: return False def hide(self, layout): if not layout.key in self.ignoreIDs: layout.hide() return layout.setValue('state', 'hide') def show(self, layout): if not layout.key in self.ignoreIDs: layout.show() return layout.setValue('state', 'show') def showNormal(self, layout): if not layout.key in self.ignoreIDs: layout.showNormal() return layout.setValue('state', 'showNormal') def showMinnimize(self, layout): if not layout.key in self.ignoreIDs: layout.showMinimize() return layout.setValue('state', 'showMinimize') def showMaximized(self, layout): if not layout.key in self.ignoreIDs: layout.showMaximized() return layout.setValue('state', 'showMaximized') def showAllLayout(self): for layout in self.layouts(): self.show(layout) def registLayout(self, layout): return self._register.regisLayout(layout) def globalSetting(self): for layout in self.layouts(): # print(layout.key) try: layout.setContentMargin(1,1,1,1) except AttributeError: pass try: layout.setSizePolicy(SiPoMin, SiPoMin) except AttributeError: pass try: layout.setSpacing(2) except AttributeError: pass if layout.key == 'PipelineManager': layout.setFixedWidth(475) # layout.setFixedHeight(850) # self.parent.setWindowFlags(STAY_ON_TOP) pass if layout.key in ['TobTab', 'BotTab']: layout.setMovable(True) layout.setElideMode(Qt.ElideRight) layout.setUsesScrollButtons(True) pass @property def buildAll(self): return self._buildAll @property def register(self): return self._register @buildAll.setter def buildAll(self, val): self._buildAll = val @register.setter def register(self, val): self._register = val # ------------------------------------------------------------------------------------------------------------- # Created by panda on 6/07/2018 - 11:31 AM # © 2017 - 2018 DAMGteam. All rights reserved