class pDetector(
Detector
): # A simple QTextEdit, with a few pre-set attributes and a file-like interface.
def __init__(self, parent=None):
super(pDetector, self).__init__(parent)
self._buffer = StringIO()
self.parent = parent
self.setReadOnly(True)
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.parent = parent
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def write(
self,
msg): # Add msg to the console's output, on a showLayout_new line.
self._buffer.write(msg)
self.insertPlainText(msg)
self.moveCursor(QTextCursor.End) # Autoscroll
def __getattr__(self, attr):
return getattr(
self._buffer, attr
) # Fall back to the buffer object if an attribute can't be found.
class VBoxLayout(QVBoxLayout):
Type = 'DAMGUI'
key = 'VBoxLayout'
_name = 'DAMG V Box Layout'
_copyright = __copyright__
def __init__(self, preset={}, parent=None):
super(VBoxLayout, self).__init__(parent)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'], self)
self.parent = parent
self.preset = preset
if check_preset(self.preset):
self.buildUI()
def buildUI(self):
for key, value in self.preset.items():
if key == 'addWidget':
for widget in value:
self.addWidget(widget)
elif key == 'addLayout':
for layout in value:
self.addLayout(layout)
elif key == 'addStretch':
self.setStretch(value, 0)
else:
print("Unrecognise configKey: {}".format(key))
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def sizeHint(self):
size = super(VBoxLayout, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 27/10/2019 - 6:57 PM
# © 2017 - 2018 DAMGteam. All rights reserved
class GridLayout(QGridLayout):
Type = 'DAMGUI'
key = 'GridLayout'
_name = 'DAMG Grid Layout'
_copyright = __copyright__
def __init__(self, parent=None):
QGridLayout.__init__(self)
self.parent = parent
self._name = self.__class__.__name__
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
def setVisible(self, bool):
pass
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def sizeHint(self):
size = super(GridLayout, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
class SystemTrayIcon(QSystemTrayIcon):
Type = 'DAMGUI'
key = 'SystemTrayIcon'
_name = 'DAMG System Tray Icon'
_copyright = __copyright__
_data = dict()
def __init__(self, parent=None):
QSystemTrayIcon.__init__(self)
self.parent = parent
self.signals = SignalManager(self)
self.logger = Loggers(self.__class__.__name__)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 27/10/2019 - 7:51 PM
# © 2017 - 2018 DAMGteam. All rights reserved
class PlainTextEdit(QPlainTextEdit):
Type = 'DAMGUI'
key = 'PlainTextEdit'
_name = 'DAMG Plain Text Edit'
_copyright = __copyright__
def __init__(self, preset={}, parent=None):
super(PlainTextEdit, self).__init__(parent)
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'], self)
self.parent = parent
self.preset = preset
if check_preset(self.preset):
self.buildUI()
self.values = dict(w = self.width(), h = self.height(), x = self.x(), y = self.y())
def sizeHint(self):
size = super(PlainTextEdit, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__=='__main__':
self.close()
else:
self.signals.emit('setSetting', 'showLayout', 'hide', self.key)
def hideEvent(self, event):
if __name__=='__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('setSetting', 'showLayout', 'hide', self.key)
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__=='__main__':
self.show()
else:
self.signals.emit('setSetting', self.key, 'showLayout', 'show')
event.ignore()
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
def buildUI(self):
if self.preset is None or self.preset == {}:
self.preset = {'txt': ' '}
for key, value in self.preset.items():
if key == 'lwm': # setLineWrapMode
self.setLineWrapMode(value)
elif key == 'sfh': # setFixHeight
self.setFixedHeight(value)
elif key == 'vsbp': # setVerticalScrollBarPolicy
self.setVerticalScrollBarPolicy(value)
elif key == 'adr': # setAcceptDrops
self.setAcceptDrops(value)
elif key == 'rol': # setReadOnly
self.setReadOnly(value)
class CheckBox(QCheckBox):
Type = 'DAMGUI'
key = 'CheckBox'
_name = 'DAMG Check Box'
_copyright = __copyright__
def __init__(self, txt=None, preset={}, parent=None):
super(CheckBox, self).__init__(parent)
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'], self)
self.parent = parent
self.txt = txt
if self.txt is not None:
self.setText(self.txt)
self.stateChanged.connect(self.saveState)
self.values = dict(w=self.width(), h=self.height(), x=self.x(), y=self.y())
self.preset = preset
if check_preset(self.preset):
self.buildUI()
def buildUI(self):
for key, value in self.preset.items():
if key == 'tt':
self.setToolTip(value)
def saveState(self, val):
if val >= 1:
state = True
else:
state = False
self.setValue('checkState', state)
def sizeHint(self):
size = super(CheckBox, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__=='__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__=='__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__=='__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 27/10/2019 - 6:53 PM
# © 2017 - 2018 DAMGteam. All rights reserved
class PLM(Application):
key = 'PLM'
dataConfig = configManager
count = 0
showLayout_old = []
executing_old = []
setSetting_old = []
openBrowser_old = []
sysNotify_old = []
def __init__(self):
super(PLM, self).__init__(sys.argv)
# Run all neccessary configuration to start PLM
self.setWindowIcon(LogoIcon("Logo")) # Setup icon
self.setOrganizationName(__organization__)
self.setApplicationName(__appname__)
self.setOrganizationDomain(__website__)
self.setApplicationVersion(__version__)
self.setApplicationDisplayName(__appname__)
self.setCursorFlashTime(1000)
self.setQuitOnLastWindowClosed(False)
self.appID = self.sessionId()
self.appKey = self.sessionKey()
self.appPid = self.applicationPid()
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(self.appID) # Setup app ID
self.logger = Loggers(self.__class__.__name__)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'], self)
self.settings._settingEnable = True
self.appInfo = self.dataConfig.appInfo # Configuration data
self.set_styleSheet('dark')
# Multithreading.
self.threadManager = ThreadManager()
self.database = LocalDatabase() # Database tool
self.browser = Browser()
self.eventManager = EventManager()
self.buttonManager = ButtonManager()
self.actionManager = ActionManager()
self.registryLayout = RegistryLayout()
self.layoutManager = LayoutManager(self.settings, self.registryLayout, self.actionManager,
self.buttonManager, self.eventManager, self.threadManager, self)
self.layoutManager.registLayout(self.browser)
self.layoutManager.buildLayouts()
self.layoutManager.globalSetting()
self.signIn = self.layoutManager.signin
self.signUp = self.layoutManager.signup
self.forgotPassword = self.layoutManager.forgotPW
self.sysTray = self.layoutManager.sysTray
self.mainUI = self.layoutManager.mainUI
self.shortcutLayout = self.layoutManager.shortcutLayout
for layout in [self.signIn, self.signUp, self.forgotPassword, self.sysTray, self.mainUI]:
layout.signals.connect('loginChanged', self.loginChanged)
for layout in self.layoutManager.layouts():
if not layout.key in self.ignoreIDs:
layout.signals.connect('showLayout', self.showLayout)
layout.signals.connect('executing', self.executing)
layout.signals.connect('openBrowser', self.openBrowser)
layout.signals.connect('setSetting', self.setSetting)
layout.signals.connect('sysNotify', self.sysNotify)
# print(layout.key)
layout.settings._settingEnable = True
if layout.key in ['SignIn', 'SignUp', 'SysTray', 'ForgotPassword']:
layout.signals.connect('loginChanged', self.loginChanged)
if self.mainUI.mode == 'Offline':
self.showLayout(self.mainUI.key, "show")
else:
try:
self.username, token, cookie, remember = self.database.query_table('curUser')
except (ValueError, IndexError):
self.logger.info("Error occur, can not query data")
self.signInEvent()
else:
if not str2bool(remember):
self.signInEvent()
else:
r = requests.get(__localServer__, verify = False, headers = {'Authorization': 'Bearer {0}'.format(token)}, cookies = {'connect.sid': cookie})
if r.status_code == 200:
if not self.sysTray.isSystemTrayAvailable():
self.logger.report(SYSTRAY_UNAVAI)
self.exitEvent()
else:
self.loginChanged(True)
self.sysTray.log_in()
self.showLayout(self.mainUI.key, "show")
else:
self.showLayout('SignIn', "show")
self.runEvent()
@pyqtSlot(str, name='openBrowser')
def openBrowser(self, url):
if self._trackRecieveSignal:
self.logger.report("receive signal open browser: {0}".format(url))
self.browser.setUrl(url)
self.browser.update()
self.browser.show()
@pyqtSlot(str, str, str, name='setSetting')
def setSetting(self, key=None, value=None, grp=None):
if self._trackRecieveSignal:
self.logger.report("receive signal setSetting: {0}, {1}, {2}".format(key, value, grp))
self.setSetting_old, repeat = self.checkSignalRepeat(self.setSetting_old, [key, value, grp])
if not repeat:
self.settings.initSetValue(key, value, grp)
else:
if self._trackBlockSignal:
self.logger.report('{3}: block signal setSetting: {0}, {1}, {2}'.format(key, value, grp, self.key))
return
@pyqtSlot(str, name="executing")
def executing(self, cmd):
if self._trackRecieveSignal:
self.logger.report("receive signal executing: {0}".format(cmd))
self.executing_old, repeat = self.checkSignalRepeat(self.executing_old, [cmd])
if repeat:
limit = 10
if self.threadManager.counter.printCounter:
self.threadManager.setPrintCounter(False)
if self.threadManager.counter._countLimited != limit:
self.threadManager.setCountLimited(limit)
if not self.threadManager.isCounting():
self.threadManager.startCounting()
if self._trackBlockSignal:
print('block signal executing: {0}'.format(cmd))
return self.countDownReset(limit)
else:
if cmd in self.registryLayout.keys():
return self.signals.emit('showLayout', cmd, 'show')
elif os.path.isdir(cmd):
return os.startfile(cmd)
elif cmd in self.dataConfig.appInfo.keys():
return os.system(self.appInfo[cmd])
elif cmd == 'Debug':
return self.mainUI.botTabUI.botTab2.test()
elif cmd == 'open_cmd':
return os.system('start /wait cmd')
elif cmd == 'CleanPyc':
return clean_file_ext('.pyc')
elif cmd == 'ReConfig':
self.dataConfig = ConfigManager(__envKey__, ROOT)
return self.dataConfig
elif cmd == 'Exit':
return self.exitEvent()
else:
if not cmd in self.toBuildCommand:
if self._trackCommand:
self.logger.report("This command is not regiested yet: {0}".format(cmd))
return self.toBuildCommand.append(cmd)
else:
if self._trackCommand:
self.logger.info("This command will be built later.".format(cmd))
return
@pyqtSlot(str, str, name="showLayout")
def showLayout(self, layoutID, mode):
self.showLayout_old, repeat = self.checkSignalRepeat(self.showLayout_old, [layoutID, mode])
if layoutID in ['NewTask', 'EditTask']:
layoutID = 'TaskManager'
if layoutID in self.registryLayout.keys():
layout = self.registryLayout[layoutID]
if layout.windowState() & StateNormal:
state = 'showNormal'
elif layout.windowState() & StateMax:
state = 'showMaximized'
elif layout.windowState() & StateMin:
state = 'showMinimized'
else:
state = layout.getValue('showLayout')
if not repeat:
if mode == state:
if self._trackBlockSignal:
self.logger.report('{2}: block signal showLayout from {0}: {1}'.format(layoutID, mode, self.key))
repeat = True
else:
if mode == 'show':
if state in ['showNormal', 'showRestore']:
if self._trackBlockSignal:
self.logger.report('{2}: block signal showLayout from {0}: {1}'.format(layoutID, mode, self.key))
repeat = True
elif mode == 'hide':
if state in ['hide', 'showMinimized']:
if self._trackBlockSignal:
self.logger.report('{2}: block signal showLayout from {0}: {1}'.format(layoutID, mode, self.key))
repeat = True
else:
repeat = True
if not repeat:
if self._trackRecieveSignal:
self.logger.report('recieve signal showLayout from {0}: {1}'.format(layoutID, mode))
pass
else:
if self._trackBlockSignal:
self.logger.report('{2}: block signal showLayout from {0}: {1}'.format(layoutID, mode, self.key))
return
if mode in ['SignIn', 'SignOut', 'SignUp', 'SwitchAccount']:
if layoutID == mode:
if mode == 'SignIn':
return self.signInEvent()
elif mode == 'SignOut':
return self.signOutEvent()
elif mode == 'SignUp':
return self.signUpEvent()
else:
return self.switchAccountEvent()
if layoutID in self.registryLayout.keys():
if layoutID in self.ignoreIDs:
if not layoutID in self.toBuildUis:
self.logger.report("Layout: '{0}' is not registerred yet.".format(layoutID))
self.toBuildUis.append(layoutID)
self.todoList.update()
else:
layout = self.registryLayout[layoutID]
if mode == "hide":
if not layout.isHidden():
layout.hide()
self.setSetting('showLayout', 'hide', layout.key)
self.mainUI.signals.states[layout.key] = mode
elif mode == "show":
if layout.isHidden():
layout.show()
self.setSetting('showLayout', 'show', layout.key)
self.mainUI.signals.states[layout.key] = mode
elif mode == 'showRestore' or mode == 'showNormal':
if not layout.windowState() & StateNormal:
layout.showNormal()
self.setSetting('showLayout', 'show', layout.key)
self.mainUI.signals.states[layout.key] = mode
elif mode == 'showMinimized' or mode == 'showMin':
if not layout.isMinimized():
layout.showMinimized()
self.setSetting('showLayout', 'showMinimized', layout.key)
self.mainUI.signals.states[layout.key] = mode
elif mode == 'showMaximized' or mode == 'showMax':
if not layout.isMaximized():
layout.showMaximized()
self.setSetting('showLayout', 'showMaximized', layout.key)
self.mainUI.signals.states[layout.key] = mode
elif mode == 'switch':
if layout.isHidden():
layout.show()
self.setSetting('showLayout', 'show', layout.key)
self.mainUI.signals.states[layout.key] = mode
else:
layout.hide()
self.setSetting('showLayout', 'hide', layout.key)
self.mainUI.signals.states[layout.key] = mode
elif mode == 'quit' or mode == 'exit':
self.exitEvent()
else:
self.logger.report('LayoutModeError: {0} does not have mode: {1}'.format(layoutID, mode))
else:
if not layoutID in self.toBuildUis:
self.logger.report("Layout key does not exists: {0}".format(layoutID))
self.toBuildUis.append(layoutID)
self.todoList.update()
@pyqtSlot(str, str, str, int, name='sysNotify')
def sysNotify(self, title, mess, iconType, timeDelay):
if self._trackRecieveSignal:
self.logger.report('Receive signal sysNotify: {0} {1} {2} {3}'.format(title, mess, iconType, timeDelay))
self.sysNotify_old, repeat = self.checkSignalRepeat(self.sysNotify_old, [title, mess, iconType, timeDelay])
if not repeat:
return self.layoutManager.sysTray.sysNotify(title, mess, iconType, timeDelay)
else:
if self._trackBlockSignal:
self.logger.report('{4}: block signal setSetting: {0}, {1}, {2}, {3}'.format(title, mess, iconType, timeDelay, self.key))
return
@pyqtSlot(bool, name='loginChanged')
def loginChanged(self, val):
self._login = val
if not self._login:
self.showLayout(self.mainUI.key, 'hide')
self.mainUI.signals.states.add(self.mainUI.key, 'hide')
else:
self.showLayout(self.mainUI.key, 'show')
self.mainUI.signals.states.add(self.mainUI.key, 'show')
for layout in [self.signIn, self.signUp, self.forgotPassword]:
self.showLayout(layout.key, 'hide')
layout.signals.states.add(layout.key, 'hide')
self.sysTray.loginChanged(self._login)
self.signIn.loginChanged(self._login)
self.signUp.loginChanged(self._login)
return self._login
@pyqtSlot(str, name='setStylesheet')
def set_styleSheet(self, style):
from cores.StyleSheet import StyleSheet
self._styleSheet = StyleSheet(style).stylesheet
self.setStyleSheet(self._styleSheet)
self.setSetting('styleSheet', style, self.key)
def countDownReset(self, limit):
self.count += 1
if self.count == limit:
self.executing_old = []
return self.executing_old
def signInEvent(self):
self.switchAccountEvent()
def signOutEvent(self):
self.loginChanged(False)
self.signIn.show()
for layout in [self.mainUI, self.signUp, self.forgotPassword] + self.layoutManager.infos + \
self.layoutManager.setts + self.layoutManager.tools + self.layoutManager.prjs:
self.showLayout(layout.key, 'hide')
layout.signals.states.add(layout.key, 'hide')
def signUpEvent(self):
self.loginChanged(False)
self.showLayout(self.signUp, 'show')
self.signUp.signals.states.add(self.signUp.key, 'show')
for layout in [self.mainUI, self.signUp, self.forgotPassword] + self.layoutManager.infos + \
self.layoutManager.setts + self.layoutManager.tools + self.layoutManager.prjs:
self.showLayout(layout.key, 'hide')
layout.signals.states.add(layout.key, 'hide')
def switchAccountEvent(self):
self.signOutEvent()
def exitEvent(self):
if self._trackJobsTodo:
from pprint import pprint
pprint(self.todoList)
states = {}
for layout in self.layoutManager.layouts():
if layout.key not in self.ignoreIDs + ['SysTray']:
self.showLayout(layout.key, 'hide')
value = layout.getValue('showLayout')
if value is None:
value = 'hide'
elif value == 'show':
value = 'hide'
layout.setValue('showLayout', value)
states[layout.key] = value
layout.setValue('x', layout.x())
layout.setValue('y', layout.y())
layout.setValue('w', layout.width())
layout.setValue('h', layout.height())
self.mainUI.signals.states.appendDict(states)
self.mainUI.signals.updateState()
self.exit()
class DockWidget(QDockWidget):
# self.content = DockStamp(self)
# self.setWidget(self.content)
# cursor = self.content.textCursor()
# cursor.insertBlock()
# cursor.insertText("Note info")
Type = 'DAMGUI'
key = 'DockWidget'
_name = 'DAMG Dock Widget'
_copyright = __copyright__
def __init__(self, parent=None):
QDockWidget.__init__(self)
self.parent = parent
self._name = self.__class__.__name__
self.signals = SignalManager(self)
self.logger = Loggers(self.__class__.__name__)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
def sizeHint(self):
size = super(DockWidget, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__ == '__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__ == '__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__ == '__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
class Button(QPushButton):
Type = 'DAMGUI'
key = 'Button'
_name = 'DAMG Button'
_copyright = __copyright__
def __init__(self, preset={}, parent=None):
super(Button, self).__init__(parent)
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
self.preset = preset
if check_preset(self.preset):
self.procedural()
def procedural(self):
for key, value in self.preset.items():
if key == 'txt':
self.setText(value)
elif key == 'tt':
self.setToolTip(value)
elif key == 'cl':
self.clicked.connect(value)
elif key == 'icon':
self.setIcon(AppIcon(32, value))
elif key == 'tag':
self.setIcon(TagIcon(value))
elif key == 'icon24':
self.setIcon(AppIcon(24, value))
elif key == 'fix':
self.setFixedSize(value)
elif key == 'ics':
self.setIconSize(value)
elif key == 'stt':
self.setToolTip(value)
else:
print(
"PresetKeyError at {0}: No such key registed in preset: {1}: {2}"
.format(__name__, key, value))
def sizeHint(self):
size = super(Button, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__ == '__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__ == '__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__ == '__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
class LCDNumber(QLCDNumber):
Type = 'DAMGUI'
key = 'LCDNumber'
_name = 'DAMG LCD Number'
_copyright = __copyright__
def __init__(self, parent=None):
QLCDNumber.__init__(self)
self.parent = parent
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.time = QTime()
self.zone = QTimeZone()
self.date = QDate()
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
def sizeHint(self):
size = super(LCDNumber, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__ == '__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__ == '__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__ == '__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
def currentTime(self):
return self.time.currentTime()
def currentTimeZone(self):
return self.zone.utc()
def currentDate(self):
return self.date.currentDate()
class TabWidget(QTabWidget):
Type = 'DAMGUI'
key = 'TabWidget'
_name = 'DAMG Tab Widget'
_copyright = __copyright__
def __init__(self, parent=None):
QTabWidget.__init__(self)
self.parent = parent
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.setTabPosition(self.North)
self.setMovable(True)
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
def sizeHint(self):
size = super(TabWidget, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__ == '__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__ == '__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
vals = [int(v) for v in vals]
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__ == '__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
def getCurrentTab(self):
return self.tabLst[self.currentIndex()]
def getCurrentKey(self):
return self.getCurrentTab().key
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 27/10/2019 - 4:39 PM
# © 2017 - 2018 DAMGteam. All rights reserved
class ComboBox(QComboBox):
Type = 'DAMGUI'
key = 'ComboBox'
_name = 'DAMG Combo Box'
_copyright = __copyright__
def __init__(self, preset={}, parent=None):
super(ComboBox, self).__init__(parent)
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.parent = parent
self.preset = preset
if check_preset(self.preset):
self.buildUI()
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
def sizeHint(self):
size = super(ComboBox, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__ == '__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__ == '__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__ == '__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
def buildUI(self):
for key, value in self.preset.items():
if key == 'items':
for item in value:
self.addItem(item)
elif key == 'editable':
self.setEditable(value)
elif key == 'curIndex':
self.setCurrentIndex(value)
elif key == 'setObjName':
self.setObjectName(value)
else:
print("PRESETKEYERROR: There is no key in preset: {}".format(
key))
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 27/10/2019 - 6:55 PM
# © 2017 - 2018 DAMGteam. All rights reserved
class Widget(QWidget):
Type = 'DAMGWIDGET'
key = 'Widget'
_name = 'DAMG Widget'
_copyright = __copyright__
def __init__(self, parent=None):
QWidget.__init__(self)
self.parent = parent
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'], self)
self.setWindowIcon(AppIcon(32, self.key))
self.setWindowTitle(self.key)
def sizeHint(self):
size = super(Widget, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__=='__main__':
self.setValue('showLayout', 'close')
self.close()
else:
self.setValue('showLayout', 'hide')
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__=='__main__':
self.setValue('showLayout', 'hide')
self.hide()
else:
self.setValue('showLayout', 'hide')
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
if w is None:
w = self.width()
if h is None:
h = self.height()
if x is None:
x = 0
if y is None:
y = 0
self.resize(int(w), int(h))
self.move(int(x), int(h))
if __name__=='__main__':
self.setValue('showLayout', 'show')
self.show()
else:
self.setValue('showLayout', 'show')
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
class Label(QLabel):
Type = 'DAMGUI'
key = 'Label'
_name = 'DAMG Label'
_copyright = __copyright__
def __init__(self, preset={}, parent=None):
QLabel.__init__(self)
self.parent = parent
self.preset = preset
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
if check_preset(self.preset):
self.buildUI()
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
def sizeHint(self):
size = super(Label, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__ == '__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__ == '__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__ == '__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
def buildUI(self):
for key, value in self.preset.items():
if key == 'txt':
self.setText(value)
elif key == 'fnt':
self.setFont(QFont(value))
elif key == 'alg':
self.setAlignment(PRS[value])
elif key == 'wmax':
self.setMaximumWidth(value)
elif key == 'wmin':
self.setMinimumWidth(value)
elif key == 'hmin':
self.setMinimumHeight(value)
elif key == 'smin':
self.setMinimumSize(value[0], value[1])
elif key == 'smax':
self.setMaximumSize(value[0], value[1])
elif key == 'sizePolicy':
self.setSizePolicy(PRS[value[0]], PRS[value[1]])
elif key == 'pxm':
self.setPixmap(Pixmap(value))
elif key == 'scc':
self.setScaledContents(value)
elif key == 'sfs':
self.setFixedSize(value[0], value[1])
elif key == 'setBuddy':
self.setBuddy(value)
elif key == 'link':
self.setOpenExternalLinks(value)
elif key == 'stt':
self.setToolTip(value)
elif key == 'sst':
self.setStatusTip(value)
elif key == 'sss':
self.setStyleSheet(value)
else:
print(
"PresetKeyError at {0}: No such key registed in preset: {1}: {2}"
.format(__name__, key, value))
class LineEdit(QLineEdit):
Type = 'DAMGUI'
key = 'LineEdit'
_name = 'DAMG Line Edit'
_copyright = __copyright__
def __init__(self, preset={}, parent=None):
super(LineEdit, self).__init__(parent)
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'], self)
self.parent = parent
self.preset = preset
if check_preset(self.preset):
self.buildUI()
self.values = dict(w = self.width(), h = self.height(), x = self.x(), y = self.y())
def sizeHint(self):
size = super(LineEdit, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__=='__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__=='__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__=='__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
def buildUI(self):
if self.preset is None or self.preset == {}:
self.preset = {'txt': ' '}
for key, value in self.preset.items():
if key == 'fn':
self.setEchoMode(PRS[value])
elif key == 'txt':
self.setText(value)
elif key == 'validator':
if value == 'int':
self.setValidator(QIntValidator())
elif key == 'echo':
if value == 'password':
self.setEchoMode(QLineEdit.Password)
else:
print("PresetKeyError at {0}: No such key registed in preset: {1}: {2}".format(__name__, key, value))
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 27/10/2019 - 6:40 PM
# © 2017 - 2018 DAMGteam. All rights reserved
class ToolBar(QToolBar):
Type = 'DAMGUI'
key = 'ToolBar'
_name = 'DAMG Tool Bar'
_copyright = __copyright__
actions = []
def __init__(self, parent=None):
QToolBar.__init__(self)
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)
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.setWindowTitle(self._name)
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
def add_action(self, action):
self.actions.append(action)
return self.addAction(action)
def sizeHint(self):
size = super(ToolBar, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__ == '__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__ == '__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__ == '__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 31/07/2018 - 12:50 AM
# © 2017 - 2018 DAMGteam. All rights reserved
class ToolButton(QToolButton):
Type = 'DAMGUI'
key = 'ToolButton'
_name = 'DAMG Tool Button'
_copyright = __copyright__
def __init__(self, text, parent=None):
QToolButton.__init__(self)
self.parent = parent
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.resize(40, 40)
self.setText(text)
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
def sizeHint(self):
size = super(ToolButton, self).sizeHint()
size.setHeight(size.height())
size.setWidth(max(size.width(), size.height()))
return size
def setValue(self, key, value):
return self.settings.initSetValue(key, value, self.key)
def getValue(self, key):
return self.settings.initValue(key, self.key)
def moveEvent(self, event):
if self.settings._settingEnable:
self.setValue('x', self.x())
self.setValue('y', self.y())
def resizeEvent(self, event):
if self.settings._settingEnable:
self.setValue('w', self.width())
self.setValue('h', self.height())
def closeEvent(self, event):
if __name__ == '__main__':
self.close()
else:
self.signals.emit('showLayout', self.key, 'hide')
def hideEvent(self, event):
if __name__ == '__main__':
self.hide()
else:
if self.settings._settingEnable:
for key, value in self.values.items():
self.setValue(key, value)
self.signals.emit('showLayout', self.key, 'hide')
def showEvent(self, event):
if self.settings._settingEnable:
w = self.getValue('w')
h = self.getValue('h')
x = self.getValue('x')
y = self.getValue('x')
vals = [w, h, x, y]
for i in range(len(vals)):
if vals[i] is None:
key = [k for k in self.values.keys()]
value = self.values[key[i]]
for index, element in enumerate(vals):
if element == vals[i]:
vals[index] = value
self.setValue(key[i], self.values[key[i]])
for v in vals:
if not type(v) in [int]:
v = int(v)
self.resize(vals[0], vals[1])
self.move(vals[2], vals[3])
if __name__ == '__main__':
self.show()
else:
self.signals.emit('showLayout', self.key, 'show')
@property
def copyright(self):
return self._copyright
@property
def name(self):
return self._name
@name.setter
def name(self, newName):
self._name = newName
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 18/07/2018 - 8:37 AM
# © 2017 - 2018 DAMGteam. All rights reserved