class MusicPlayerApplication(Gtk.Application):
APP_NAME = "MusicPlayer"
APP_CONFIG_PATH = "musicplayer"
def __init__(self):
Gtk.Application.__init__(self)
GLib.set_application_name(self.APP_NAME)
self.win = None
self.settings = None
self.discoverer = None
self.player = None
self.equalizer = None
self.queue = None
self.history = None
self.integration = None
def do_startup(self):
Gtk.Application.do_startup(self)
self.settings = Settings(self)
self.discoverer = Discoverer()
self.player = Player(self)
self.equalizer = Equalizer(self)
self.queue = Queue(self)
self.history = History(self)
self.integration = Integration(self)
self.win = MainWindow(self)
def do_activate(self):
self.win.show_all()
def render(self):
app = QApplication(sys.argv)
self.config_window = ConfigWindow()
self.stat_window = ClientStatsWindow()
self.main_window = MainWindow()
self.show_main_window()
self.make_signals_connection()
app.exec_()
def transition_to_main_window(project):
logging.info("Transitioning to main window.")
global main_window
driver = Driver(project)
settings_service.save_settings()
main_window = MainWindow(transition_back_to_create_project, driver)
main_window.show()
class MainState(State):
def __init__(self):
super().__init__("Main")
self.window = None
def act(self):
logging.info("Entered Main state.")
self.window = MainWindow()
self.window.show()
def do_startup(self):
Gtk.Application.do_startup(self)
self.settings = Settings(self)
self.discoverer = Discoverer()
self.player = Player(self)
self.equalizer = Equalizer(self)
self.queue = Queue(self)
self.history = History(self)
self.integration = Integration(self)
self.win = MainWindow(self)
def __init__(self):
app = QApplication(sys.argv)
width = app.desktop().screenGeometry().width()
height = app.desktop().screenGeometry().height()
Connection() # Initializing database connection
load_setting() # Load Setting from config
load_url() # Load URL List from json file
w = MainWindow(width, height, "Skreepy")
w.setVisible(True)
sys.exit(app.exec_())
def __init__(self):
self.m_settings = None
self.m_parser = None
self.m_window = None
self.m_connected = False
self.m_auto_start = False
self.m_full_screen = False
self.clutch_pedal_effect = None
self.brake_pedal_effect = None
self.throttle_pedal_effect = None
self.m_udp_host = Parser.UDP_IP
self.m_udp_port = Parser.UDP_PORT
self.m_game = Games.DIRT_RALLY
self.ardui_dash = None
self.arduino_com_port = None
self.arduino_baud_rate = None
self.arduino_auto_start = False
self.last_ui_update = None
qt_app = QtWidgets.QApplication(sys.argv)
qt_app.quitOnLastWindowClosed()
self.m_window = MainWindow.init_from_ui(self)
self.load_preferences()
prefix_path = ''
if getattr(sys, 'frozen', False):
# noinspection PyUnresolvedReferences,PyProtectedMember
prefix_path = sys._MEIPASS + '/'
self.m_window.clutch_label.setPixmap(
QtGui.QPixmap(prefix_path + 'res/images/clutch.png'))
self.m_window.brake_label.setPixmap(
QtGui.QPixmap(prefix_path + 'res/images/brake.png'))
self.m_window.throttle_label.setPixmap(
QtGui.QPixmap(prefix_path + 'res/images/throttle.png'))
self.fill_games_menu()
self.clear_ui()
self.ardui_dash = ArduiDash()
if GUI is True:
if self.m_full_screen is True:
self.m_window.showFullScreen()
self.hide_toolbars()
else:
self.m_window.show()
if DEBUG is True:
self.m_parser.enable_parser_debug(flags.log_level)
self.ardui_dash.enable_debug(flags.log_level)
if self.m_auto_start is True:
self.start()
sys.exit(qt_app.exec_())
else:
self.m_parser.enable_parser_debug(2)
self.ardui_dash.enable_debug(2)
self.start()
def sign_up(self, login, password, name):
user = User(login = login, password=password, fullname = str(name))
try:
self.auth_service.create_new_user(user)
messagebox.showinfo(message="User created.")
self.window.destroy()
self.window = Tk()
MainWindow(self.window, user.id, Services.product_service(), Services.user_service(),
Services.physical_stats_service())
except:
messagebox.showinfo(message="User with that login already exists.")
def sign_in(self, login, password):
user = User(login = login, password = password)
try:
user_from_db = self.auth_service.verify_user(user)
self.window.destroy()
self.window = Tk()
MainWindow(self.window, user_from_db.id, Services.product_service(), Services.user_service(),
Services.physical_stats_service())
except Exception as e:
messagebox.showinfo(message="Wrong login or password.")
def show_main_window(self):
self.main_window = MainWindow(self.client.client_name)
self.main_window.logout_signal.connect(self.logout)
self.main_window.start_chatting_signal.connect(self.start_chatting)
self.main_window.send_message_signal.connect(self.send_message)
self.main_window.switch_to_add_contact.connect(self.show_add_contact_window)
self.main_window.switch_to_del_contact.connect(self.show_del_contact_window)
self.make_main_window_signals_connection()
self.main_window.set_elements_disable_status(True)
self.main_window.render_welcome_message()
contacts = self.get_contacts()
self.main_window.render_contacts(contacts)
if self.login_window:
self.login_window.close()
if self.signup_window:
self.signup_window.close()
self.main_window.show()
def run():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument(
'-m',
dest='module',
default='pynodegl_utils.examples',
help='set the module name containing the scene functions')
parser.add_argument(
'-a',
dest='assets_dir',
help='set the assets directory to be used by the scene functions')
parser.add_argument('--hooks-dir',
dest='hooksdir',
help='set the directory path containing event hooks')
pargs = parser.parse_args(sys.argv[1:])
app = QtWidgets.QApplication(sys.argv)
window = MainWindow(pargs.module, pargs.assets_dir, pargs.hooksdir)
window.show()
app.exec_()
def main(argv):
"""
Program entry point
argv: Command line args (excluding the script name)
"""
# Load the ship registry
script_path = os.path.dirname(os.path.abspath(__file__))
ships_json = os.path.join(script_path, "data", "ship_registry.json")
ship_registry = ShipRegistry(ships_json)
# Load the pilot registry
pilots_json = os.path.join(script_path, "data", "pilot_registry.json")
pilot_registry = PilotRegistry(pilots_json, ship_registry)
# Create the board
board = Board()
# Create players for each side
player1 = ConsolePlayer(Faction.imperial, board)
player2 = ConsolePlayer(Faction.rebel, board)
# Wrap these all up in the game object
game = Game(board, [player1, player2], pilot_registry)
# Create the game thread and set it running
game_thread = GameThread(game)
# Build the UI and set it running
root = tk.Tk()
app = MainWindow(board, master=root)
try:
app.mainloop()
except KeyboardInterrupt:
pass
# Once the main window is closed, join the game thread
game_thread.join()
return 0
def main():
app = QgsApplication([], True)
app.setPrefixPath("C:/OSGeo4W64/apps/qgis", True)
app.initQgis()
window = MainWindow()
window.show()
window.raise_()
bb = (635432, 5616219, 635939, 5616575) # WestSouthEastNorth
# bb = (633612, 5619141, 634424, 5619713) # highway
# # streets
streetsPath = ("files/cir/streets.shp")
osmStreets = OsmStreets(extent=bb, extentEPSG=25832)
osmStreets.getBufferedStreets(savePath=streetsPath)
loadVectorLayer(streetsPath, "streets")
streetMaskPath = ("files/cir/streets_mask.tiff")
vector2raster(bb, streetsPath, streetMaskPath)
loadRasterLayer(streetMaskPath, "streetsMask")
# clipping dop with streetMask
dop = ("files/colour/streets_dop.tif")
clippedPathTemp = ("files/colour/streets_clipped_temp.tiff")
clipping(streetMaskPath, dop, clippedPathTemp)
# copy extent and EPSG from streetMaskPath
clippedPath = ("files/colour/streets_clipped.tiff")
CopyExtentandEPSG(streetMaskPath, clippedPathTemp, clippedPath)
loadRasterLayer(clippedPath, "clippedSteets")
#
# # buildings
# buildingsPath = ("files/buildings.shp")
# osmBuildings = OsmBuildings(extent=bb, extentEPSG=25832)
# osmBuildings.getBuildingPolygons(savePath=buildingsPath, onlyWithHeight=False)
# loadVectorLayer(buildingsPath, "buildings")
# buildingMaskPath = ("files/buildings.tiff")
# vector2raster(bb, buildingsPath, buildingMaskPath)
# loadRasterLayer(buildingMaskPath, "buildingsMask")
# water
# waterPath = "files/water.shp"
# osmWater = OsmWater(extent=bb, extentEPSG=25832)
# osmWater.getWaterPolygons(savePath=waterPath)
# loadVectorLayer(waterPath, "water")
# waterMaskPath = "files/water.tiff"
# vector2raster(bb, waterPath, waterMaskPath)
# loadRasterLayer(waterMaskPath, "waterMask")
# set CRS to the one of image and zoom to extent
crs = QgsCoordinateReferenceSystem()
crs.createFromId(25832)
window.canvas.setDestinationCrs(crs)
exitcode = app.exec_()
QgsApplication.exitQgis()
sys.exit(exitcode)
def run():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument(
'-m',
dest='module',
default='pynodegl_utils.examples',
help='set the module name containing the scene functions')
parser.add_argument(
'-a',
dest='assets_dir',
help='set the assets directory to be used by the scene functions')
parser.add_argument('--hooks-dir',
dest='hooksdir',
help='set the directory path containing event hooks')
pargs = parser.parse_args(sys.argv[1:])
app = QtWidgets.QApplication(sys.argv)
# Fixes ui freezes with the native gl view on macos 10.14 (mojave)
app.setAttribute(QtCore.Qt.AA_DontCreateNativeWidgetSiblings)
window = MainWindow(pargs.module, pargs.assets_dir, pargs.hooksdir)
window.show()
app.exec_()
def __init__(self,ip='',port=9011,peer_id=-1,build_ui = True, log = None):
# Node state
if ip == '':
self.ip = self._getIP()
else:
self.ip = ip
if not log:
log = Log('livesession')
self.id = peer_id
self.port = port
self.log = log
self.name = '{0}:{1}'.format(self.ip,port)
self.state = PeerState(peer_id, self.log)
self.state.ip = self.ip
self.state.port = self.port
self.state.ips.append(self.state.ip)
self.state.ports.append(self.state.port)
# Print start
log.blue('\n\nINIT', self.id)
log.blue('-'*(len(self.ip.__str__())+len(self.port.__str__())+3))
self.log.blue(self.ip, ":", self.port)
log.blue('-'*(len(self.ip.__str__())+len(self.port.__str__())+3))
# Init main UI
if build_ui:
self.window = MainWindow(self.state)
self.window.show()
self.window.raise_()
self.state.window = self.window
self.state.newStrokesSignal.connect(self.window.scribbleArea.strokesSignalHandler)
# Handler for the RPC requests
self.RPCresponder = RPCresponder(self.state)
# Accept incoming connections in a background thread
self.server = SimpleXMLRPCServer((ip,port),logRequests=False,bind_and_activate=False)
self.server.server_bind()
self.server.server_activate()
self.server.register_introspection_functions()
self.server.register_instance(self.RPCresponder)
t = Thread(target = self._run,name='{0}:{1}'.format(ip,port))
t.daemon = True
t.start()
def run(self):
print('Waiting to initial connection to server...')
while not self.servers_db.selected:
ip = Ip(self.queue.get())
if ip.protocol != 6: continue
tcp = Tcp(ip.data)
if len(tcp.data) == 4 and tcp.data.get_array_int(1) == [1, 0, 0, 0]:
self.servers_db.selected = self.servers_db[ip.source_addr]
print('Conected to: ' + self.servers_db.selected['name'])
MainWindow().SetServerName(self.servers_db.selected['name'])
while len(self.server_keys) < 2 or len(self.client_keys) < 2:
ip = Ip(self.queue.get())
if ip.protocol != 6 or (ip.source_addr != self.servers_db.selected['ip'] and ip.destination_addr != self.servers_db.selected['ip']): continue
tcp = Tcp(ip.data)
if tcp.data.len() == 128:
if ip.source_addr == self.servers_db.selected['ip']: # received
self.server_keys.append(tcp.data)
else: # sent
self.client_keys.append(tcp.data)
self.session = Session(self.server_keys, self.client_keys)
SkillDatabase().read(self.servers_db.selected['location'])
HotDotDatabase().read(self.servers_db.selected['location'])
NpcDatabase().read(self.servers_db.selected['location'])
while self.enable:
ip = Ip(self.queue.get())
if ip.protocol != 6 or (ip.source_addr != self.servers_db.selected['ip'] and ip.destination_addr != self.servers_db.selected['ip']): continue
tcp = Tcp(ip.data)
if not tcp.data.len(): continue
if ip.source_addr == self.servers_db.selected['ip']: # received
self.session.encrypt(tcp.data)
self.s_splitter.add_data(tcp.data)
else: # sent
self.session.decrypt(tcp.data)
self.c_splitter.add_data(tcp.data)
from tkinter import Tk
from ui.main_window import MainWindow
if __name__ == '__main__':
root = Tk()
mw = MainWindow(root)
root.mainloop()
import resource
import sys
from PyQt5.QtWidgets import QApplication
from ui.main_window import MainWindow
if __name__ == "__main__":
# Increasing size of stack to be able to pickle
print(resource.getrlimit(resource.RLIMIT_STACK))
print(sys.getrecursionlimit())
max_rec = 0x100000
# May segfault without this line. 0x100 is a guess at the size of each stack frame.
resource.setrlimit(resource.RLIMIT_STACK, [0x100 * max_rec, resource.RLIM_INFINITY])
sys.setrecursionlimit(max_rec)
app = QApplication(sys.argv)
mySW = MainWindow()
mySW.show()
sys.exit(app.exec_())
import qdarkstyle
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QApplication, QMessageBox
from ui.main_window import MainWindow
if __name__ == '__main__':
app = QApplication([])
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
if os.path.isfile('config.json'):
with open('config.json') as f:
config = json.load(f)
application = MainWindow(app, config)
# Disable window resize and the maximize button
application.setWindowFlags(Qt.WindowCloseButtonHint
| Qt.WindowMinimizeButtonHint)
application.show()
application.setFixedSize(application.size())
sys.exit(app.exec_())
else:
msg = QMessageBox()
msg.setWindowTitle('Config missing')
msg.setText(
"""<p style='text-align: center;'><img src='ui/assets/warning-icon.png' alt='' width='42' height='42'/></p>
<p style='align: center;'><strong>config.json file is missing, cannot continue !</strong></p>"""
class Peer:
def __init__(self,ip='',port=9011,peer_id=-1,build_ui = True, log = None):
# Node state
if ip == '':
self.ip = self._getIP()
else:
self.ip = ip
if not log:
log = Log('livesession')
self.id = peer_id
self.port = port
self.log = log
self.name = '{0}:{1}'.format(self.ip,port)
self.state = PeerState(peer_id, self.log)
self.state.ip = self.ip
self.state.port = self.port
self.state.ips.append(self.state.ip)
self.state.ports.append(self.state.port)
# Print start
log.blue('\n\nINIT', self.id)
log.blue('-'*(len(self.ip.__str__())+len(self.port.__str__())+3))
self.log.blue(self.ip, ":", self.port)
log.blue('-'*(len(self.ip.__str__())+len(self.port.__str__())+3))
# Init main UI
if build_ui:
self.window = MainWindow(self.state)
self.window.show()
self.window.raise_()
self.state.window = self.window
self.state.newStrokesSignal.connect(self.window.scribbleArea.strokesSignalHandler)
# Handler for the RPC requests
self.RPCresponder = RPCresponder(self.state)
# Accept incoming connections in a background thread
self.server = SimpleXMLRPCServer((ip,port),logRequests=False,bind_and_activate=False)
self.server.server_bind()
self.server.server_activate()
self.server.register_introspection_functions()
self.server.register_instance(self.RPCresponder)
t = Thread(target = self._run,name='{0}:{1}'.format(ip,port))
t.daemon = True
t.start()
def __str__(self):
return 'peer {0} - {1}'.format(self.id,self.name)
def _run(self):
""" Accept incoming connection till exit """
self.server.serve_forever()
def _getIP(self):
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('google.com',80))
ip = s.getsockname()[0]
s.close()
return ip
def kill(self):
self.log.red( self,'=> killed')
self.RPCresponder.kill()
def revive(self):
self.log.green( self,'=> revived')
self.RPCresponder.revive()
def setUnreliable(self):
self.log.red( self,'=> unreliable')
self.RPCresponder.setUnreliable()
def setReliable(self):
self.log.green( self,'=> reliable')
self.RPCresponder.setReliable()
def addPeer(self,ip,port):
""" Add a new peer """
self.state.addPeer(ip,port)
def getStrokes(self):
return self.state.getStrokes()
def thaw(self, sid):
self.state.thaw(sid)
def freeze(self, sid):
self.state.freeze(sid)
def setup_hook():
_excepthook = sys.excepthook
def hook(exctype, value, traceback):
print(exctype, value, traceback)
_excepthook(exctype, value, traceback)
sys.exit(1)
sys.excepthook = hook
if __name__ == '__main__':
setup_hook()
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
app = QApplication(sys.argv)
app.setWindowIcon(QIcon(':/icon/img/logo.png'))
w = MainWindow()
cp = QDesktopWidget().availableGeometry().center()
qr = w.frameGeometry()
qr.moveCenter(cp)
w.move(qr.topLeft())
w.show()
w.tabs_container.setCurrentIndex(0)
try:
sys.exit(app.exec_())
except:
pass
# Joao Victor Fagundes
# Salomao Rodrigues Jacinto
# INE5421 - Trablho Prático II Junho 2018
import sys
from ui.main_window import MainWindow
from PyQt5.QtWidgets import QApplication
if __name__ == "__main__":
app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())
if __name__ == '__main__':
print('Reading databases...')
servers_db = ServerDatabase()
abnormal_db = AbnormalDatabase()
hot_dot_db = HotDotDatabase()
icon_db = IconDatabase()
npc_db = NpcDatabase()
skill_db = SkillDatabase()
opcodes_db = OpcodesDatabase()
tracker = Tracker()
app = wx.App()
ui = MainWindow()
msg_handler = MessagesHandler()
c_splitter = BlockSplitter(MessageDirection(1), msg_handler.messages)
s_splitter = BlockSplitter(MessageDirection(2), msg_handler.messages)
con_handler = ConnectionHandler(c_splitter, s_splitter)
sniffer = Sniffer(con_handler.queue)
msg_handler.start()
c_splitter.start()
s_splitter.start()
con_handler.start()
sniffer.start()
app.MainLoop() # hold in UI loop
from PyQt5.Qt import QApplication
from PyQt5.QtWidgets import QMessageBox
from ui.main_window import MainWindow
from core.session import Session
from core.util import Utility
import sys
import logging
CONFIG_FILE_PATH = "config/config.conf"
if __name__ == '__main__':
app = QApplication(sys.argv)
logging.basicConfig(level=logging.INFO)
try:
session = Session(CONFIG_FILE_PATH)
except ValueError as e:
QMessageBox.warning(None, "Error", "Error parsing config file...")
sys.exit(1)
except (OSError, IOError) as e:
QMessageBox.warning(None, "Error", "Couldn't open config file")
sys.exit(1)
main_window = MainWindow(app.desktop(), session)
main_window.show()
sys.exit(app.exec_())
def write(self, message):
os.write(self.fd, message.encode())
def flush(self):
pass
if __name__ == '__main__':
app = QApplication(sys.argv)
window = QMainWindow()
# capture file descriptors, responsible for stderr and stdout and pass them to console for logging
stdout_descriptor = sys.stdout.fileno()
new_stdout, in_write = os.pipe()
os.dup2(in_write, stdout_descriptor)
sys.stdout = FDWrapper(in_write)
dark = '--dark' in sys.argv
if dark:
stylesheet = load_stylesheet_pyqt5()
window.setStyleSheet(stylesheet)
main_ui = MainWindow(window, new_stdout, dark)
main_ui.setupUi(window)
main_ui.initialize()
print('Ready.')
window.show()
sys.exit(app.exec_())
def main():
app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())
from PySide2.QtGui import QIcon
# custom style
from pdi.widgets.qstyle import darkstyle
# main window
from ui.main_window import MainWindow
# logger utility
from util.setup_log import setupLogger
if __name__ == "__main__":
os.chdir(os.path.dirname(os.path.abspath(os.path.join(__file__, "../"))))
print(os.getcwd())
print("AAA")
# アプリケーション作成
app = QApplication(sys.argv)
# app.setWindowIcon(QIcon("icon.png"))
# オブジェクト作成
window = MainWindow(sys.argv)
# MainWindowの表示
window.show()
window.resize(1200, 800)
ret = app.exec_()
print(ret)
sys.exit(ret)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
from ui.main_window import MainWindow
if __name__ == '__main__':
import sys
app = QtGui.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec_())
from ui.main_window import MainWindow
if __name__ == "__main__":
MainWindow()
ga_solver = GASolver(n_population=8)
final_state = ga_solver.solve()
final_state.print_chessboard()
print(final_state.get_attacking_count())
print(ga_solver.get_running_time(), ga_solver.get_expanded_count(),
ga_solver.get_cost())
csp = CSPSolver()
csp.solve(state)
print("Number steps to the final solution =", csp.get_cost())
csp.final_sol.print_chessboard()
print("Expanded node count =", csp.get_expanded_count())
print("Execution time in milliseconds =", csp.get_running_time())
# hill = HillClimbingSolver()
# hill.solve(ChessboardStateNode(state), 'rr')
# print("Number steps to the final solution =", hill.get_cost())
# hill.get_final_solution().print_chessboard()
# print("Number of attacks in the final solution =", hill.conflictions_count)
# print("Expanded node count =", hill.get_expanded_count())
# print("Execution time in milliseconds =", hill.get_running_time())
#
# print(len(state.neighbors()));
# GUI
app = QtWidgets.QApplication(sys.argv)
main = MainWindow()
main.setWindowTitle("8 Queens")
main.show()
sys.exit(app.exec_())
import sys
from PySide.QtGui import QApplication
from ui.main_window import MainWindow
APP_NAME = 'Dreamer'
class DreamerApp(QApplication):
def __init__(self, *args, **kwargs):
QApplication.__init__(self, *args, **kwargs)
self.setApplicationName(APP_NAME)
app = DreamerApp(sys.argv)
if __name__ == "__main__":
window = MainWindow()
window.setWindowTitle(APP_NAME)
window.show()
return_code = app.exec_()
sys.exit(return_code)
import sys
from ui.main_window import MainWindow
from PyQt5 import QtWidgets
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
main = MainWindow()
main.show()
sys.exit(app.exec_())
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('GtkSource', '3.0')
from gi.repository import Gtk
from graph.source_graph import SourceGraph
import logging
import os.path
import signal
import sys
from ui.main_window import MainWindow
from workspace import Workspace
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
signal.signal(signal.SIGINT, signal.SIG_DFL)
ws_dir = '.workspace'
if len(sys.argv) == 2:
ws_dir = sys.argv[1]
if not os.path.isdir(ws_dir):
logging.warn(
'Workspace doesn\'t exist: {}'.format(ws_dir))
workspace = Workspace(ws_dir)
src_graph = SourceGraph(workspace)
win = MainWindow(workspace, src_graph)
win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()
#!/usr/bin/python3
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, GdkPixbuf, GObject, GLib
import os
from ui.main_window import MainWindow
from ui.view_service_window import ViewServiceWindow
log_viewer = MainWindow()
Gtk.main()
#!/usr/bin/env python3
# Make sure to find pyVFRendering, nanogui and ovf if manually built
# This is only needed if you did not install the package
#
# import sys
# import os
# pyVFRenderingDir = os.path.abspath(os.path.join(os.path.dirname( __file__ ), "VFRendering/build/Release"))
# sys.path.insert(0, pyVFRenderingDir)
# nanoguiDir = os.path.abspath(os.path.join(os.path.dirname( __file__ ), "nanogui/build/Release/python"))
# sys.path.insert(0, nanoguiDir)
# nanoguiDir = os.path.abspath(os.path.join(os.path.dirname( __file__ ), "ovf/python"))
# sys.path.insert(0, nanoguiDir)
import nanogui
import gc
from ui.main_window import MainWindow
if __name__ == '__main__':
nanogui.init()
win = MainWindow(800, 600)
win.setVisible(True)
nanogui.mainloop(refresh=1000)
del win
gc.collect
nanogui.shutdown()
# -*- coding: UTF-8 -*-
'''
Created on 28/09/2010
@author: rodrigo
'''
import logging
import sip
sip.setapi('QString', 2)
sip.setapi('QVariant', 2)
logging.basicConfig(level=logging.DEBUG)
logging.getLogger(__name__).debug("Inicializando")
if __name__ == '__main__':
from PyQt4.QtGui import QApplication
from ui.main_window import MainWindow
import sys
import core
core.models.initDB()
app = QApplication(sys.argv)
window = MainWindow()
window.show()
app.exec_()
from PyQt5.QtWidgets import QApplication from application_service.get_map_uc import GetMapUseCase from serveces.YandexMapAdapter import YandexMapAdapter from ui.main_window import MainWindow adapter = YandexMapAdapter() use_case = GetMapUseCase(adapter) app = QApplication([]) win = MainWindow(use_case) win.show() app.exec()
import sys
import argparse
from PyQt5.QtWidgets import QApplication
from ui.main_window import MainWindow
def parse_arguments():
parser = argparse.ArgumentParser("Argument parser for decision system")
parser.add_argument("-p",
"--path",
help="Path to the file with decision graph to import",
type=str)
return parser.parse_args()
if __name__ == '__main__':
args = parse_arguments()
app = QApplication([])
main_window = MainWindow()
if args.path:
main_window.import_from_path(args.path)
pass
sys.exit(app.exec_())
