def main():
app = QApplication(sys.argv)
if "Oxygen" in QStyleFactory.keys():
app.setStyle( QStyleFactory.create("Oxygen") ) # try to set the Oxygen style
elif "Fusion" in QStyleFactory.keys(): # if not the try Fusion
app.setStyle( QStyleFactory.create("Fusion") )
Globals.icons["finish flag"].addPixmap( QPixmap("Ressources/icons/finish_flag.png"), QIcon.Disabled, QIcon.On)
Globals.MainWindow = MainWindow()
Globals.Screen = app.primaryScreen()
taille = Globals.Screen.size()
height = taille.height()
width = taille.width()
if False:
Globals.MainWindow.setMaximumSize( taille )
Globals.MainWindow.resize( height, width )
Globals.MainWindow.Tab_Container.setMaximumSize(QSize( height , width - 40))
Globals.MainWindow.Tab_Container.setGeometry( QRect(0, 0, height, width - 40))
Globals.MainWindow.main()
# Init Decoder interface
for dec in pref.decoderList:
print ( dec )
if pref.decoderList[ dec ]['active']:
decoder_task( pref.decoderList[dec], dec )
for task in Globals.decoder:
receive( task )
app.exec_()
def mainGUI():
app = QApplication(sys.argv)
try:
# ajout de l'id de l'application
myappid = 'ValentinLe.lecteur_musique'
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
except AttributeError:
pass
# ajout de l'icone de l'application
app.setWindowIcon(QIcon(QPixmap("assets/logo.ico")))
# couleurs pour la scrollBar
palette = QPalette()
palette.setColor(QPalette.Base, QColor("#454545"))
palette.setColor(QPalette.Light, QColor("#454545"))
app.setPalette(palette)
# affichage de la fenetre principale
board = Board()
window = MainWindow(board)
window.setWindowTitle("Musique")
window.showMaximized()
# window.show()
sys.exit(app.exec_())
def main(opts, logger):
root = QtGui.QApplication(sys.argv)
client = DAQProvider(opts, logger, root)
# Set up the GUI part
gui = MainWindow(client.outqueue, client.inqueue, logger, opts, root)
gui.show()
root.exec_()
def __init__(self):
app = QApplication(sys.argv)
QApplication.setStyle(QStyleFactory.create('Fusion'))
main_window = MainWindow()
main_window.show()
sys.exit(app.exec_()) #will not end until you close the program
def start(self):
self.main_window = MainWindow(None, self.announces, self.api)
self.main_window.addPlugin('PainterPlugin', PainterPlugin)
self.main_window.addPlugin('LayoutPlugin', LayoutPlugin)
self.main_window.addPlugin('PlayerPlugin', PlayerPlugin)
self.main_window.addPlugin('NameInfoPlugin', NameInfoPlugin)
self.main_window.addPlugin('LogPlugin', LogPlugin)
self.main_window.addPlugin('InfoDialogPlugin', InfoDialogPlugin)
self.main_window.addPlugin('StatisticsPlugin', StatisticsPlugin)
def main():
root = Tk()
icon = PhotoImage(file="resources/webserver.png")
root.iconphoto(True, icon)
root.title("PyWebServer")
root.resizable(0, 0)
main_window = MainWindow(root)
main_window.pack()
root.mainloop()
def main():
app = QApplication()
apply_stylesheet(app, theme='dark_amber.xml')
window = MainWindow()
signal.signal(signal.SIGINT, sigint_handler)
timer = QTimer()
timer.start(500)
timer.timeout.connect(lambda: None)
sys.exit(app.exec_())
def login(self):
userName=self.loginEntry.get()
password=self.passwordEntry.get()
user=UserController().findUser(userName)
try:
if(password==user.password):
self.master.withdraw()
MainWindow(user,root)
print("LOGGING IN...")
else:
messagebox.showinfo("ERROR","INCORRECT PASSWORD")
except:
messagebox.showinfo("ERROR","INCORRECT LOGIN")
def main():
# Load the configuration file
preferences = Preferences()
# Create application
app = QtGui.QApplication(sys.argv)
# Load the Main Widget
main_window = MainWindow(preferences)
# Start the application
sys.exit(app.exec_())
def run_gui(args):
from gui.MainWindow import MainWindow
integrators = {
'euler': Euler(),
'leapfrog': Leapfrog(),
'hermite': Hermite()
}
try:
integrator = integrators[args.integrator]
except:
print("Integrator must one of: euler, leapfrog, hermite")
exit(-1)
sim = simulation.SimRun(n_steps=args.n,
n_stars=args.s,
integrator=integrator)
w = MainWindow(sim)
w.simulate()
def run(argv):
"""Parse command-line options and start Audiolog."""
parser = OptionParser(usage="audiolog [OPTIONS] [INPUT_DIR]...")
parser.add_option("--no-gui",
action="store_false",
dest="showGUI",
default=True,
help="run program without GUI (on by default)")
parser.add_option(
"-s",
metavar="SORTED_DIR",
dest="sortedPath",
help="the directory correctly sorted music should be moved to")
options, inputPaths = parser.parse_args(argv)
configuration.loadConfigFile()
if options.sortedPath:
configuration.PATHS["SORTED"] = toUnicode(options.sortedPath)
if inputPaths:
configuration.PATHS["TO_SCAN"] = [
toUnicode(path) for path in inputPaths
]
if options.showGUI:
from PyQt4.QtGui import QApplication
from gui.MainWindow import MainWindow
app = QApplication(sys.argv)
mainWindow = MainWindow()
mainWindow.show()
if inputPaths:
mainWindow.start()
app.exec_()
elif not options.showGUI and inputPaths:
logOutputs.append(sys.stdout)
traverse.handleIt()
# Assign a function to save configurations when the app is closed.
app.aboutToQuit.connect(exitApplication)
# Apply window style
if config.windowStyle and config.windowStyle in QStyleFactory.keys():
app.setStyle(config.windowStyle)
# Apply theme style
if config.qtMaterial and config.qtMaterialTheme:
apply_stylesheet(app, theme=config.qtMaterialTheme)
config.theme = "dark" if config.qtMaterialTheme.startswith("dark_") else "default"
else:
app.setPalette(Themes.getPalette())
# Active verse number colour
#config.activeVerseNoColour = config.activeVerseNoColourDark if config.theme == "dark" else config.activeVerseNoColourLight
# Assign mainWindow to config.mainWindow, to make it acessible from user customised user script
config.mainWindow = MainWindow()
# Check screen size
availableGeometry = app.desktop().availableGeometry(config.mainWindow)
setupMainWindow(availableGeometry)
# A container of functions to be run after UBA loaded history records on startup
# This offers a way for startup plugins to run codes after history records being loaded.
config.actionsRightAfterLoadingHistoryRecords = []
runStartupPlugins()
# Run initial commands
if config.populateTabsOnStartup:
openBibleWindowContentOnNextTab, openStudyWindowContentOnNextTab = config.openBibleWindowContentOnNextTab, config.openStudyWindowContentOnNextTab
forceGenerateHtml = config.forceGenerateHtml
from fbs_runtime.application_context.PySide2 import ApplicationContext
from PySide2.QtWidgets import QMainWindow, QApplication
import sys
from gui.MainWindow import MainWindow
KEY_BIT_WIDTH = 16
SUFFIX_NAME = ".tjl"
if __name__ == '__main__':
appctxt = ApplicationContext()
ex = MainWindow(KEY_BIT_WIDTH, SUFFIX_NAME)
ex.show()
sys.exit(appctxt.app.exec_())
from PyQt5.QtWidgets import QApplication
from gui.MainWindow import MainWindow
import sys
if __name__ == "__main__":
app = QApplication(sys.argv)
window = MainWindow()
sys.exit(app.exec_())
def main():
app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())
def mainLoop():
mainWindow = MainWindow()
mainWindow.mainloop()
def __init__(self):
if not self.main_window:
self.main_window = MainWindow(getMainWindow())
self.main_window.show()
import subprocess
import sys
## A helper function for installing modules for this program if they are not existing.
#
# \param packageName Name of the package that shall be installed.
def maybeInstall(packageName):
if importlib.util.find_spec(packageName) is None:
subprocess.check_call(
[sys.executable, "-m", "pip", "install", packageName])
if __name__ == "__main__":
# Update pip.
#subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", "pip"])
# For file exchange with Git
from PyQt5.QtWidgets import *
from PyQt5 import QtCore
app = QApplication(sys.argv)
app.setApplicationVersion("1.0.0")
from gui.MainWindow import MainWindow
from core.Controller import Controller
controller = Controller()
window = MainWindow(controller)
window.show()
sys.exit(app.exec_())
def launch(self) -> None:
self.window = MainWindow(self)
self.window.show()
def startGUI():
app = QtGui.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec_())
def main():
#
app = QtModule.QApplication(sys.argv)
app_settings.setValue('version', __version__)
app_settings.setValue('root', normPath(root))
project_filename = setDefaultValue('project_filename', 'meshadered.prj')
temp_dir = setDefaultValue('temp', normPath(os.path.join(root, 'tmp')))
project_dir = setDefaultValue('project',
normPath(os.path.join(root, 'samples')))
project_shaders = setDefaultValue(
'project_shaders', normPath(os.path.join(project_dir, 'shaders')))
project_textures = setDefaultValue(
'project_textures', normPath(os.path.join(project_dir, 'textures')))
shader_networks_dir = setDefaultValue(
'shader_networks', normPath(os.path.join(project_shaders, 'shn')))
shader_sources_dir = setDefaultValue(
'shader_sources', normPath(os.path.join(project_shaders, 'src')))
shader_output_dir = project_shaders
lib_dir = setDefaultValue('lib', normPath(os.path.join(root, 'lib')))
node_dir = setDefaultValue('nodes',
normPath(os.path.join(lib_dir, 'nodes')))
texture_dir = setDefaultValue('texture',
normPath(os.path.join(lib_dir, 'textures')))
shaders_dir = setDefaultValue('shaders',
normPath(os.path.join(lib_dir, 'shaders')))
archive_dir = setDefaultValue('archive',
normPath(os.path.join(lib_dir, 'archives')))
include_dir = setDefaultValue('include',
normPath(os.path.join(root, 'include')))
createMissingDirs(
[temp_dir, lib_dir, project_dir, project_shaders, project_textures])
createMissingDirs([shader_networks_dir, shader_sources_dir])
createMissingDirs([node_dir, texture_dir, shaders_dir,
archive_dir]) # include_dir supposed to be a list
#
# Recent projects/networks
#
setDefaultValue('recent_projects_max', 10)
setDefaultValue('recent_networks_max', 10)
#
# setup globals
#
app_global_vars['version'] = getDefaultValue(app_settings, '', 'version')
app_global_vars['RootPath'] = root
app_global_vars['TempPath'] = temp_dir
app_global_vars['ProjectPath'] = project_dir
app_global_vars['ProjectShaders'] = project_shaders
app_global_vars['ProjectTextures'] = project_textures
app_global_vars['ProjectNetworks'] = shader_networks_dir
app_global_vars['ProjectSources'] = shader_sources_dir
app_global_vars['LibPath'] = lib_dir
app_global_vars['NodesPath'] = node_dir
app_global_vars['TexturePath'] = texture_dir
app_global_vars['ShaderPath'] = shaders_dir
app_global_vars['IncludePath'] = include_dir
app_global_vars['TextureSearchPath'] = sanitizeSearchPath(texture_dir)
app_global_vars['ShaderSearchPath'] = sanitizeSearchPath(shaders_dir)
app_global_vars['ArchiveSearchPath'] = sanitizeSearchPath(archive_dir)
app_global_vars['ProjectSearchPath'] = sanitizeSearchPath(project_dir)
app_global_vars['ProjectSearchShaders'] = sanitizeSearchPath(
project_shaders)
app_global_vars['ProjectSearchTextures'] = sanitizeSearchPath(
project_textures)
#
# Setup current renderer preset
#
defRenderer = setDefaultValue('defRenderer', '3Delight')
preset = meRendererPreset(os.path.join(root, 'renderers.xml'), defRenderer)
app_global_vars['RendererPreset'] = preset
app_global_vars['RendererName'] = preset.currentPreset.RendererName
app_global_vars['RendererFlags'] = preset.currentPreset.RendererFlags
app_global_vars['ShaderCompiler'] = preset.currentPreset.ShaderCompiler
app_global_vars['ShaderDefines'] = preset.currentPreset.ShaderDefines
app_global_vars['ShaderInfo'] = preset.currentPreset.ShaderInfo
app_global_vars['SLO'] = preset.currentPreset.ShaderExt
app_global_vars['TextureMake'] = preset.currentPreset.TextureMake
app_global_vars['TextureInfo'] = preset.currentPreset.TextureInfo
app_global_vars['TextureViewer'] = preset.currentPreset.TextureViewer
app_global_vars['TEX'] = preset.currentPreset.TextureExt
createDefaultProject(app_settings, True) # check_if_exist = True
if DEBUG_MODE:
print 'TextureSearchPath = %s' % app_global_vars['TextureSearchPath']
print 'ShaderSearchPath = %s' % app_global_vars['ShaderSearchPath']
print 'ArchiveSearchPath = %s' % app_global_vars['ArchiveSearchPath']
print 'Renderer = %s' % app_global_vars['RendererName']
#app_global_vars[ 'RibPath' ] = ''
#app_global_vars[ 'DisplayPath' ] = ''
app_settings.beginGroup('WorkArea')
#grid_enabled = bool( setDefaultValue( 'grid_enabled', True ).toString() )
grid_enabled = setDefaultValue('grid_enabled', True)
grid_size = int(setDefaultValue('grid_size', 10))
grid_snap = setDefaultValue('grid_snap', True)
reverse_flow = setDefaultValue('reverse_flow', False)
straight_links = setDefaultValue('straight_links', True)
app_settings.endGroup()
app_settings.beginGroup('Colors')
app_colors['rsl_node_bg'] = setDefaultValue('rsl_node_bg',
app_colors['rsl_node_bg'])
app_colors['rib_node_bg'] = setDefaultValue('rib_node_bg',
app_colors['rib_node_bg'])
app_colors['image_node_bg'] = setDefaultValue('image_node_bg',
app_colors['image_node_bg'])
app_colors['group_node_bg'] = setDefaultValue('group_node_bg',
app_colors['group_node_bg'])
app_settings.endGroup()
from gui.MainWindow import MainWindow
window = MainWindow()
window.show()
# It's exec_ because exec is a reserved word in Python
sys.exit(app.exec_())
import sys
from gui.MainWindow import MainWindow
from PyQt5.QtWidgets import QApplication
if __name__ == '__main__':
application_name = 'YandexMail_500'
config_file_name = '../settings.ini'
app = QApplication(sys.argv)
window = MainWindow(application_name, config_file_name)
window.show()
app.exec_()
def run_replay(args):
from gui.MainWindow import MainWindow
sim = simulation.Player(args.replay)
w = MainWindow(sim)
w.simulate()
# coding: utf-8
import sys
from PyQt5.QtWidgets import QApplication
from core.DataBase import DataBase
from gui.MainWindow import MainWindow
if __name__ == '__main__':
app = QApplication(sys.argv)
db = DataBase()
print(db.connect())
m = MainWindow()
m.show()
sys.exit(app.exec_())
def setUp(self):
self.gui = MainWindow()
self.char = Character.Character.Open(charfile)
