def seed_img(self, is_seed = True):
if is_seed:
try:
cseed = self.get_seed()
except UserCancelled:
return
except InvalidPassword as e:
self.d.show_error(str(e))
return
if not cseed:
self.d.show_message(_("This wallet has no seed"))
return
txt = cseed.upper()
else:
txt = self.txt.upper()
img = QImage(self.SIZE[0], self.SIZE[1], QImage.Format_Mono)
bitmap = QBitmap.fromImage(img, Qt.MonoOnly)
bitmap.fill(Qt.white)
painter = QPainter()
painter.begin(bitmap)
QFontDatabase.addApplicationFont(os.path.join(os.path.dirname(__file__), 'SourceSansPro-Bold.otf') )
if len(txt) < 102 :
fontsize = 15
linespace = 15
max_letters = 17
max_lines = 6
max_words = 3
else:
fontsize = 12
linespace = 10
max_letters = 21
max_lines = 9
max_words = int(max_letters/4)
font = QFont('Source Sans Pro', fontsize, QFont.Bold)
font.setLetterSpacing(QFont.PercentageSpacing, 100)
font.setPixelSize(fontsize)
painter.setFont(font)
seed_array = txt.split(' ')
for n in range(max_lines):
nwords = max_words
temp_seed = seed_array[:nwords]
while len(' '.join(map(str, temp_seed))) > max_letters:
nwords = nwords - 1
temp_seed = seed_array[:nwords]
painter.drawText(QRect(0, linespace*n , self.SIZE[0], self.SIZE[1]), Qt.AlignHCenter, ' '.join(map(str, temp_seed)))
del seed_array[:nwords]
painter.end()
img = bitmap.toImage()
if (self.rawnoise == False):
self.make_rawnoise()
self.make_cypherseed(img, self.rawnoise, False, is_seed)
return img
def display_content(self):
#
layout_main = QVBoxLayout()
layout_main.setAlignment(Qt.AlignCenter)
self.setLayout(layout_main)
self.layouts.append(layout_main)
#
fonts = QFontDatabase()
fonts.addApplicationFont('Fonts/Raleway/Raleway-ExtraLight.ttf')
fonts.addApplicationFont('Fonts/OpenSans/OpenSans-Light.ttf')
#
title = QLabel("Eight Puzzle")
title.setStyleSheet('font-size: 52px; color: #CECFD4;')
title.setFont(QFont('Raleway'))
layout_main.addWidget(title)
layout_main.addSpacerItem(QSpacerItem(0, 12))
#
layout_tiles = QGridLayout()
layout_tiles.setAlignment(Qt.AlignCenter)
layout_main.addLayout(layout_tiles)
for index in range(9):
tile = QPushButton(str(self.puzzle.state[index]))
tile.setStyleSheet('background-color: #879AA4;'
'color: #CECFD4; font-size: 32px;')
tile.setFont(QFont('Open Sans'))
tile.setFixedSize(75, 75)
tile.setEnabled(False)
tile.setFocusPolicy(Qt.NoFocus)
layout_tiles.addWidget(tile, index / 3, index % 3)
if self.puzzle.state[index] is '0':
tile.setVisible(False)
self.tiles.append(tile)
self.layouts.append(layout_tiles)
layout_main.addSpacerItem(QSpacerItem(0, 25))
#
layout_buttons = QGridLayout()
layout_buttons.setAlignment(Qt.AlignCenter)
layout_main.addLayout(layout_buttons)
for index in range(3):
button = QPushButton(['Shuffle', 'Solve', 'Quit'][index])
button.setStyleSheet('background-color: #CECFD4;'
'color: #363B57; font-size: 18px;')
button.setFont(QFont('Raleway'))
button.setFixedSize(90, 40)
button.setFocusPolicy(Qt.NoFocus)
layout_buttons.addWidget(button, 0, index)
self.buttons.append(button)
self.layouts.append(layout_buttons)
layout_main.addSpacerItem(QSpacerItem(0, 10))
def __init__(self):
super(MainWindow, self).__init__()
font_id = QFontDatabase.addApplicationFont("fontawesome-webfont.ttf")
if font_id is not -1:
font_db = QFontDatabase()
self.font_styles = font_db.styles('FontAwesome')
self.font_families = QFontDatabase.applicationFontFamilies(font_id)
print(self.font_styles, self.font_families)
for font_family in self.font_families:
self.font = font_db.font(font_family, self.font_styles[0], 18)
self.home()
def __init__(self):
super(Report, self).__init__()
self.status_view = "window"
self.status_colors = "light"
self.font_size = 22
self.font_database = QFontDatabase()
# add font cmtex9
self.font_file_cmtex9 = "cmtex9.ttf"
self.font_identifier_cmtex9 = QFontDatabase.addApplicationFont(
self.font_file_cmtex9
)
self.fontFamilyName_cmtex9 = self.font_database.applicationFontFamilies(
self.font_identifier_cmtex9
)[0]
self.update_font()
self.initialise_UI()
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None):
"""Loads a font file and the associated charmap
If `directory` is None, the files will be looked up in ./fonts/
Arguments
---------
prefix: str
prefix string to be used when accessing a given font set
ttf_filename: str
ttf font filename
charmap_filename: str
charmap filename
directory: str or None, optional
directory for font and charmap files
"""
def hook(obj):
result = {}
for key in obj:
result[key] = unichr(int(obj[key], 16))
return result
if directory is None:
directory = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'fonts')
with open(os.path.join(directory, charmap_filename), 'r') as codes:
self.charmap[prefix] = json.load(codes, object_hook=hook)
id_ = QFontDatabase.addApplicationFont(os.path.join(directory, ttf_filename))
loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_)
if loadedFontFamilies:
self.fontname[prefix] = loadedFontFamilies[0]
else:
print('Font is empty')
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
# Log some basic system info
try:
v = openshot.GetVersion()
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" % v.ToString())
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except:
pass
# Setup application
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
self.settings.load()
# Init and attach exception handler
from classes import exceptions
sys.excepthook = exceptions.ExceptionHandler
# Init translation system
language.init_language()
# Detect minimum libopenshot version
_ = self._tr
libopenshot_version = openshot.GetVersion().ToString()
if mode != "unittest" and libopenshot_version < info.MINIMUM_LIBOPENSHOT_VERSION:
QMessageBox.warning(None, _("Wrong Version of libopenshot Detected"),
_("<b>Version %(minimum_version)s is required</b>, but %(current_version)s was detected. Please update libopenshot or download our latest installer.") %
{"minimum_version": info.MINIMUM_LIBOPENSHOT_VERSION, "current_version": libopenshot_version})
# Stop launching and exit
sys.exit()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
try:
log.info("Setting font to %s" % os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception as ex:
log.error("Error setting Ubuntu-R.ttf QFont: %s" % str(ex))
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
darkPalette.setColor(QPalette.Disabled, QPalette.Text, QColor(104, 104, 104))
self.setPalette(darkPalette)
self.setStyleSheet("QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }")
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow(mode)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.OpenProjectSignal.emit(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
else:
# Recover backup file (this can't happen until after the Main Window has completely loaded)
self.window.RecoverBackup.emit()
y = (self.height() + metrics.ascent() - metrics.descent()) / 2
for i, ch in enumerate(self.text()):
index = (self.step + i) % 16
painter.setPen(TCOLORLIST[qrand() % 6])
painter.drawText(x,
y - ((SINETABLE[index] * metrics.height()) / 400),
ch)
x += metrics.width(ch)
if __name__ == "__main__":
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QHBoxLayout
from PyQt5.QtGui import QFontDatabase
from PyQt5.QtWidgets import QLineEdit
app = QApplication(sys.argv)
app.setApplicationName("Validate Code")
QFontDatabase.addApplicationFont("Data/itckrist.ttf")
w = QWidget()
layout = QHBoxLayout(w)
cwidget = WidgetCode(w, minimumHeight=35, minimumWidth=80)
layout.addWidget(cwidget)
lineEdit = QLineEdit(
w,
maxLength=4,
placeholderText="请输入验证码并按回车验证",
returnPressed=lambda: print(cwidget.check(lineEdit.text())))
layout.addWidget(lineEdit)
w.show()
sys.exit(app.exec_())
from PyQt5.QtWidgets import QApplication
from PyQt5.QtGui import QIcon, QFontDatabase
from .gui.mainwindow import MainWindow
from .utils import path
if __name__ == '__main__':
app = QApplication(sys.argv)
app.setStyle('Fusion')
app.setApplicationName("Agent Scrat")
app_icon = QIcon(path('images/nut.png'))
app.setWindowIcon(app_icon)
# windows taskbar icon issues
# solution from
# https://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7/1552105#1552105
if os.name == 'nt':
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
'Agent Scrat')
# must be done after application initialization
QFontDatabase.addApplicationFont(path("fonts/Pacifico-Regular.ttf"))
mainwindow = MainWindow()
mainwindow.show()
sys.exit(app.exec_())
def __init__(self,
splash,
nexicoBase,
config,
selectionName="standard",
parent=None):
"""
Constructor
"""
QMainWindow.__init__(self)
self.setupUi(self)
qfdb = QFontDatabase()
fi = qfdb.addApplicationFont(":fonts/resources/FreeSans.otf")
try:
self.font = qfdb.font(
qfdb.applicationFontFamilies(fi)[0], "Light", False)
except:
self.font = None
self.config = config
self.nbBestKids = int(self.config["configuration"]["nbBestKids"])
self.currentSection = None
self.selectedWord = ""
self.selectedTokeni = None
self.sectList = []
self.base = nexicoBase
self.wordTableWidget.setHorizontalHeaderLabels(
[self.tr("word"), self.tr("frequency")])
self.autoSelect = 0
false_positives = set(["aliases", "undefined"])
self.encodings = set(
name
for imp, name, ispkg in pkgutil.iter_modules(encodings.__path__)
if not ispkg)
self.encodings.difference_update(false_positives)
self.encodings = sorted(self.encodings)
self.statusbar.showMessage(self.tr("Welcome!"), 20000)
self.fileNameEdit.setText(selectionName)
self.pb = QtWidgets.QProgressBar(self.statusBar())
self.statusBar().addPermanentWidget(self.pb)
self.pb.hide()
self.splash = splash
self.selecting = False
self.graphicsView.setRenderHints(
QtGui.QPainter.Antialiasing
or QtGui.QPainter.SmoothPixmapTransform)
self.ngra = self.ngraDial.sliderPosition()
self.renoword = re.compile("\W+$", re.U + re.I + re.M)
self.webView = QWebView()
self.collocations = Collocations(self)
#self.gridLayout_3.addWidget(self.graphcanvas, 0, 0, 1, 1)
self.gridLayout_3.addWidget(self.webView, 0, 0, 1, 1)
# start with collocation open?
#openwithcolloc=int(self.config["configuration"]["openwithcolloc"]) # False
openwithcolloc = False
self.actionCollocations.setChecked(openwithcolloc)
self.on_actionCollocations_toggled(openwithcolloc)
#self.graphButton.setChecked(True)
#self.specos=None # dict of collocations for current word
# TODO: solve the memory problem of qsplitter:
#self.hsplitter=QSplitter(1, self.centralwidget) # 2=vertical orientation
#self.centralGridLayout.addWidget(self.hsplitter, 0, 1)
#self.vspgridLayout = QtGui.QGridLayout(self.hsplitter)
#self.vspgridLayout.setSpacing(0)
#self.hsplitter.setHandleWidth(8)
#self.vspgridLayout.setContentsMargins(2, 0, 2, 0)
#self.vspgridLayout.addWidget(self.westwidget, 0, 0)
#self.vspgridLayout.addWidget(self.eastwidget)
self.load()
self.filter.textChanged.connect(self.filterChanged)
self.colfilter.textChanged.connect(self.colfilterChanged)
self.recenter = RecenterClass()
def load_font(self, prefix, ttf_filename, charmap_filename, directory=None):
"""Loads a font file and the associated charmap.
If ``directory`` is None, the files will be looked for in ``./fonts/``.
Parameters
----------
prefix: str
Prefix string to be used when accessing a given font set
ttf_filename: str
Ttf font filename
charmap_filename: str
Charmap filename
directory: str or None, optional
Directory for font and charmap files
"""
def hook(obj):
result = {}
for key in obj:
result[key] = unichr(int(obj[key], 16))
return result
if directory is None:
directory = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'fonts')
# Load font
if QApplication.instance() is not None:
id_ = QFontDatabase.addApplicationFont(os.path.join(directory,
ttf_filename))
loadedFontFamilies = QFontDatabase.applicationFontFamilies(id_)
if(loadedFontFamilies):
self.fontname[prefix] = loadedFontFamilies[0]
else:
raise FontError(u"Font at '{0}' appears to be empty. "
"If you are on Windows 10, please read "
"https://support.microsoft.com/"
"en-us/kb/3053676 "
"to know how to prevent Windows from blocking "
"the fonts that come with QtAwesome.".format(
os.path.join(directory, ttf_filename)))
with open(os.path.join(directory, charmap_filename), 'r') as codes:
self.charmap[prefix] = json.load(codes, object_hook=hook)
# Verify that vendorized fonts are not corrupt
if not SYSTEM_FONTS:
md5_hashes = {'fontawesome-webfont.ttf':
'b06871f281fee6b241d60582ae9369b9',
'elusiveicons-webfont.ttf':
'207966b04c032d5b873fd595a211582e'}
ttf_hash = md5_hashes.get(ttf_filename, None)
if ttf_hash is not None:
hasher = hashlib.md5()
with open(os.path.join(directory, ttf_filename),
'rb') as f:
content = f.read()
hasher.update(content)
ttf_calculated_hash_code = hasher.hexdigest()
if ttf_calculated_hash_code != ttf_hash:
raise FontError(u"Font is corrupt at: '{0}'".format(
os.path.join(directory, ttf_filename)))
def loadFont(cls):
"""加载外部字体"""
path = os.path.join(Settings().dataDir, "fonts")
for font in os.listdir(path):
QFontDatabase.addApplicationFont(os.path.join(path, font))
def __init__(self, dwarf_args, flags=None):
super(AppWindow, self).__init__(flags)
self.dwarf_args = dwarf_args
self.session_manager = SessionManager(self)
self.session_manager.sessionCreated.connect(self.session_created)
self.session_manager.sessionStopped.connect(self.session_stopped)
self.session_manager.sessionClosed.connect(self.session_closed)
self._tab_order = [
'memory', 'modules', 'ranges', 'jvm-inspector', 'jvm-debugger'
]
self.menu = self.menuBar()
self._is_newer_dwarf = False
self.view_menu = None
#dockwidgets
self.watchers_dwidget = None
self.hooks_dwiget = None
self.bookmarks_dwiget = None
self.registers_dock = None
self.console_dock = None
self.backtrace_dock = None
self.threads_dock = None
#panels
self.asm_panel = None
self.console_panel = None
self.context_panel = None
self.backtrace_panel = None
self.contexts_list_panel = None
self.data_panel = None
self.emulator_panel = None
self.ftrace_panel = None
self.hooks_panel = None
self.bookmarks_panel = None
self.smali_panel = None
self.java_inspector_panel = None
self.java_explorer_panel = None
self.java_trace_panel = None
self.memory_panel = None
self.modules_panel = None
self.ranges_panel = None
self.search_panel = None
self.trace_panel = None
self.watchers_panel = None
self.welcome_window = None
self._ui_elems = []
self.setWindowTitle(
'Dwarf - A debugger for reverse engineers, crackers and security analyst'
)
# load external assets
_app = QApplication.instance()
self.remove_tmp_dir()
# themes
self.prefs = Prefs()
self.set_theme(self.prefs.get('dwarf_ui_theme', 'black'))
# load font
if os.path.exists(utils.resource_path('assets/Anton.ttf')):
QFontDatabase.addApplicationFont(
utils.resource_path('assets/Anton.ttf'))
if os.path.exists(utils.resource_path('assets/OpenSans-Regular.ttf')):
QFontDatabase.addApplicationFont(
utils.resource_path('assets/OpenSans-Regular.ttf'))
_app.setFont(QFont("OpenSans", 9, QFont.Normal))
if os.path.exists(utils.resource_path('assets/OpenSans-Bold.ttf')):
QFontDatabase.addApplicationFont(
utils.resource_path('assets/OpenSans-Bold.ttf'))
# mainwindow statusbar
self.progressbar = QProgressBar()
self.progressbar.setRange(0, 0)
self.progressbar.setVisible(False)
self.progressbar.setFixedHeight(15)
self.progressbar.setFixedWidth(100)
self.progressbar.setTextVisible(False)
self.progressbar.setValue(30)
self.statusbar = QStatusBar(self)
self.statusbar.setAutoFillBackground(False)
self.statusbar.addPermanentWidget(self.progressbar)
self.statusbar.setObjectName("statusbar")
self.setStatusBar(self.statusbar)
self.main_tabs = QTabWidget(self)
self.main_tabs.setMovable(False)
self.main_tabs.setTabsClosable(True)
self.main_tabs.setAutoFillBackground(True)
self.main_tabs.tabCloseRequested.connect(self._on_close_tab)
self.setCentralWidget(self.main_tabs)
if self.dwarf_args.package is None:
self.welcome_window = WelcomeDialog(self)
self.welcome_window.setModal(True)
self.welcome_window.onIsNewerVersion.connect(
self._enable_update_menu)
self.welcome_window.onUpdateComplete.connect(
self._on_dwarf_updated)
self.welcome_window.setWindowTitle(
'Welcome to Dwarf - A debugger for reverse engineers, crackers and security analyst'
)
self.welcome_window.onSessionSelected.connect(self._start_session)
self.welcome_window.onSessionRestore.connect(self._restore_session)
# wait for welcome screen
self.hide()
self.welcome_window.show()
else:
if dwarf_args.package is not None:
if dwarf_args.type is None:
# no device given check if package is local path
if os.path.exists(dwarf_args.package):
print('* Starting new LocalSession')
self._start_session('local')
else:
print('use -t to set sessiontype')
exit(0)
else:
print('* Starting new Session')
self._start_session(dwarf_args.type)
def __init__(self):
super(MainWindow, self).__init__()
uic.loadUi(appctxt.get_resource('mainwindow.ui'), self)
# Initial Conditions
self.memory = {
"memA": {
"freq": 96.9e6,
"band": "FM"
},
"memB": {
"freq": 94.5e6,
"band": "FM"
},
"memC": {
"freq": 97.5e6,
"band": "FM"
},
"memD": {
"freq": 95.5e6,
"band": "FM"
},
"memE": {
"freq": 87.9e6,
"band": "FM"
},
}
self.freq = 96.9e6
self.running = False
self.mode = 0
self.tau = 75e-6
# Universal Demodulator Configuration
self.demod = Demodulator(self.freq)
# Display Update Timer
self.displayTimer = QTimer(self)
self.displayTimer.setInterval(500)
self.displayTimer.timeout.connect(self.updateDisplay)
# Devices Update Timer
self.deviceCheckTimer = QTimer(self)
self.deviceCheckTimer.setInterval(1000)
self.deviceCheckTimer.timeout.connect(self.updateDevices)
self.deviceCheckTimer.start()
self.updateDevices()
# Activate First Device
self.handleDevice(quiet=True)
# Text Setting with Initial Conditions
self.updateMemoryBtn()
self.setFreq(self.freq)
# Value Setting with Initial Conditions
self.setWindowTitle("CyberRadio")
self.volume.setValue(self.demod.vol * 100)
# Buttons Handlers Declaration
self.modFmBtn.clicked.connect(self.handleFm)
self.modAmBtn.clicked.connect(self.handleAm)
self.powerBtn.clicked.connect(self.handlePower)
self.memA.clicked.connect(self.handleMemory)
self.memB.clicked.connect(self.handleMemory)
self.memC.clicked.connect(self.handleMemory)
self.memD.clicked.connect(self.handleMemory)
self.memE.clicked.connect(self.handleMemory)
# Load Custom Fonts
QFontDatabase.addApplicationFont(
appctxt.get_resource('fonts/Comfortaa-VariableFont.ttf'))
QFontDatabase.addApplicationFont(
appctxt.get_resource('fonts/RacingSansOne-Regular.ttf'))
QFontDatabase.addApplicationFont(
appctxt.get_resource('fonts/RobotoMono-Bold.ttf'))
QFontDatabase.addApplicationFont(
appctxt.get_resource('fonts/RobotoMono-Regular.ttf'))
# Change Handlers
self.freqLine.editingFinished.connect(self.handleFreq)
self.volume.valueChanged.connect(self.handleVol)
self.deviceBox.currentTextChanged.connect(self.handleDevice)
# Custom Stylecheet
self.volume.setStyleSheet(volumeStyle())
self.deviceBox.setStyleSheet(
comboStyle(appctxt.get_resource('down_arrow.png')))
self.uiToggle(False)
# Show Window
self.center()
self.show()
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
# Log some basic system info
try:
v = openshot.GetVersion()
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" % v.ToString())
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except:
pass
# Setup appication
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
try:
self.settings.load()
except Exception as ex:
log.error("Couldn't load user settings. Exiting.\n{}".format(ex))
exit()
# Init translation system
language.init_language()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set unique install id (if blank)
if not self.settings.get("unique_install_id"):
self.settings.set("unique_install_id", str(uuid4()))
# Track 1st launch metric
import classes.metrics
classes.metrics.track_metric_screen("initial-launch-screen")
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
try:
log.info("Setting font to %s" % os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception as ex:
log.error("Error setting Ubuntu-R.ttf QFont: %s" % str(ex))
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
darkPalette.setColor(QPalette.Disabled, QPalette.Text, QColor(104, 104, 104))
self.setPalette(darkPalette)
self.setStyleSheet("QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }")
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow(mode)
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.open_project(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
def load(self, path: str, is_first_call: bool = True) -> None:
if path == self._path:
return
with open(os.path.join(path, "theme.json"), encoding = "utf-8") as f:
Logger.log("d", "Loading theme file: %s", os.path.join(path, "theme.json"))
data = json.load(f)
# Iteratively load inherited themes
try:
theme_id = data["metadata"]["inherits"]
self.load(Resources.getPath(Resources.Themes, theme_id), is_first_call = False)
except FileNotFoundError:
Logger.log("e", "Could not find inherited theme %s", theme_id)
except KeyError:
pass # No metadata or no inherits keyword in the theme.json file
if "colors" in data:
for name, color in data["colors"].items():
c = QColor(color[0], color[1], color[2], color[3])
self._colors[name] = c
fonts_dir = os.path.join(path, "fonts")
if os.path.isdir(fonts_dir):
for file in os.listdir(fonts_dir):
if "ttf" in file:
QFontDatabase.addApplicationFont(os.path.join(fonts_dir, file))
if "fonts" in data:
system_font_size = QCoreApplication.instance().font().pointSize()
for name, font in data["fonts"].items():
q_font = QFont()
q_font.setFamily(font.get("family", QCoreApplication.instance().font().family()))
if font.get("bold"):
q_font.setBold(font.get("bold", False))
else:
q_font.setWeight(font.get("weight", 50))
q_font.setLetterSpacing(QFont.AbsoluteSpacing, font.get("letterSpacing", 0))
q_font.setItalic(font.get("italic", False))
q_font.setPointSize(int(font.get("size", 1) * system_font_size))
q_font.setCapitalization(QFont.AllUppercase if font.get("capitalize", False) else QFont.MixedCase)
self._fonts[name] = q_font
if "sizes" in data:
for name, size in data["sizes"].items():
s = QSizeF()
s.setWidth(round(size[0] * self._em_width))
s.setHeight(round(size[1] * self._em_height))
self._sizes[name] = s
iconsdir = os.path.join(path, "icons")
if os.path.isdir(iconsdir):
for icon in os.listdir(iconsdir):
name = os.path.splitext(icon)[0]
self._icons[name] = QUrl.fromLocalFile(os.path.join(iconsdir, icon))
imagesdir = os.path.join(path, "images")
if os.path.isdir(imagesdir):
for image in os.listdir(imagesdir):
name = os.path.splitext(image)[0]
self._images[name] = QUrl.fromLocalFile(os.path.join(imagesdir, image))
styles = os.path.join(path, "styles.qml")
if os.path.isfile(styles):
c = QQmlComponent(self._engine, styles)
context = QQmlContext(self._engine, self._engine)
context.setContextProperty("Theme", self)
self._styles = c.create(context)
if c.isError():
for error in c.errors():
Logger.log("e", error.toString())
Logger.log("d", "Loaded theme %s", path)
self._path = path
# only emit the theme loaded signal once after all the themes in the inheritance chain have been loaded
if is_first_call:
self.themeLoaded.emit()
def overlay_marks(self, img, is_cseed=False, calibration_sheet=False):
border_color = Qt.white
base_img = QImage(self.f_size.width(),self.f_size.height(), QImage.Format_ARGB32)
base_img.fill(border_color)
img = QImage(img)
painter = QPainter()
painter.begin(base_img)
total_distance_h = round(base_img.width() / self.abstand_v)
dist_v = round(total_distance_h) / 2
dist_h = round(total_distance_h) / 2
img = img.scaledToWidth(base_img.width() - (2 * (total_distance_h)))
painter.drawImage(total_distance_h,
total_distance_h,
img)
#frame around image
pen = QPen(Qt.black, 2)
painter.setPen(pen)
#horz
painter.drawLine(0, total_distance_h, base_img.width(), total_distance_h)
painter.drawLine(0, base_img.height()-(total_distance_h), base_img.width(), base_img.height()-(total_distance_h))
#vert
painter.drawLine(total_distance_h, 0, total_distance_h, base_img.height())
painter.drawLine(base_img.width()-(total_distance_h), 0, base_img.width()-(total_distance_h), base_img.height())
#border around img
border_thick = 6
Rpath = QPainterPath()
Rpath.addRect(QRectF((total_distance_h)+(border_thick/2),
(total_distance_h)+(border_thick/2),
base_img.width()-((total_distance_h)*2)-((border_thick)-1),
(base_img.height()-((total_distance_h))*2)-((border_thick)-1)))
pen = QPen(Qt.black, border_thick)
pen.setJoinStyle (Qt.MiterJoin)
painter.setPen(pen)
painter.drawPath(Rpath)
Bpath = QPainterPath()
Bpath.addRect(QRectF((total_distance_h), (total_distance_h),
base_img.width()-((total_distance_h)*2), (base_img.height()-((total_distance_h))*2)))
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawPath(Bpath)
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawLine(0, base_img.height()/2, total_distance_h, base_img.height()/2)
painter.drawLine(base_img.width()/2, 0, base_img.width()/2, total_distance_h)
painter.drawLine(base_img.width()-total_distance_h, base_img.height()/2, base_img.width(), base_img.height()/2)
painter.drawLine(base_img.width()/2, base_img.height(), base_img.width()/2, base_img.height() - total_distance_h)
#print code
f_size = 37
QFontDatabase.addApplicationFont(os.path.join(os.path.dirname(__file__), 'DejaVuSansMono-Bold.ttf'))
font = QFont("DejaVu Sans Mono", f_size-11, QFont.Bold)
font.setPixelSize(35)
painter.setFont(font)
if not calibration_sheet:
if is_cseed: #its a secret
painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
painter.drawImage(((total_distance_h))+11, ((total_distance_h))+11,
QImage(icon_path('electrumb.png')).scaledToWidth(2.1*(total_distance_h), Qt.SmoothTransformation))
painter.setPen(QPen(Qt.white, border_thick*8))
painter.drawLine(base_img.width()-((total_distance_h))-(border_thick*8)/2-(border_thick/2)-2,
(base_img.height()-((total_distance_h)))-((border_thick*8)/2)-(border_thick/2)-2,
base_img.width()-((total_distance_h))-(border_thick*8)/2-(border_thick/2)-2 - 77,
(base_img.height()-((total_distance_h)))-((border_thick*8)/2)-(border_thick/2)-2)
painter.setPen(QColor(0,0,0,255))
painter.drawText(QRect(0, base_img.height()-107, base_img.width()-total_distance_h - border_thick - 11,
base_img.height()-total_distance_h - border_thick), Qt.AlignRight,
self.versioned_seed.version + '_'+self.versioned_seed.checksum)
painter.end()
else: # revealer
painter.setPen(QPen(border_color, 17))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
logo = QImage(icon_path('revealer_c.png')).scaledToWidth(1.3*(total_distance_h))
painter.drawImage((total_distance_h)+ (border_thick), ((total_distance_h))+ (border_thick), logo, Qt.SmoothTransformation)
#frame around logo
painter.setPen(QPen(Qt.black, border_thick))
painter.drawLine(total_distance_h+border_thick, total_distance_h+logo.height()+3*(border_thick/2),
total_distance_h+logo.width()+border_thick, total_distance_h+logo.height()+3*(border_thick/2))
painter.drawLine(logo.width()+total_distance_h+3*(border_thick/2), total_distance_h+(border_thick),
total_distance_h+logo.width()+3*(border_thick/2), total_distance_h+logo.height()+(border_thick))
#frame around code/qr
qr_size = 179
painter.drawLine((base_img.width()-((total_distance_h))-(border_thick/2)-2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2,
(base_img.width()/2+(total_distance_h/2)-border_thick-(border_thick*8)/2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2)
painter.drawLine((base_img.width()/2+(total_distance_h/2)-border_thick-(border_thick*8)/2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2,
base_img.width()/2 + (total_distance_h/2)-border_thick-(border_thick*8)/2-qr_size,
((base_img.height()-((total_distance_h)))-(border_thick/2)-2))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) - (border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) - border_thick - qr_size,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0,0,0,255))
painter.drawText(QRect(((base_img.width()/2) +21)-qr_size, base_img.height()-107,
base_img.width()-total_distance_h - border_thick -93,
base_img.height()-total_distance_h - border_thick), Qt.AlignLeft, self.versioned_seed.get_ui_string_version_plus_seed())
painter.drawText(QRect(0, base_img.height()-107, base_img.width()-total_distance_h - border_thick -3 -qr_size,
base_img.height()-total_distance_h - border_thick), Qt.AlignRight, self.versioned_seed.checksum)
# draw qr code
qr_qt = self.paintQR(self.versioned_seed.get_ui_string_version_plus_seed()
+ self.versioned_seed.checksum)
target = QRectF(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
qr_size, qr_size )
painter.drawImage(target, qr_qt)
painter.setPen(QPen(Qt.black, 4))
painter.drawLine(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
base_img.width() - 65 - qr_size,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8)) - (border_thick / 2) - 4
)
painter.drawLine(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
base_img.width() - 65,
base_img.height()-65-qr_size
)
painter.end()
else: # calibration only
painter.end()
cal_img = QImage(self.f_size.width() + 100, self.f_size.height() + 100,
QImage.Format_ARGB32)
cal_img.fill(Qt.white)
cal_painter = QPainter()
cal_painter.begin(cal_img)
cal_painter.drawImage(0,0, base_img)
#black lines in the middle of border top left only
cal_painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
cal_painter.drawLine(0, dist_v, base_img.width(), dist_v)
cal_painter.drawLine(dist_h, 0, dist_h, base_img.height())
pen = QPen(Qt.black, 2, Qt.DashDotDotLine)
cal_painter.setPen(pen)
n=15
cal_painter.setFont(QFont("DejaVu Sans Mono", 21, QFont.Bold))
for x in range(-n,n):
#lines on bottom (vertical calibration)
cal_painter.drawLine((((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)-13,
x+2+base_img.height()-(dist_v),
(((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)+13,
x+2+base_img.height()-(dist_v))
num_pos = 9
if x > 9 : num_pos = 17
if x < 0 : num_pos = 20
if x < -9: num_pos = 27
cal_painter.drawText((((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)-num_pos,
50+base_img.height()-(dist_v),
str(x))
#lines on the right (horizontal calibrations)
cal_painter.drawLine(x+2+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/n)+(base_img.height()/2)-13,
x+2+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/n)+(base_img.height()/2)+13)
cal_painter.drawText(30+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/2)+13, str(x))
cal_painter.end()
base_img = cal_img
return base_img
def set_gui_constants(parent):
# TODO: after the design is settled, remove unnecessary font files
weights = {'ExtraLight', 'Light', 'Semibold', 'Bold', 'Black'}
weights ^= set(s + 'It' for s in copy(weights))
weights ^= {'Regular', 'It'}
# Load fonts
fonts = QFontDatabase()
for weight in weights:
fonts.addApplicationFont(os_path_join(_FONT_PATH,
'SourceSansPro-{}.ttf'.format(weight)))
# TODO: distinguish in names:
# type_palette_property and type_color_property
# Palettes
CONSTANTS['text_color_dark'] = _palette(parent, FOREGROUND, '000000', 45)
CONSTANTS['text_color_light'] = _palette(parent, FOREGROUND, 'ffffff', 30)
CONSTANTS['text_color_light_selected'] = _palette(parent, FOREGROUND, 'ffffff', 85)
# CONSTANTS['panel_color_light'] = _palette(parent, BACKGROUND, '808080')
CONSTANTS['panel_color_dark'] = _palette(parent, BACKGROUND, '303030')
CONSTANTS['panel_color_darker'] = _palette(parent, BACKGROUND, '101010')
CONSTANTS['panel_color_error'] = _palette(parent, BACKGROUND, '000000', 35)
# Colors
CONSTANTS['shadow_color'] = _color('000000', 70)
CONSTANTS['panel_color_light'] = _color('808080')
DEBUG_ALPHA = 40
CONSTANTS['debug1'] = _color('ffff00', DEBUG_ALPHA)
CONSTANTS['debug2'] = _color('00ffff', DEBUG_ALPHA)
CONSTANTS['debug3'] = _color('ff00ff', DEBUG_ALPHA)
CONSTANTS['debug4'] = _color('ff0000', DEBUG_ALPHA)
CONSTANTS['debug5'] = _color('00ff00', DEBUG_ALPHA)
CONSTANTS['debug6'] = _color('0000ff', DEBUG_ALPHA)
# Fonts
CONSTANTS['text_font_title'] = QFont(_SANS, 16, QFont.Light)
CONSTANTS['text_font_author'] = QFont(_SANS, 10, QFont.Normal, italic=True)
CONSTANTS['text_font_numbers'] = QFont(_SANS, 12, QFont.Normal)
CONSTANTS['text_font_generic'] = QFont(_SANS, 10, QFont.Normal)
# Icons
CONSTANTS['icon_scroll_up'] = _icon('icons_scroll.png')
CONSTANTS['icon_scroll_down'] = _icon('icons_scroll.png', rotate=180)
CONSTANTS['icon_recoub'] = _icon('icons_share.png')
CONSTANTS['icon_like'] = _icon('icons_like.png')
CONSTANTS['icon_featured'] = _icon('icons_featured.png')
CONSTANTS['icon_newest'] = _icon('icons_newest.png')
CONSTANTS['icon_random'] = _icon('icons_random.png')
CONSTANTS['icon_hot'] = _icon('icons_hot.png')
CONSTANTS['icon_featured_selected'] = _icon('icons_featured_selected.png')
CONSTANTS['icon_newest_selected'] = _icon('icons_newest_selected.png')
CONSTANTS['icon_random_selected'] = _icon('icons_random_selected.png')
CONSTANTS['icon_hot_selected'] = _icon('icons_hot_selected.png')
# Other images
CONSTANTS['icon_no_avatar'] = _static('no_avatar.png')
CONSTANTS['other_separator'] = _static('separator.png')
# Animation
CONSTANTS['anim_busy_dark'] = os_path_join(_BASE_PATH, 'motion', 'dark_loader.gif')
CONSTANTS['anim_busy_light'] = os_path_join(_BASE_PATH, 'motion', 'light_loader.gif')
def load(self, path):
if path == self._path:
return
self._path = path
with open(os.path.join(self._path, "theme.json")) as f:
Logger.log("d", "Loading theme file: %s", os.path.join(self._path, "theme.json"))
data = json.load(f)
self._initializeDefaults()
if "colors" in data:
for name, color in data["colors"].items():
c = QColor(color[0], color[1], color[2], color[3])
self._colors[name] = c
fontsdir = os.path.join(self._path, "fonts")
if os.path.isdir(fontsdir):
for file in os.listdir(fontsdir):
if "ttf" in file:
QFontDatabase.addApplicationFont(os.path.join(fontsdir, file))
if "fonts" in data:
for name, font in data["fonts"].items():
f = QFont()
f.setFamily(font.get("family", QCoreApplication.instance().font().family()))
f.setBold(font.get("bold", False))
f.setLetterSpacing(QFont.AbsoluteSpacing, font.get("letterSpacing", 0))
f.setItalic(font.get("italic", False))
f.setPixelSize(font.get("size", 1) * self._em_height)
f.setCapitalization(QFont.AllUppercase if font.get("capitalize", False) else QFont.MixedCase)
self._fonts[name] = f
if "sizes" in data:
for name, size in data["sizes"].items():
s = QSizeF()
s.setWidth(round(size[0] * self._em_width))
s.setHeight(round(size[1] * self._em_height))
self._sizes[name] = s
iconsdir = os.path.join(self._path, "icons")
if os.path.isdir(iconsdir):
for icon in os.listdir(iconsdir):
name = os.path.splitext(icon)[0]
self._icons[name] = QUrl.fromLocalFile(os.path.join(iconsdir, icon))
imagesdir = os.path.join(self._path, "images")
if os.path.isdir(imagesdir):
for image in os.listdir(imagesdir):
name = os.path.splitext(image)[0]
self._images[name] = QUrl.fromLocalFile(os.path.join(imagesdir, image))
styles = os.path.join(self._path, "styles.qml")
if os.path.isfile(styles):
c = QQmlComponent(self._engine, styles)
context = QQmlContext(self._engine, self._engine)
context.setContextProperty("Theme", self)
self._styles = c.create(context)
if c.isError():
for error in c.errors():
Logger.log("e", error.toString())
Logger.log("d", "Loaded theme %s", self._path)
self.themeLoaded.emit()
"""
self.username = self.ui.username_textbox.text()
self.registration_thread = RegisterThread(username=self.username, user_check=True)
self.registration_thread.signals.clear_textboxes_signal.connect(self.clear_all_textbox)
self.registration_thread.signals.disable_widgets_signal.connect(self.disable_widgets)
self.registration_thread.signals.popup_signal.connect(self.popup_msg)
self.registration_thread.signals.label_update_signal.connect(self.update_progress_label)
self.registration_thread.signals.play_splash_signal.connect(self.play_splash)
self.thread_pool.start(self.registration_thread)
@Slot()
def closeEvent(self, event):
"""
This function is a slot function for when the user clicks the red button to exit the window.
:param event: is the event object, so in this case, the even is closing the application (we either accept or reject)
"""
with open(_config, 'r'):
self.config['Default']['sponsor'] = self.ui.sponsor_textbox.text()
with open(_config, 'w') as config:
self.config.write(config)
event.accept()
if __name__ == '__main__':
app = QApplication(sys.argv)
QFontDatabase.addApplicationFont(_font)
app.setStyle('Fusion')
window = MainWindow()
sys.exit(app.exec_())
def __init__(self, dwarf_args, flags=None):
super(AppWindow, self).__init__(flags)
self.dwarf_args = dwarf_args
self.session_manager = SessionManager(self)
self.session_manager.sessionCreated.connect(self.session_created)
self.session_manager.sessionStopped.connect(self.session_stopped)
self.session_manager.sessionClosed.connect(self.session_closed)
self._tab_order = [
'debug', 'modules', 'ranges', 'jvm-inspector', 'jvm-debugger'
]
self._is_newer_dwarf = False
self.q_settings = QSettings(utils.home_path() + "dwarf_window_pos.ini",
QSettings.IniFormat)
self.menu = self.menuBar()
self.view_menu = None
# dockwidgets
self.watchpoints_dwidget = None
self.breakpoint_dwiget = None
self.bookmarks_dwiget = None
self.registers_dock = None
self.console_dock = None
self.backtrace_dock = None
self.threads_dock = None
# panels
self.asm_panel = None
self.backtrace_panel = None
self.bookmarks_panel = None
self.console_panel = None
self.context_panel = None
self.debug_panel = None
self.contexts_list_panel = None
self.data_panel = None
self.ftrace_panel = None
self.breakpoints_panel = None
self.objc_inspector_panel = None
self.java_inspector_panel = None
self.java_explorer_panel = None
self.java_trace_panel = None
self.modules_panel = None
self.ranges_panel = None
self.search_panel = None
self.smali_panel = None
self.watchpoints_panel = None
self._ui_elems = []
self.setWindowTitle(
'Dwarf - A debugger for reverse engineers, crackers and security analyst'
)
# load external assets
_app = QApplication.instance()
# themes
self.prefs = Prefs()
utils.set_theme(self.prefs.get('dwarf_ui_theme', 'dark'), self.prefs)
# load font
if os.path.exists(utils.resource_path('assets/Anton.ttf')):
QFontDatabase.addApplicationFont(
utils.resource_path('assets/Anton.ttf'))
else:
QFontDatabase.addApplicationFont(':/assets/Anton.ttf')
if os.path.exists(utils.resource_path('assets/OpenSans-Regular.ttf')):
QFontDatabase.addApplicationFont(
utils.resource_path('assets/OpenSans-Regular.ttf'))
else:
QFontDatabase.addApplicationFont(':/assets/OpenSans-Regular.ttf')
if os.path.exists(utils.resource_path('assets/OpenSans-Bold.ttf')):
QFontDatabase.addApplicationFont(
utils.resource_path('assets/OpenSans-Bold.ttf'))
else:
QFontDatabase.addApplicationFont(':/assets/OpenSans-Bold.ttf')
font = QFont("OpenSans", 9, QFont.Normal)
# TODO: add settingsdlg
font_size = self.prefs.get('dwarf_ui_font_size', 12)
font.setPixelSize(font_size)
_app.setFont(font)
# mainwindow statusbar
self.progressbar = QProgressBar()
self.progressbar.setRange(0, 0)
self.progressbar.setVisible(False)
self.progressbar.setFixedHeight(15)
self.progressbar.setFixedWidth(100)
self.progressbar.setTextVisible(False)
self.progressbar.setValue(30)
self.statusbar = QStatusBar(self)
self.statusbar.setAutoFillBackground(False)
self.statusbar.addPermanentWidget(self.progressbar)
self.statusbar.setObjectName("statusbar")
self.setStatusBar(self.statusbar)
self.main_tabs = QTabWidget(self)
self.main_tabs.setMovable(False)
self.main_tabs.setTabsClosable(True)
self.main_tabs.setAutoFillBackground(True)
self.main_tabs.tabCloseRequested.connect(self._on_close_tab)
self.setCentralWidget(self.main_tabs)
# pluginmanager
self.plugin_manager = PluginManager(self)
self.plugin_manager.reload_plugins()
self.welcome_window = None
if dwarf_args.any == '':
self.welcome_window = WelcomeDialog(self)
self.welcome_window.setModal(True)
self.welcome_window.onIsNewerVersion.connect(
self._enable_update_menu)
self.welcome_window.onUpdateComplete.connect(
self._on_dwarf_updated)
self.welcome_window.setWindowTitle(
'Welcome to Dwarf - A debugger for reverse engineers, crackers and security analyst'
)
self.welcome_window.onSessionSelected.connect(self._start_session)
# wait for welcome screen
self.hide()
self.welcome_window.show()
else:
print('* Starting new Session')
self._start_session(dwarf_args.target)
def __init__(self, app, bot):
# app
super(GUI, self).__init__()
QDir.setCurrent(bundle_dir)
self.app = app
# window info
self.setWindowFlags(self.windowFlags() | Qt.FramelessWindowHint)
window_icon = QIcon("./assets/favicon.ico")
self.setWindowTitle("Discord Audio Pipe")
self.app.setWindowIcon(window_icon)
self.position = None
# discord
self.bot = bot
# layout
central = QWidget()
self.layout = QGridLayout()
central.setLayout(self.layout)
# labels
self.info = QLabel("Connecting...")
device_lb = QLabel("Devices")
device_lb.setObjectName("label")
server_lb = QLabel("Servers ")
server_lb.setObjectName("label")
channel_lb = QLabel("Channels ")
channel_lb.setObjectName("label")
# connections
self.devices = sound.query_devices()
self.connections = [Connection(2, self)]
self.connected_servers = set()
# new connections
self.connection_btn = QPushButton("＋", self)
self.connection_btn.setObjectName("connection_btn")
# add widgets
self.layout.addWidget(self.info, 0, 0, 1, 3)
self.layout.addWidget(device_lb, 1, 0)
self.layout.addWidget(server_lb, 1, 1)
self.layout.addWidget(channel_lb, 1, 2)
self.layout.addWidget(self.connection_btn, 2, 4)
# events
self.connection_btn.clicked.connect(self.add_connection)
# build window
titlebar = TitleBar(self)
self.setMenuWidget(titlebar)
self.setCentralWidget(central)
self.setEnabled(False)
# load styles
QFontDatabase.addApplicationFont("./assets/Roboto-Black.ttf")
with open("./assets/style.qss", "r") as qss:
self.app.setStyleSheet(qss.read())
# show window
self.show()
def overlay_marks(self, img, is_cseed=False, calibration_sheet=False):
border_color = Qt.white
base_img = QImage(self.f_size.width(), self.f_size.height(),
QImage.Format_ARGB32)
base_img.fill(border_color)
img = QImage(img)
painter = QPainter()
painter.begin(base_img)
total_distance_h = round(base_img.width() / self.abstand_v)
dist_v = round(total_distance_h) / 2
dist_h = round(total_distance_h) / 2
img = img.scaledToWidth(base_img.width() - (2 * (total_distance_h)))
painter.drawImage(total_distance_h, total_distance_h, img)
#frame around image
pen = QPen(Qt.black, 2)
painter.setPen(pen)
#horz
painter.drawLine(0, total_distance_h, base_img.width(),
total_distance_h)
painter.drawLine(0,
base_img.height() - (total_distance_h),
base_img.width(),
base_img.height() - (total_distance_h))
#vert
painter.drawLine(total_distance_h, 0, total_distance_h,
base_img.height())
painter.drawLine(base_img.width() - (total_distance_h), 0,
base_img.width() - (total_distance_h),
base_img.height())
#border around img
border_thick = 6
Rpath = QPainterPath()
Rpath.addRect(
QRectF((total_distance_h) + (border_thick / 2),
(total_distance_h) + (border_thick / 2),
base_img.width() - ((total_distance_h) * 2) -
((border_thick) - 1),
(base_img.height() -
((total_distance_h)) * 2) - ((border_thick) - 1)))
pen = QPen(Qt.black, border_thick)
pen.setJoinStyle(Qt.MiterJoin)
painter.setPen(pen)
painter.drawPath(Rpath)
Bpath = QPainterPath()
Bpath.addRect(
QRectF((total_distance_h), (total_distance_h),
base_img.width() - ((total_distance_h) * 2),
(base_img.height() - ((total_distance_h)) * 2)))
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawPath(Bpath)
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawLine(0,
base_img.height() / 2, total_distance_h,
base_img.height() / 2)
painter.drawLine(base_img.width() / 2, 0,
base_img.width() / 2, total_distance_h)
painter.drawLine(base_img.width() - total_distance_h,
base_img.height() / 2, base_img.width(),
base_img.height() / 2)
painter.drawLine(base_img.width() / 2, base_img.height(),
base_img.width() / 2,
base_img.height() - total_distance_h)
#print code
f_size = 37
QFontDatabase.addApplicationFont(
os.path.join(os.path.dirname(__file__), 'DejaVuSansMono-Bold.ttf'))
font = QFont("DejaVu Sans Mono", f_size - 11, QFont.Bold)
font.setPixelSize(35)
painter.setFont(font)
if not calibration_sheet:
if is_cseed: #its a secret
painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
painter.drawImage(
((total_distance_h)) + 11, ((total_distance_h)) + 11,
QImage(icon_path('electrumb.png')).scaledToWidth(
2.1 * (total_distance_h), Qt.SmoothTransformation))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2 - 77,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0, 0, 0, 255))
painter.drawText(
QRect(
0,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
11,
base_img.height() - total_distance_h - border_thick),
Qt.AlignRight, self.versioned_seed.version + '_' +
self.versioned_seed.checksum)
painter.end()
else: # revealer
painter.setPen(QPen(border_color, 17))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
logo = QImage(icon_path('revealer_c.png')).scaledToWidth(
1.3 * (total_distance_h))
painter.drawImage((total_distance_h) + (border_thick),
((total_distance_h)) + (border_thick), logo,
Qt.SmoothTransformation)
#frame around logo
painter.setPen(QPen(Qt.black, border_thick))
painter.drawLine(
total_distance_h + border_thick,
total_distance_h + logo.height() + 3 * (border_thick / 2),
total_distance_h + logo.width() + border_thick,
total_distance_h + logo.height() + 3 * (border_thick / 2))
painter.drawLine(
logo.width() + total_distance_h + 3 * (border_thick / 2),
total_distance_h + (border_thick),
total_distance_h + logo.width() + 3 * (border_thick / 2),
total_distance_h + logo.height() + (border_thick))
#frame around code/qr
qr_size = 179
painter.drawLine((base_img.width() - ((total_distance_h)) -
(border_thick / 2) - 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2,
(base_img.width() / 2 +
(total_distance_h / 2) - border_thick -
(border_thick * 8) / 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2)
painter.drawLine(
(base_img.width() / 2 +
(total_distance_h / 2) - border_thick -
(border_thick * 8) / 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) -
border_thick - (border_thick * 8) / 2 - qr_size,
((base_img.height() - ((total_distance_h))) -
(border_thick / 2) - 2))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) -
border_thick - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0, 0, 0, 255))
painter.drawText(
QRect(((base_img.width() / 2) + 21) - qr_size,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
93,
base_img.height() - total_distance_h - border_thick),
Qt.AlignLeft,
self.versioned_seed.get_ui_string_version_plus_seed())
painter.drawText(
QRect(
0,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
3 - qr_size,
base_img.height() - total_distance_h - border_thick),
Qt.AlignRight, self.versioned_seed.checksum)
# draw qr code
qr_qt = self.paintQR(
self.versioned_seed.get_ui_string_version_plus_seed() +
self.versioned_seed.checksum)
target = QRectF(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size, qr_size,
qr_size)
painter.drawImage(target, qr_qt)
painter.setPen(QPen(Qt.black, 4))
painter.drawLine(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size,
base_img.width() - 65 - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 4)
painter.drawLine(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size,
base_img.width() - 65,
base_img.height() - 65 - qr_size)
painter.end()
else: # calibration only
painter.end()
cal_img = QImage(self.f_size.width() + 100,
self.f_size.height() + 100, QImage.Format_ARGB32)
cal_img.fill(Qt.white)
cal_painter = QPainter()
cal_painter.begin(cal_img)
cal_painter.drawImage(0, 0, base_img)
#black lines in the middle of border top left only
cal_painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
cal_painter.drawLine(0, dist_v, base_img.width(), dist_v)
cal_painter.drawLine(dist_h, 0, dist_h, base_img.height())
pen = QPen(Qt.black, 2, Qt.DashDotDotLine)
cal_painter.setPen(pen)
n = 15
cal_painter.setFont(QFont("DejaVu Sans Mono", 21, QFont.Bold))
for x in range(-n, n):
#lines on bottom (vertical calibration)
cal_painter.drawLine((((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) - 13,
x + 2 + base_img.height() - (dist_v),
(((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) + 13,
x + 2 + base_img.height() - (dist_v))
num_pos = 9
if x > 9: num_pos = 17
if x < 0: num_pos = 20
if x < -9: num_pos = 27
cal_painter.drawText((((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) - num_pos,
50 + base_img.height() - (dist_v), str(x))
#lines on the right (horizontal calibrations)
cal_painter.drawLine(
x + 2 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) * (x)) +
(base_img.height() / n) + (base_img.height() / 2) - 13,
x + 2 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) * (x)) +
(base_img.height() / n) + (base_img.height() / 2) + 13)
cal_painter.drawText(30 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) *
(x)) + (base_img.height() / 2) + 13,
str(x))
cal_painter.end()
base_img = cal_img
return base_img
def __init__(self, appctxt):
super(MainWindow, self).__init__()
self.appctxt = appctxt
uic.loadUi(self.appctxt.get_resource('mainwindow.ui'), self)
# Load Settings
self.loadSettings()
# Routine State
self.running = False
# Display Update Timer
self.displayTimer = QTimer(self)
self.displayTimer.setInterval(500)
self.displayTimer.timeout.connect(self.updateDisplay)
# Devices Update Timer
self.deviceCheckTimer = QTimer(self)
self.deviceCheckTimer.setInterval(1000)
self.deviceCheckTimer.timeout.connect(self.updateDevices)
self.deviceCheckTimer.start()
self.updateDevices()
# Activate First Device
self.handleDevice(quiet=True)
# Text Setting with Initial Conditions
self.updateMemoryBtn()
self.setFreq(self.freq)
# Value Setting with Initial Conditions
self.setWindowTitle("CyberRadio")
self.volume.setValue(self.demod.vol * 100)
# Buttons Handlers Declaration
self.modFmBtn.clicked.connect(self.handleFm)
self.modAmBtn.clicked.connect(self.handleAm)
self.powerBtn.clicked.connect(self.handlePower)
self.settingsBtn.clicked.connect(self.handleSettingsWindow)
self.memA.clicked.connect(self.handleMemory)
self.memB.clicked.connect(self.handleMemory)
self.memC.clicked.connect(self.handleMemory)
self.memD.clicked.connect(self.handleMemory)
self.memE.clicked.connect(self.handleMemory)
# Load Custom Fonts
QFontDatabase.addApplicationFont(
appctxt.get_resource('fonts/Comfortaa-VariableFont.ttf'))
QFontDatabase.addApplicationFont(
appctxt.get_resource('fonts/RacingSansOne-Regular.ttf'))
QFontDatabase.addApplicationFont(
appctxt.get_resource('fonts/RobotoMono-Bold.ttf'))
QFontDatabase.addApplicationFont(
appctxt.get_resource('fonts/RobotoMono-Regular.ttf'))
# Change Handlers
self.freqLine.editingFinished.connect(self.handleFreq)
self.volume.valueChanged.connect(self.handleVol)
self.deviceBox.currentTextChanged.connect(self.handleDevice)
# Custom Stylecheet
self.volume.setStyleSheet(volumeStyle())
self.deviceBox.setStyleSheet(
comboStyle(appctxt.get_resource('down_arrow.png')))
self.uiToggle(False)
# Print System Information
print("[GUI] Python Version:\n{}".format(sys.version))
print("[GUI] Numpy Version: {}".format(np.__version__))
# Show Window
self.center()
self.show()
@site: irony.iask.in , mzone.iask.in @email: [email protected] @file: test.test_font.py @description: """ from PyQt5.QtGui import QFontDatabase from PyQt5.QtWidgets import QApplication, QPushButton __Author__ = "By: Irony.\"[讽刺]\nQQ: 892768447\nEmail: [email protected]" __Copyright__ = "Copyright (c) 2015 Irony.\"[讽刺]" __Version__ = 1.0 app = QApplication([]) QFontDatabase.addApplicationFont("../data/fonts/webdings.ttf") QFontDatabase.addApplicationFont("../data/fonts/fontawesome-webfont.ttf") btn = QPushButton() btn.setObjectName("blog_up_button") btn.show() # 圆形进度 \uf110 # 搜索 \uf002 app.setStyleSheet(""" #blog_up_button { qproperty-text: "\uf002"; font-family: "FontAwesome"; } """)
def initUI(self):
# Import NYT custom font
QFontDatabase.addApplicationFont("Resources/KarnakPro-CondensedBlack.ttf")
# Header
self.header = QVBoxLayout()
top = QHBoxLayout()
# Header label containing the title
header_str = "The Mini Crossword"
header_label = QLabel(header_str)
header_label.setFont(QFont("KarnakPro-CondensedBlack", 30))
header_label.setAlignment(Qt.AlignBottom)
top.addWidget(header_label)
# Date label containing the specified or today's date
date_label = QLabel(self.todays_date)
date_label.setFont(QFont("Franklin", 17, 10))
date_label.setAlignment(Qt.AlignBottom)
date_label.setIndent(7)
top.addWidget(date_label)
# Align contents to left
top.addStretch(1)
self.header.addLayout(top)
# Label containing author's name
joel_label = QLabel("By Joel Fagliano")
joel_label.setFont(QFont("Franklin", 10))
self.header.addWidget(joel_label)
# Body (or middle part)
self.body = QHBoxLayout()
self.body.setSpacing(10)
self.body.addWidget(Body(self.grid, self.grid_numbers, self.answer, self.across, self.down, self.our_answer, parent=self, trace_mod=self.trace_mod))
# Footer
self.footer = QHBoxLayout()
# Creating a timer object to update the time and date every second
timer = QTimer(self)
timer.timeout.connect(self.show_time)
timer.start(1000)
# Footer label containing current date and time along with group name
footer_str = self.todays_date + '\n' + self.current_time + '\n' + GROUP_NAME
self.footer_label = QLabel(footer_str)
self.footer_label.setFont(QFont("Franklin", 10))
# Send footer label to the right
self.footer.addStretch(1)
self.footer.addWidget(self.footer_label)
main_layout = QGridLayout()
# Add header on top
main_layout.addLayout(self.header, 0, 0, 1, 1)
# Add body after header
main_layout.addLayout(self.body, 1, 0, 5, 1)
# Send footer to the bottom
main_layout.addLayout(self.footer, 6, 0, 1, 1)
self.setLayout(main_layout)
self.show()
def __init__(self, *args):
QApplication.__init__(self, *args)
# Setup appication
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
try:
self.settings.load()
except Exception as ex:
log.error("Couldn't load user settings. Exiting.\n{}".format(ex))
exit()
# Init translation system
language.init_language()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
log.info("Setting font to %s" % os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
self.setPalette(darkPalette)
self.setStyleSheet("QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }")
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow()
self.window.show()
# Load new/blank project (which sets default profile)
self.project.load("")
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.open_project(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
h = 250
qp.drawLine(self.max_x, h, self.min_x, h)
if self.max_x < self.min_x:
qp.drawLine(self.min_x, h, self.min_x - 30, h - 10)
qp.drawLine(self.min_x, h, self.min_x - 30, h + 10)
else:
qp.drawLine(self.min_x, h, self.min_x + 30, h - 10)
qp.drawLine(self.min_x, h, self.min_x + 30, h + 10)
qp.end()
if __name__ == "__main__":
def excepthook(type, value, tback):
sys.__excepthook__(type, value, tback)
sys.excepthook = excepthook
conn = sqlite3.connect("Que.db")
PQLE = PyQL(conn, "Que")
app = QApplication(sys.argv)
app.setStyleSheet(style)
fid = QFontDatabase.addApplicationFont("fonts/Lato-Regular.ttf") # Replace with your path
fontstr = QFontDatabase.applicationFontFamilies(fid)[0]
font = QFont(fontstr)
app.setFont(font)
ex = QueVisual()
sys.exit(app.exec())
def load(self, path):
self._path = path
with open(os.path.join(self._path, "theme.json")) as f:
data = json.load(f)
self._initializeDefaults()
if "colors" in data:
for name, color in data["colors"].items():
c = QColor(color[0], color[1], color[2], color[3])
self._colors[name] = c
fontsdir = os.path.join(self._path, "fonts")
if os.path.isdir(fontsdir):
for file in os.listdir(fontsdir):
if "ttf" in file:
QFontDatabase.addApplicationFont(
os.path.join(fontsdir, file))
if "fonts" in data:
for name, font in data["fonts"].items():
f = QFont()
if not sys.platform == "win32":
# Excluding windows here as a workaround for bad font rendering
f.setFamily(
font.get("family",
QCoreApplication.instance().font().family()))
f.setStyleName(font.get("style", "Regular"))
f.setBold(font.get("bold", False))
f.setLetterSpacing(QFont.AbsoluteSpacing,
font.get("letterSpacing", 0))
f.setItalic(font.get("italic", False))
f.setPixelSize(font.get("size", 1) * self._em_height)
f.setCapitalization(QFont.AllUppercase if font.get(
"capitalize", False) else QFont.MixedCase)
self._fonts[name] = f
if "sizes" in data:
for name, size in data["sizes"].items():
s = QSizeF()
s.setWidth(round(size[0] * self._em_width))
s.setHeight(round(size[1] * self._em_height))
self._sizes[name] = s
styles = os.path.join(self._path, "styles.qml")
if os.path.isfile(styles):
c = QQmlComponent(self._engine, styles)
self._styles = c.create()
if c.isError():
for error in c.errors():
Logger.log("e", error.toString())
iconsdir = os.path.join(self._path, "icons")
if os.path.isdir(iconsdir):
for icon in os.listdir(iconsdir):
name = os.path.splitext(icon)[0]
self._icons[name] = QUrl.fromLocalFile(
os.path.join(iconsdir, icon))
imagesdir = os.path.join(self._path, "images")
if os.path.isdir(imagesdir):
for image in os.listdir(imagesdir):
name = os.path.splitext(image)[0]
self._images[name] = QUrl.fromLocalFile(
os.path.join(imagesdir, image))
Logger.log("d", "Loaded theme %s", self._path)
self.themeLoaded.emit()
self.setAttribute(Qt.WA_StyledBackground, True)
self._initView()
def _initView(self):
layout = QVBoxLayout(self)
layout.setSpacing(15)
layout.setContentsMargins(12, 35, 12, 30)
layout.addWidget(LinkButton(self, objectName="groupButton1"))
layout.addWidget(LinkButton(self, objectName="groupButton2"))
layout.addWidget(LinkButton(self, objectName="qqButton"))
layout.addWidget(LinkButton(self, objectName="weixinButton"))
layout.addWidget(LinkButton(self, objectName="alipayButton"))
layout.addItem(QSpacerItem(
40, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
layout.addWidget(RubberBandButton(self, objectName="upButton"))
if __name__ == "__main__":
import sys
import os
os.chdir("../../")
from PyQt5.QtWidgets import QApplication
from PyQt5.QtGui import QFontDatabase
app = QApplication(sys.argv)
QFontDatabase.addApplicationFont("themes/default/font.ttf")
app.setStyleSheet(open("themes/default/style.qss",
"rb").read().decode("utf-8"))
w = LinkWidget()
w.show()
sys.exit(app.exec_())
painter.rotate(self._rotateAnimation.currentValue() * 30)
fm = self.fontMetrics()
# 在变换坐标后的正中间画文字
w = fm.width(self.LoadingText)
h = fm.height()
painter.drawText(QRectF(0 - w * 2, 0 - h, w * 2 * 2, h * 2),
Qt.AlignCenter, self.LoadingText)
painter.restore()
def _onClick(self):
if self._rotateAnimationStarted:
self._rotateAnimationStarted = False
self._rotateAnimation.stop()
return
self._rotateAnimationStarted = True
self._rotateAnimation.start()
def update(self, _=None):
super(PushButtonFont, self).update()
if __name__ == "__main__":
app = QApplication(sys.argv)
# 加载字体到字体库中
QFontDatabase.addApplicationFont(
"Data/Fonts/FontAwesome/fontawesome-webfont.ttf")
w = PushButtonFont("点击加载")
w.resize(400, 400)
w.show()
sys.exit(app.exec_())
import glob
import os
import sys
from PyQt5.QtGui import QFontDatabase, QFont
from PyQt5.QtWidgets import QApplication, QLabel, QWidget, QGridLayout
app = QApplication(sys.argv)
names = []
for path in glob.glob("Fonts/Roboto/*.ttf"):
print("path", os.path.abspath(path))
names.append(os.path.basename(path.replace(".ttf", "")).replace("-", ""))
fid = QFontDatabase.addApplicationFont(os.path.abspath(path))
print("fid", fid)
print(QFontDatabase.applicationFontFamilies(fid))
w = QWidget()
w.setWindowTitle("Roboto Fonts")
layout = QGridLayout(w)
print("names", names)
for row in range(4):
for col in range(4):
layout.addWidget(
QLabel(names[row * 4 + col], font=QFont(names[row * 4 + col], 26)),
row, col, 1, 1)
# print(row, col, row * 4 + col)
def load_font(self, font="Montserrat"):
QFontDatabase.addApplicationFont(":/fonts/fonts/Montserrat.ttf")
QFontDatabase.addApplicationFont(":/fonts/fonts/Roboto-Regular.ttf")
f = QFont(font)
self.setFont(f)
def load(self, path: str, is_first_call: bool = True) -> None:
if path == self._path:
return
theme_full_path = os.path.join(path, "theme.json")
Logger.log(
"d", "Loading theme file: {theme_full_path}".format(
theme_full_path=theme_full_path))
try:
with open(theme_full_path, encoding="utf-8") as f:
data = json.load(f)
except EnvironmentError as e:
Logger.error(
"Unable to load theme file at {theme_full_path}: {err}".format(
theme_full_path=theme_full_path, err=e))
return
except UnicodeDecodeError:
Logger.error(
"Theme file at {theme_full_path} is corrupt (invalid UTF-8 bytes)."
.format(theme_full_path=theme_full_path))
return
except json.JSONDecodeError:
Logger.error(
"Theme file at {theme_full_path} is corrupt (invalid JSON syntax)."
.format(theme_full_path=theme_full_path))
return
# Iteratively load inherited themes
try:
theme_id = data["metadata"]["inherits"]
self.load(Resources.getPath(Resources.Themes, theme_id),
is_first_call=False)
except FileNotFoundError:
Logger.log("e", "Could not find inherited theme %s", theme_id)
except KeyError:
pass # No metadata or no inherits keyword in the theme.json file
if "colors" in data:
for name, color in data["colors"].items():
try:
c = QColor(color[0], color[1], color[2], color[3])
except IndexError: # Color doesn't have enough components.
Logger.log(
"w",
"Colour {name} doesn't have enough components. Need to have 4, but had {num_components}."
.format(name=name, num_components=len(color)))
continue # Skip this one then.
self._colors[name] = c
fonts_dir = os.path.join(path, "fonts")
if os.path.isdir(fonts_dir):
for root, dirnames, filenames in os.walk(fonts_dir):
for filename in filenames:
if filename.lower().endswith(".ttf"):
QFontDatabase.addApplicationFont(
os.path.join(root, filename))
if "fonts" in data:
system_font_size = QCoreApplication.instance().font().pointSize()
for name, font in data["fonts"].items():
q_font = QFont()
q_font.setFamily(
font.get("family",
QCoreApplication.instance().font().family()))
if font.get("bold"):
q_font.setBold(font.get("bold", False))
else:
q_font.setWeight(font.get("weight", 50))
q_font.setLetterSpacing(QFont.AbsoluteSpacing,
font.get("letterSpacing", 0))
q_font.setItalic(font.get("italic", False))
q_font.setPointSize(int(
font.get("size", 1) * system_font_size))
q_font.setCapitalization(QFont.AllUppercase if font.get(
"capitalize", False) else QFont.MixedCase)
self._fonts[name] = q_font
if "sizes" in data:
for name, size in data["sizes"].items():
s = QSizeF()
s.setWidth(round(size[0] * self._em_width))
s.setHeight(round(size[1] * self._em_height))
self._sizes[name] = s
iconsdir = os.path.join(path, "icons")
if os.path.isdir(iconsdir):
for base_path, _, icons in os.walk(iconsdir):
detail_level = base_path.split(os.sep)[-1]
self._icons[detail_level] = {}
for icon in icons:
name = os.path.splitext(icon)[0]
self._icons[detail_level][name] = QUrl.fromLocalFile(
os.path.join(base_path, icon))
imagesdir = os.path.join(path, "images")
if os.path.isdir(imagesdir):
for image in os.listdir(imagesdir):
name = os.path.splitext(image)[0]
self._images[name] = QUrl.fromLocalFile(
os.path.join(imagesdir, image))
styles = os.path.join(path, "styles.qml")
if os.path.isfile(styles):
c = QQmlComponent(self._engine, styles)
context = QQmlContext(self._engine, self._engine)
context.setContextProperty("Theme", self)
self._styles = c.create(context)
if c.isError():
for error in c.errors():
Logger.log("e", error.toString())
Logger.log("d", "Loaded theme %s", path)
self._path = path
# only emit the theme loaded signal once after all the themes in the inheritance chain have been loaded
if is_first_call:
self.themeLoaded.emit()
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
# Log some basic system info
try:
v = openshot.GetVersion()
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" % v.ToString())
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except:
pass
# Setup application
self.setApplicationName('YYSportCoder')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
self.settings.load()
# Init and attach exception handler
from classes import exceptions
sys.excepthook = exceptions.ExceptionHandler
# Init translation system
language.init_language()
# Detect minimum libopenshot version
_ = self._tr
libopenshot_version = openshot.GetVersion().ToString()
if mode != "unittest" and libopenshot_version < info.MINIMUM_LIBOPENSHOT_VERSION:
QMessageBox.warning(
None, _("Wrong Version of YYSportCoder Detected"),
_("<b>Version %(minimum_version)s is required</b>, but %(current_version)s was detected. Please update libopenshot or download our latest installer."
) % {
"minimum_version": info.MINIMUM_LIBOPENSHOT_VERSION,
"current_version": libopenshot_version
})
# Stop launching and exit
sys.exit()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
try:
log.info(
"Setting font to %s" %
os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(
os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception as ex:
log.error("Error setting Ubuntu-R.ttf QFont: %s" % str(ex))
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
darkPalette.setColor(QPalette.Disabled, QPalette.Text,
QColor(104, 104, 104))
self.setPalette(darkPalette)
self.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }"
)
'''
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow(mode)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.OpenProjectSignal.emit(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
else:
# Recover backup file (this can't happen until after the Main Window has completely loaded)
self.window.RecoverBackup.emit()
'''
#from windows.yy_main_window import YYMainWindow
#self.window = YYMainWindow(mode)
from windows.yymain_window import YYMainWindow
self.window = YYMainWindow()
def run():
app = QApplication(sys.argv)
QFontDatabase.addApplicationFont('./style/' + style.style_loader.FONT + '.ttf')
to_window = TournamentOrganizerWindow()
sys.exit(app.exec_())
def setup_fonts(self):
QFontDatabase.addApplicationFont(':/font/SourceCodePro-Regular.otf')
QFontDatabase.addApplicationFont(':/font/SourceCodePro-It.otf')
QFontDatabase.addApplicationFont(':/font/SourceCodePro-Bold.otf')
def received_message(self, message):
self.parent.dmSignal.emit(str(message))
def on_closed(self):
self.connectStatusLabel.setText('已断开服务器连接')
#将窗口置顶
def toTop():
hwnd = win32gui.FindWindow(None, 'YFdanmu')
win32gui.SetWindowPos(
hwnd, win32con.HWND_TOP, 0, 0, 0, 0, win32con.SWP_NOMOVE
| win32con.SWP_NOOWNERZORDER | win32con.SWP_NOACTIVATE
| win32con.SWP_SHOWWINDOW | win32con.SWP_NOSIZE)
app = QApplication(sys.argv)
nindex = QFontDatabase.addApplicationFont(
os.path.join(basedir, 'src/myfont.ttf'))
if nindex != -1:
fontName = QFontDatabase.applicationFontFamilies(0)[0]
fontThis = QFont(fontName, 10)
app.setFont(fontThis)
#每100毫秒将窗口置顶一次
timer = QTimer()
timer.timeout.connect(toTop)
timer.start(100)
mainWindow = MainWindow()
mainWindow.show()
mainWindow.danmuWindow.show()
sys.exit(app.exec_())
if __name__ == '__main__':
import sys
if getattr(sys, 'frozen', False):
# we are running in a bundle
frozen = 'ever so'
bundle_dir = sys._MEIPASS
else:
# we are running in a normal Python environment
bundle_dir = os.path.dirname(os.path.abspath(__file__))
os.chdir(bundle_dir)
app = QApplication(sys.argv)
QFontDatabase.addApplicationFont("font/FiraSans-Regular.otf")
QFontDatabase.addApplicationFont("font/FiraSans-Medium.otf")
QFontDatabase.addApplicationFont("font/FiraSans-SemiBold.otf")
translator = QTranslator()
translator.load(QLocale.system(), "", "", "lang")
app.installTranslator(translator)
app.setWindowIcon(QIcon('icon.ico'))
player = Player()
player.show()
sys.exit(app.exec_())
def __init__(self, *args):
QApplication.__init__(self, *args)
try:
# Импорт модулей
from classes import constants
from classes.logger import log, reroute_output
# Отметка начала сессии
import time
self.__start_time = time.time() # Время начала инициализации
log.info("------------------------------------------------")
locale.setlocale(locale.LC_ALL, 'ru')
log.info(
time.strftime("%d %B %Y %H:%M:%S", time.localtime()).center(
48)) # Пример: 26 Август 2019 16:14:04
log.info('Запуск новой сессии'.center(48))
from classes import ui_util
# Перенаправляем stdout и stderr в логер
reroute_output()
except (ImportError, ModuleNotFoundError) as ex:
tb = traceback.format_exc()
QMessageBox.warning(
None, "Ошибка импорта модулей",
"Модуль: %(name)s\n\n%(tb)s" % {
"name": ex.name,
"tb": tb
})
# Остановить запуск и выйти
sys.exit()
except Exception:
sys.exit()
# Запись служебной информации
try:
log.info("------------------------------------------------")
log.info(("%s (version %s)" %
(constants.APP_NAME, constants.VERSION)).center(48))
log.info("------------------------------------------------")
log.info("Платформа: %s" % platform.platform())
log.info("Процессор: %s" % platform.processor())
log.info("Тип: %s" % platform.machine())
log.info("Python: %s" % platform.python_version())
log.info("Qt: %s" % QT_VERSION_STR)
log.info("PyQt: %s" % PYQT_VERSION_STR)
log.info("------------------------------------------------")
except Exception:
pass
log.info("Подключаем сигнал окончания сессии")
self.aboutToQuit.connect(self.on_log_the_end)
log.info(
"Подключаем переменные необходимые для правильной работы приложения"
)
self.setApplicationName(constants.APP_NAME)
self.setApplicationDisplayName(constants.APP_NAME_RUS)
self.setOrganizationName(constants.COMPANY)
self.setApplicationVersion(constants.VERSION)
log.info("Инициализация настроек")
App.settings = QSettings()
log.info("Инициализируем ловца необработанных исключений")
from classes import exceptions
sys.excepthook = exceptions.exception_handler
log.info("Подключаем файл ресурсов приложения")
from resources import resources
resources.qInitResources()
log.info("Создаем объект базы данных")
from classes.database import Database
App.db = Database()
App.user_id = None
log.info("Установка темы Fusion")
self.setStyle(QStyleFactory.create("Fusion"))
log.info("Загружаем и устанавливаем шрифт приложения")
try:
font_path = ":/fonts/roboto.ttf"
font_id = QFontDatabase.addApplicationFont(font_path)
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(12)
QApplication.setFont(font)
except Exception as ex:
log.error("Ошибка установки шрифта roboto.ttf: %s" % str(ex))
log.info("Создаем главное окно приложения")
from view.main_window import MainWindow
App.main_window = MainWindow()
log.info("------------------------------------------------")
log.info("Инициализация приложения завершена".center(48))
elapsed_time = time.time() - self.__start_time
log.info(("Потребовалось времени: %.3f сек" % elapsed_time).center(48))
log.info("------------------------------------------------")
# Сигнал о завершении загрузки приложения
self.app_loading_is_complete.emit()
def new_version_available(self):
# this will only work if numbers go up
try:
for (o, c) in zip(ONLINE_VERSION.split('.'), CURRENT_VERSION.split('.')):
if int(o) > int(c):
return True
except:
return False
if __name__ == "__main__":
try:
import ctypes
APPID = 'nomns.nparse'
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(APPID)
except:
pass
APP = NomnsParse(sys.argv)
APP.setStyleSheet(open(resource_path('data/ui/_.css')).read())
APP.setWindowIcon(QIcon(resource_path('data/ui/icon.png')))
APP.setQuitOnLastWindowClosed(False)
APP.setAttribute(Qt.AA_EnableHighDpiScaling)
QFontDatabase.addApplicationFont(
resource_path('data/fonts/NotoSans-Regular.ttf'))
QFontDatabase.addApplicationFont(
resource_path('data/fonts/NotoSans-Bold.ttf'))
sys.exit(APP.exec())
def __init__(self, app, addr, port):
QMainWindow.__init__(self)
self.addr = addr
self.port = port
self.app = app
''' Set window style '''
self.setWindowTitle('EMERGENT Dashboard')
QFontDatabase.addApplicationFont('dashboard/gui/media/Exo2-Light.ttf')
with open('dashboard/gui/stylesheet.txt', "r") as file:
self.setStyleSheet(file.read())
self.central_widget = QWidget()
self.setWindowIcon(QIcon('../dashboard/gui/media/icon.png'))
self.setCentralWidget(self.central_widget)
layout = QHBoxLayout(self.central_widget)
height = 720
width = height * 16 / 9
self.resize(width, height)
''' Define Qt signals '''
self.timestep_signal = DictSignal()
self.sequence_update_signal = DictSignal()
self.test_signal = DictSignal()
self.actuate_signal = DictSignal()
self.show_grid_signal = DictSignal()
self.show_grid_signal.connect(self.show_grid)
self.plot_signal = DictSignal()
self.plot_signal.connect(self.plot_window)
''' Wait until connection is established '''
self._connected = False
while True:
try:
self.get('', format='raw')
break
except Exception:
continue
''' Load modules '''
''' Create QTreeWidget '''
frame = QFrame()
layout.addWidget(frame)
self.tree_layout = QVBoxLayout()
frame.setLayout(self.tree_layout)
self.tree_widget = NodeTree(self)
self.tree_layout.addWidget(self.tree_widget)
button_layout = QHBoxLayout()
self.tree_layout.addLayout(button_layout)
from emergent.dashboard.structures.icon_button import IconButton
button_layout.addWidget(
IconButton('dashboard/gui/media/Material/content-save-outline.svg',
lambda: self.post('save'),
tooltip='Save device states'))
button_layout.addWidget(
IconButton('dashboard/gui/media/Material/content-undo.svg',
lambda: self.post('load'),
tooltip='Load device states'))
lock_button = IconButton(
'dashboard/gui/media/Material/baseline-lock-open.svg',
self.tree_widget.lock,
tooltip='Load device states',
toggle_icon='dashboard/gui/media/Material/baseline-lock-closed.svg'
)
button_layout.addWidget(lock_button)
button_layout.addStretch()
button_layout.addWidget(
IconButton('dashboard/gui/media/Material/outline-timer.svg',
self.show_grid,
tooltip='Open timing grid'))
''' Experiment interface '''
self.experiment_layout = QVBoxLayout()
layout.addLayout(self.experiment_layout)
self.experiment_panel = ExperimentLayout(self)
self.experiment_layout.addLayout(self.experiment_panel)
self.test_signal.connect(
self.experiment_panel.pipeline_panel.add_block)
''' Create task panel '''
self.task_panel = TaskPanel(self)
self.experiment_layout.addLayout(self.task_panel)
''' Open reverse connection to master '''
logging.getLogger('socketio').setLevel(logging.ERROR)
logging.getLogger('engineio').setLevel(logging.ERROR)
app = Flask(__name__)
socketio = SocketIO(app, logger=False)
@socketio.on('actuate')
def actuate(state):
self.actuate_signal.emit(state)
@socketio.on('plot')
def plot(data):
self.plot_signal.emit(data)
@socketio.on('timestep')
def update_timestep(d):
self.timestep_signal.emit({'name': d['name']})
@socketio.on('sequencer')
def show_grid(d):
self.show_grid_signal.emit(d)
@socketio.on('sequence update')
def update_sequence():
self.sequence_update_signal.emit({})
@socketio.on('sequence reorder')
def update_sequence_order(d):
knob = self.tree_widget.get_knob('hub', 'sequencer', d['name'])
knob.move(d['n'])
@socketio.on('event')
def event(event):
self.task_panel.add_event(event)
print('Starting flask-socketio server')
from threading import Thread
thread = Thread(target=socketio.run,
args=(app, ),
kwargs={'port': self.port + 1})
thread.start()
self.post('handshake', {'port': self.port + 1})
@socketio.on('test')
def test(d):
self.test_signal.emit(d)
if not username:
self.showErrorMsg(self.tr('Incorrect username'))
return
if not password:
self.showErrorMsg(self.tr('Incorrect password'))
return
self.labelNotice.setText('')
def showErrorMsg(self, msg):
"""
:param msg: 消息内容
"""
self.labelNotice.setText(self.Icon + ' ' + msg)
if __name__ == '__main__':
import sys
import cgitb
sys.excepthook = cgitb.Hook(1, None, 5, sys.stderr, 'text')
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QFontDatabase
from Utils.Tools import readData
app = QApplication(sys.argv)
app.setStyleSheet(readData('../../Resources/Themes/Default.qss'))
QFontDatabase.addApplicationFont('../../Resources/Fonts/qtskin.ttf')
ww = QWidget()
ww.show()
w = LoginDialog(ww)
w.exec_()
sys.exit(app.exec_())
if diff is None:
wt = windows[0].start.replace(year=ct.year,
month=ct.month,
day=ct.day + 1)
diff = wt - ct
hours, remainder = divmod(diff.seconds, 3600)
minutes, seconds = divmod(remainder, 60)
self.showMessage(
"Next Window",
"The next window opens in {:02d}:{:02d}:{:02d}".format(
hours, minutes, seconds))
def clicked(self, reason):
if reason == QSystemTrayIcon.DoubleClick or reason == QSystemTrayIcon.MiddleClick:
self.parent().unhide()
elif reason == QSystemTrayIcon.Trigger:
self.next_window()
if __name__ == "__main__":
app = QApplication(sys.argv)
QFontDatabase.addApplicationFont("./font.otf")
font = QFont("FOT-Pearl Std L", 16)
window = Window()
sys.exit(app.exec_())
def seed_img(self, is_seed=True):
if is_seed:
try:
cseed = self.get_seed()
except UserCancelled:
return
except InvalidPassword as e:
self.d.show_error(str(e))
return
if not cseed:
self.d.show_message(_("This wallet has no seed"))
return
txt = cseed.upper()
else:
txt = self.txt.upper()
img = QImage(self.SIZE[0], self.SIZE[1], QImage.Format_Mono)
bitmap = QBitmap.fromImage(img, Qt.MonoOnly)
bitmap.fill(Qt.white)
painter = QPainter()
painter.begin(bitmap)
QFontDatabase.addApplicationFont(
os.path.join(os.path.dirname(__file__), 'SourceSansPro-Bold.otf'))
if len(txt) < 102:
fontsize = 15
linespace = 15
max_letters = 17
max_lines = 6
max_words = 3
else:
fontsize = 12
linespace = 10
max_letters = 21
max_lines = 9
max_words = int(max_letters / 4)
font = QFont('Source Sans Pro', fontsize, QFont.Bold)
font.setLetterSpacing(QFont.PercentageSpacing, 100)
font.setPixelSize(fontsize)
painter.setFont(font)
seed_array = txt.split(' ')
for n in range(max_lines):
nwords = max_words
temp_seed = seed_array[:nwords]
while len(' '.join(map(str, temp_seed))) > max_letters:
nwords = nwords - 1
temp_seed = seed_array[:nwords]
painter.drawText(
QRect(0, linespace * n, self.SIZE[0], self.SIZE[1]),
Qt.AlignHCenter, ' '.join(map(str, temp_seed)))
del seed_array[:nwords]
painter.end()
img = bitmap.toImage()
if (self.rawnoise == False):
self.make_rawnoise()
self.make_cypherseed(img, self.rawnoise, False, is_seed)
return img
def initUI(self):
self.defaultText = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789~!@#$%^&*()_+-=[]{},./?><\'\\|'
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint)
self.setWindowTitle("字体精简小工具")
self.resize(300, 170)
# self.setFixedSize(300, 170)
self.setWindowIcon(QIcon(':/windowIcon.png'))
self.fontID = QFontDatabase.addApplicationFont(
'./DroidSansFallback.ttf')
self.fontName = QFontDatabase.applicationFontFamilies(self.fontID)[0]
hwg = QWidget()
vwg = QWidget()
layout = QVBoxLayout()
layoutH = QHBoxLayout()
self.label = QLabel("保留的字符:")
self.label.setFixedHeight(20)
layoutH.addWidget(self.label)
self.list = QComboBox()
self.list.setFixedHeight(20)
self.list.setFixedWidth(90)
self.list.addItem('常用')
self.list.addItem('无符号')
self.list.addItem('含中文标点')
self.list.currentIndexChanged.connect(self.listChange)
layoutH.addWidget(self.list)
self.textEdit1 = QPlainTextEdit()
self.textEdit1.setFixedHeight(50)
self.textEdit1.setPlainText(self.defaultText)
self.textEdit1.textChanged.connect(self.textEdit1Change)
# self.button1 = SelectFontButton("选择或拖拽字体文件到这里", self)
self.button1 = MyButton(self.defaultText)
self.button1.setText("选择或拖拽字体文件到这里")
font = QFont(self.fontName)
# pointsize = font.pointSize()
font.setPointSize(12)
self.button1.setFont(font)
self.button1.clicked.connect(self.clickedButton)
self.button1.setFixedHeight(50)
# self.button1.setFont(QFont('font', 20))
# self.button1.setFont(QFont(self.fontName, 12))
source = 'key.png'
scale = [22, 22, 30, 30] # 左,上,右,下 [22, 22, 30, 30]
# slice = '40 24 60 50' # 上 右 下 左
repeat = 'stretched stretched' # rounded
self.button1.setObjectName('button1')
# self.button1.setStyleSheet('#button1{border-width:'+slice+';border-image:url(' + source + ') ' + slice+'}')
# self.button1.setStyleSheet('border:30;border-image:url(key.png) 30')
self.setBorderImage(self.button1, scale, source, repeat)
hwg.setLayout(layoutH)
# hwg.setObjectName('hwg')
# hwg.setStyleSheet('#hwg{border-width:'+slice+';border-image:url(' + source + ') ' + slice+'}')
layout.addWidget(hwg)
layout.addWidget(self.textEdit1)
layout.addWidget(self.button1)
# layout.addWidget(self.button2)
self.setLayout(layout)
font.setPointSize(10)
self.setFont(font)
# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#
# Static globals and functions to manage them.
#
# Generate a font database and make sure it contains Liberation Mono
# and Cousine, loading them from our resources module.
#
from PyQt5.QtGui import (
QFont,
QFontDatabase
)
from PyQt5.QtWidgets import QFontDialog
_FONT_DB = QFontDatabase()
_FONT_DB.addApplicationFont(':/liberation_mono.ttf')
_FONT_DB.addApplicationFont(':/cousine.ttf')
# Return a list of available monospaced families for use in the preferences
# dialog. Because for some stupid reason the font database refuses to
# acknowledge that liberation mono and cousine are in fact, monospaced,
# insert those names too.
def list_of_good_families():
selection = _FONT_DB.families() # all known family names
short_list = [family for family in selection if _FONT_DB.isFixedPitch(family) ]
short_list.insert(0,'Liberation Mono')
short_list.insert(0,'Cousine')
return short_list
# Primary use of these global constants is in unit test
### Translation process
locale = QLocale.system().name()
app_translator = QTranslator()
if app_translator.load(QLocale(), ray.APP_TITLE.lower(), '_',
"%s/locale" % get_code_root()):
app.installTranslator(app_translator)
sys_translator = QTranslator()
path_sys_translations = QLibraryInfo.location(
QLibraryInfo.TranslationsPath)
if sys_translator.load(QLocale(), 'qt', '_', path_sys_translations):
app.installTranslator(sys_translator)
QFontDatabase.addApplicationFont(":/fonts/Ubuntu-R.ttf")
QFontDatabase.addApplicationFont(":fonts/Ubuntu-C.ttf")
# get arguments
parser = ArgParser()
init_gui_tools()
# Add raysession/src/bin to $PATH
# to can use raysession after make, whitout install
ray.add_self_bin_to_path()
#connect signals
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
def load(self, path):
self._path = path
with open(os.path.join(self._path, "theme.json")) as f:
data = json.load(f)
self._initializeDefaults()
if "colors" in data:
for name, color in data["colors"].items():
c = QColor(color[0], color[1], color[2], color[3])
self._colors[name] = c
fontsdir = os.path.join(self._path, "fonts")
if os.path.isdir(fontsdir):
for file in os.listdir(fontsdir):
if "ttf" in file:
QFontDatabase.addApplicationFont(os.path.join(fontsdir, file))
if "fonts" in data:
for name, font in data["fonts"].items():
f = QFont()
if not sys.platform == "win32":
# Excluding windows here as a workaround for bad font rendering
f.setFamily(font.get("family", QCoreApplication.instance().font().family()))
f.setStyleName(font.get("style", "Regular"))
f.setBold(font.get("bold", False))
f.setItalic(font.get("italic", False))
f.setPixelSize(font.get("size", 1) * self._em_height)
f.setCapitalization(QFont.AllUppercase if font.get("capitalize", False) else QFont.MixedCase)
self._fonts[name] = f
if "sizes" in data:
for name, size in data["sizes"].items():
s = QSizeF()
s.setWidth(size[0] * self._em_width)
s.setHeight(size[1] * self._em_height)
self._sizes[name] = s
styles = os.path.join(self._path, "styles.qml")
if os.path.isfile(styles):
c = QQmlComponent(self._engine, styles)
self._styles = c.create()
if c.isError():
for error in c.errors():
Logger.log("e", error.toString())
iconsdir = os.path.join(self._path, "icons")
if os.path.isdir(iconsdir):
for icon in os.listdir(iconsdir):
name = os.path.splitext(icon)[0]
self._icons[name] = QUrl.fromLocalFile(os.path.join(iconsdir, icon))
imagesdir = os.path.join(self._path, "images")
if os.path.isdir(imagesdir):
for image in os.listdir(imagesdir):
name = os.path.splitext(image)[0]
self._images[name] = QUrl.fromLocalFile(os.path.join(imagesdir, image))
Logger.log("d", "Loaded theme %s", self._path)
self.themeLoaded.emit()
def load(self, path: str, is_first_call: bool = True) -> None:
if path == self._path:
return
with open(os.path.join(path, "theme.json"), encoding = "utf-8") as f:
Logger.log("d", "Loading theme file: %s", os.path.join(path, "theme.json"))
data = json.load(f)
# Iteratively load inherited themes
try:
theme_id = data["metadata"]["inherits"]
self.load(Resources.getPath(Resources.Themes, theme_id), is_first_call = False)
except FileNotFoundError:
Logger.log("e", "Could not find inherited theme %s", theme_id)
except KeyError:
pass # No metadata or no inherits keyword in the theme.json file
if "colors" in data:
for name, color in data["colors"].items():
c = QColor(color[0], color[1], color[2], color[3])
self._colors[name] = c
fonts_dir = os.path.join(path, "fonts")
if os.path.isdir(fonts_dir):
for root, dirnames, filenames in os.walk(fonts_dir):
for filename in filenames:
if filename.lower().endswith(".ttf"):
QFontDatabase.addApplicationFont(os.path.join(root, filename))
if "fonts" in data:
system_font_size = QCoreApplication.instance().font().pointSize()
for name, font in data["fonts"].items():
q_font = QFont()
q_font.setFamily(font.get("family", QCoreApplication.instance().font().family()))
if font.get("bold"):
q_font.setBold(font.get("bold", False))
else:
q_font.setWeight(font.get("weight", 50))
q_font.setLetterSpacing(QFont.AbsoluteSpacing, font.get("letterSpacing", 0))
q_font.setItalic(font.get("italic", False))
q_font.setPointSize(int(font.get("size", 1) * system_font_size))
q_font.setCapitalization(QFont.AllUppercase if font.get("capitalize", False) else QFont.MixedCase)
self._fonts[name] = q_font
if "sizes" in data:
for name, size in data["sizes"].items():
s = QSizeF()
s.setWidth(round(size[0] * self._em_width))
s.setHeight(round(size[1] * self._em_height))
self._sizes[name] = s
iconsdir = os.path.join(path, "icons")
if os.path.isdir(iconsdir):
for icon in os.listdir(iconsdir):
name = os.path.splitext(icon)[0]
self._icons[name] = QUrl.fromLocalFile(os.path.join(iconsdir, icon))
imagesdir = os.path.join(path, "images")
if os.path.isdir(imagesdir):
for image in os.listdir(imagesdir):
name = os.path.splitext(image)[0]
self._images[name] = QUrl.fromLocalFile(os.path.join(imagesdir, image))
styles = os.path.join(path, "styles.qml")
if os.path.isfile(styles):
c = QQmlComponent(self._engine, styles)
context = QQmlContext(self._engine, self._engine)
context.setContextProperty("Theme", self)
self._styles = c.create(context)
if c.isError():
for error in c.errors():
Logger.log("e", error.toString())
Logger.log("d", "Loaded theme %s", path)
self._path = path
# only emit the theme loaded signal once after all the themes in the inheritance chain have been loaded
if is_first_call:
self.themeLoaded.emit()
